Removes the grid from ash.

ash/wm/workspace/workspace_window_resizer_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 "ash/wm/workspace/workspace_window_resizer.h"
 
 #include "ash/display/mouse_cursor_event_filter.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
@@ skipping 89 matching lines @@
       if (*i == window_.get() || *i == window2_.get() || *i == window3_.get()) {
         if (!result.empty())
           result += " ";
         result += base::IntToString((*i)->id());
       }
     }
     return result;
   }
 
  protected:
-  void SetGridSize(int grid_size) {
-    Shell::TestApi shell_test(Shell::GetInstance());
-    shell_test.workspace_controller()->SetGridSize(grid_size);
-  }
-
   gfx::Point CalculateDragPoint(const WorkspaceWindowResizer& resizer,
                                 int delta_x,
                                 int delta_y) const {
     gfx::Point location = resizer.initial_location_in_parent();
     location.set_x(location.x() + delta_x);
     location.set_y(location.y() + delta_y);
     return location;
   }
 
   std::vector<aura::Window*> empty_windows() const {
@@ skipping 29 matching lines @@
 #endif
 
 // Assertions around attached window resize dragging from the right with 2
 // windows.
 TEST_F(WorkspaceWindowResizerTest, AttachedResize_RIGHT_2) {
   window_->SetBounds(gfx::Rect(0, 300, 400, 300));
   window2_->SetBounds(gfx::Rect(400, 200, 100, 200));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
-  SetGridSize(0);
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTRIGHT, windows));
   ASSERT_TRUE(resizer.get());
   // Move it 100 to the right, which should expand w1 and push w2.
   resizer->Drag(CalculateDragPoint(*resizer, 100, 10), 0);
   EXPECT_EQ("0,300 500x300", window_->bounds().ToString());
   EXPECT_EQ("500,200 100x200", window2_->bounds().ToString());
 
   // Push off the screen, w2 should be resized to its min.
   delegate2_.set_min_size(gfx::Size(20, 20));
@@ skipping 13 matching lines @@
   EXPECT_EQ("400,200 100x200", window2_->bounds().ToString());
 }
 
 // Assertions around collapsing and expanding.
 TEST_F(WorkspaceWindowResizerTest, AttachedResize_RIGHT_Compress) {
   window_->SetBounds(gfx::Rect(   0, 300, 400, 300));
   window2_->SetBounds(gfx::Rect(400, 200, 100, 200));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
-  SetGridSize(0);
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTRIGHT, windows));
   ASSERT_TRUE(resizer.get());
   // Move it 100 to the left, which should expand w2 and collapse w1.
   resizer->Drag(CalculateDragPoint(*resizer, -100, 10), 0);
   EXPECT_EQ("0,300 300x300", window_->bounds().ToString());
   EXPECT_EQ("300,200 200x200", window2_->bounds().ToString());
 
   // Collapse all the way to w1's min.
   delegate_.set_min_size(gfx::Size(20, 20));
@@ skipping 17 matching lines @@
 TEST_F(WorkspaceWindowResizerTest, AttachedResize_RIGHT_3) {
   window_->SetBounds(gfx::Rect( 100, 300, 200, 300));
   window2_->SetBounds(gfx::Rect(300, 300, 150, 200));
   window3_->SetBounds(gfx::Rect(450, 300, 100, 200));
   delegate2_.set_min_size(gfx::Size(52, 50));
   delegate3_.set_min_size(gfx::Size(38, 50));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   windows.push_back(window3_.get());
-  SetGridSize(10);
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTRIGHT, windows));
   ASSERT_TRUE(resizer.get());
   // Move it 100 to the right, which should expand w1 and push w2 and w3.
   resizer->Drag(CalculateDragPoint(*resizer, 100, -10), 0);
   EXPECT_EQ("100,300 300x300", window_->bounds().ToString());
   EXPECT_EQ("400,300 150x200", window2_->bounds().ToString());
   EXPECT_EQ("550,300 100x200", window3_->bounds().ToString());
 
-  // Move it 296, which should now snap to grid and things should compress.
-  resizer->Drag(CalculateDragPoint(*resizer, 296, -10), 0);
+  // Move it 300, things should compress.
+  resizer->Drag(CalculateDragPoint(*resizer, 300, -10), 0);
   EXPECT_EQ("100,300 500x300", window_->bounds().ToString());
   EXPECT_EQ("600,300 120x200", window2_->bounds().ToString());
   EXPECT_EQ("720,300 80x200", window3_->bounds().ToString());
 
-  // Move it so much everything ends up at its min.
-  resizer->Drag(CalculateDragPoint(*resizer, 798, 50), 0);
-  EXPECT_EQ("100,300 600x300", window_->bounds().ToString());
-  EXPECT_EQ("700,300 60x200", window2_->bounds().ToString());
-  EXPECT_EQ("760,300 40x200", window3_->bounds().ToString());
+  // Move it so much the last two end up at their min.
+  resizer->Drag(CalculateDragPoint(*resizer, 800, 50), 0);
+  EXPECT_EQ("100,300 610x300", window_->bounds().ToString());
+  EXPECT_EQ("710,300 52x200", window2_->bounds().ToString());
+  EXPECT_EQ("762,300 38x200", window3_->bounds().ToString());
 
   // Revert and make sure everything moves back.
   resizer->RevertDrag();
   EXPECT_EQ("100,300 200x300", window_->bounds().ToString());
   EXPECT_EQ("300,300 150x200", window2_->bounds().ToString());
   EXPECT_EQ("450,300 100x200", window3_->bounds().ToString());
 }
 
 // Assertions around attached window resizing (collapsing and expanding) with
 // 3 windows.
 TEST_F(WorkspaceWindowResizerTest, AttachedResize_RIGHT_3_Compress) {
   window_->SetBounds(gfx::Rect( 100, 300, 200, 300));
   window2_->SetBounds(gfx::Rect(300, 300, 200, 200));
   window3_->SetBounds(gfx::Rect(450, 300, 100, 200));
   delegate2_.set_min_size(gfx::Size(52, 50));
   delegate3_.set_min_size(gfx::Size(38, 50));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   windows.push_back(window3_.get());
-  SetGridSize(10);
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTRIGHT, windows));
   ASSERT_TRUE(resizer.get());
   // Move it -100 to the right, which should collapse w1 and expand w2 and w3.
   resizer->Drag(CalculateDragPoint(*resizer, -100, -10), 0);
   EXPECT_EQ("100,300 100x300", window_->bounds().ToString());
-  EXPECT_EQ("200,300 270x200", window2_->bounds().ToString());
-  EXPECT_EQ("470,300 130x200", window3_->bounds().ToString());
+  EXPECT_EQ("200,300 266x200", window2_->bounds().ToString());
+  EXPECT_EQ("466,300 134x200", window3_->bounds().ToString());
 
   // Move it 100 to the right.
   resizer->Drag(CalculateDragPoint(*resizer, 100, -10), 0);
   EXPECT_EQ("100,300 300x300", window_->bounds().ToString());
   EXPECT_EQ("400,300 200x200", window2_->bounds().ToString());
   EXPECT_EQ("600,300 100x200", window3_->bounds().ToString());
 
   // 100 to the left again.
   resizer->Drag(CalculateDragPoint(*resizer, -100, -10), 0);
   EXPECT_EQ("100,300 100x300", window_->bounds().ToString());
-  EXPECT_EQ("200,300 270x200", window2_->bounds().ToString());
-  EXPECT_EQ("470,300 130x200", window3_->bounds().ToString());
+  EXPECT_EQ("200,300 266x200", window2_->bounds().ToString());
+  EXPECT_EQ("466,300 134x200", window3_->bounds().ToString());
 }
 
 // Assertions around collapsing and expanding from the bottom.
 TEST_F(WorkspaceWindowResizerTest, AttachedResize_BOTTOM_Compress) {
   window_->SetBounds(gfx::Rect(   0, 100, 400, 300));
   window2_->SetBounds(gfx::Rect(400, 400, 100, 200));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
-  SetGridSize(0);
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTBOTTOM, windows));
   ASSERT_TRUE(resizer.get());
   // Move it up 100, which should expand w2 and collapse w1.
   resizer->Drag(CalculateDragPoint(*resizer, 10, -100), 0);
   EXPECT_EQ("0,100 400x200", window_->bounds().ToString());
   EXPECT_EQ("400,300 100x300", window2_->bounds().ToString());
 
   // Collapse all the way to w1's min.
   delegate_.set_min_size(gfx::Size(20, 20));
@@ skipping 13 matching lines @@
 }
 
 // Assertions around attached window resize dragging from the bottom with 2
 // windows.
 TEST_F(WorkspaceWindowResizerTest, AttachedResize_BOTTOM_2) {
   window_->SetBounds(gfx::Rect( 0,  50, 400, 200));
   window2_->SetBounds(gfx::Rect(0, 250, 200, 100));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
-  SetGridSize(0);
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTBOTTOM, windows));
   ASSERT_TRUE(resizer.get());
   // Move it 100 to the bottom, which should expand w1 and push w2.
   resizer->Drag(CalculateDragPoint(*resizer, 10, 100), 0);
   EXPECT_EQ("0,50 400x300", window_->bounds().ToString());
   EXPECT_EQ("0,350 200x100", window2_->bounds().ToString());
 
   // Push off the screen, w2 should be resized to its min.
   delegate2_.set_min_size(gfx::Size(20, 20));
@@ skipping 31 matching lines @@
 
   window_->SetBounds(gfx::Rect( 300, 100, 300, 200));
   window2_->SetBounds(gfx::Rect(300, 300, 200, 150));
   window3_->SetBounds(gfx::Rect(300, 450, 200, 100));
   delegate2_.set_min_size(gfx::Size(50, 52));
   delegate3_.set_min_size(gfx::Size(50, 38));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   windows.push_back(window3_.get());
-  SetGridSize(10);
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTBOTTOM, windows));
   ASSERT_TRUE(resizer.get());
   // Move it 100 to the right, which should expand w1 and push w2 and w3.
   resizer->Drag(CalculateDragPoint(*resizer, -10, 100), 0);
   EXPECT_EQ("300,100 300x300", window_->bounds().ToString());
   EXPECT_EQ("300,400 200x150", window2_->bounds().ToString());
   EXPECT_EQ("300,550 200x100", window3_->bounds().ToString());
 
-  // Move it 296, which should now snap to grid and things should compress.
+  // Move it 296 things should compress.
   resizer->Drag(CalculateDragPoint(*resizer, -10, 296), 0);
-  EXPECT_EQ("300,100 300x500", window_->bounds().ToString());
-  EXPECT_EQ("300,600 200x120", window2_->bounds().ToString());
-  EXPECT_EQ("300,720 200x80", window3_->bounds().ToString());
+  EXPECT_EQ("300,100 300x496", window_->bounds().ToString());
+  EXPECT_EQ("300,596 200x122", window2_->bounds().ToString());
+  EXPECT_EQ("300,718 200x82", window3_->bounds().ToString());
 
   // Move it so much everything ends up at its min.
   resizer->Drag(CalculateDragPoint(*resizer, 50, 798), 0);
-  EXPECT_EQ("300,100 300x600", window_->bounds().ToString());
-  EXPECT_EQ("300,700 200x60", window2_->bounds().ToString());
-  EXPECT_EQ("300,760 200x40", window3_->bounds().ToString());
+  EXPECT_EQ("300,100 300x610", window_->bounds().ToString());
+  EXPECT_EQ("300,710 200x52", window2_->bounds().ToString());
+  EXPECT_EQ("300,762 200x38", window3_->bounds().ToString());
 
   // Revert and make sure everything moves back.
   resizer->RevertDrag();
   EXPECT_EQ("300,100 300x200", window_->bounds().ToString());
   EXPECT_EQ("300,300 200x150", window2_->bounds().ToString());
   EXPECT_EQ("300,450 200x100", window3_->bounds().ToString());
 }
 
 // Assertions around attached window resizing (collapsing and expanding) with
 // 3 windows.
 TEST_F(WorkspaceWindowResizerTest, AttachedResize_BOTTOM_3_Compress) {
   window_->SetBounds(gfx::Rect(  0,   0, 200, 200));
   window2_->SetBounds(gfx::Rect(10, 200, 200, 200));
   window3_->SetBounds(gfx::Rect(20, 400, 100, 100));
   delegate2_.set_min_size(gfx::Size(52, 50));
   delegate3_.set_min_size(gfx::Size(38, 50));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   windows.push_back(window3_.get());
-  SetGridSize(10);
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTBOTTOM, windows));
   ASSERT_TRUE(resizer.get());
   // Move it 100 up, which should collapse w1 and expand w2 and w3.
   resizer->Drag(CalculateDragPoint(*resizer, -10, -100), 0);
   EXPECT_EQ("0,0 200x100", window_->bounds().ToString());
-  EXPECT_EQ("10,100 200x270", window2_->bounds().ToString());
-  EXPECT_EQ("20,370 100x130", window3_->bounds().ToString());
+  EXPECT_EQ("10,100 200x266", window2_->bounds().ToString());
+  EXPECT_EQ("20,366 100x134", window3_->bounds().ToString());
 
   // Move it 100 down.
   resizer->Drag(CalculateDragPoint(*resizer, 10, 100), 0);
   EXPECT_EQ("0,0 200x300", window_->bounds().ToString());
   EXPECT_EQ("10,300 200x200", window2_->bounds().ToString());
   EXPECT_EQ("20,500 100x100", window3_->bounds().ToString());
 
   // 100 up again.
   resizer->Drag(CalculateDragPoint(*resizer, -10, -100), 0);
   EXPECT_EQ("0,0 200x100", window_->bounds().ToString());
-  EXPECT_EQ("10,100 200x270", window2_->bounds().ToString());
-  EXPECT_EQ("20,370 100x130", window3_->bounds().ToString());
+  EXPECT_EQ("10,100 200x266", window2_->bounds().ToString());
+  EXPECT_EQ("20,366 100x134", window3_->bounds().ToString());
 }
 
 // Assertions around dragging to the left/right edge of the screen.
 TEST_F(WorkspaceWindowResizerTest, Edge) {
   int bottom =
       ScreenAsh::GetUnmaximizedWorkAreaBoundsInParent(window_.get()).bottom();
   window_->SetBounds(gfx::Rect(20, 30, 50, 60));
   {
-    SetGridSize(0);
     scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
         window_.get(), gfx::Point(), HTCAPTION, empty_windows()));
     ASSERT_TRUE(resizer.get());
     resizer->Drag(CalculateDragPoint(*resizer, 0, 10), 0);
     resizer->CompleteDrag(0);
     EXPECT_EQ("0,0 720x" + base::IntToString(bottom),
               window_->bounds().ToString());
     ASSERT_TRUE(GetRestoreBoundsInScreen(window_.get()));
     EXPECT_EQ("20,30 50x60",
               GetRestoreBoundsInScreen(window_.get())->ToString());
   }
 
   // Try the same with the right side.
-  SetGridSize(0);
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTCAPTION, empty_windows()));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, 800, 10), 0);
   resizer->CompleteDrag(0);
   EXPECT_EQ("80,0 720x" + base::IntToString(bottom),
             window_->bounds().ToString());
   ASSERT_TRUE(GetRestoreBoundsInScreen(window_.get()));
   EXPECT_EQ("20,30 50x60", GetRestoreBoundsInScreen(window_.get())->ToString());
 }
 
 // Verifies a window can be moved from the primary display to another.
 TEST_F(WorkspaceWindowResizerTest, MAYBE_WindowDragWithMultiMonitors) {
   // The secondary display is logically on the right, but on the system (e.g. X)
   // layer, it's below the primary one. See UpdateDisplay() in ash_test_base.cc.
   UpdateDisplay("800x600,800x600");
   Shell::GetInstance()->shelf()->LayoutShelf();
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   ASSERT_EQ(2U, root_windows.size());
 
   window_->SetBoundsInScreen(gfx::Rect(0, 0, 50, 60),
                              gfx::Screen::GetPrimaryDisplay());
   EXPECT_EQ(root_windows[0], window_->GetRootWindow());
   {
-    SetGridSize(0);
     // Grab (0, 0) of the window.
     scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
         window_.get(), gfx::Point(), HTCAPTION, empty_windows()));
     ASSERT_TRUE(resizer.get());
     // Drag the pointer to the right. Once it reaches the right edge of the
     // primary display, it warps to the secondary. Since the secondary root
     // window's native origin held by aura::RootWindowHost is (0, 600), and a
     // mouse drag event has a location in the primary root window's coordinates,
     // (0, 610) below means (0, 10) in the second root window's coordinates.
     resizer->Drag(CalculateDragPoint(*resizer, 0, 610), 0);
@@ skipping 22 matching lines @@
 
   window_->SetBoundsInScreen(gfx::Rect(0, 0, 50, 60),
                              gfx::Screen::GetPrimaryDisplay());
   EXPECT_EQ(root_windows[0], window_->GetRootWindow());
   {
     // Grab the top-right edge of the window and move the pointer to (0, 10)
     // in the secondary root window's coordinates.
     scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
         window_.get(), gfx::Point(49, 0), HTCAPTION, empty_windows()));
     ASSERT_TRUE(resizer.get());
-    resizer->Drag(CalculateDragPoint(*resizer, -49, 610), 0);
+    resizer->Drag(CalculateDragPoint(*resizer, -49, 610), ui::EF_CONTROL_DOWN);
     resizer->CompleteDrag(0);
     // Since the pointer is on the secondary, the parent should not be changed
     // even though only small fraction of the window is within the secondary
     // root window's bounds.
     EXPECT_EQ(root_windows[1], window_->GetRootWindow());
     EXPECT_EQ("-49,10 50x60", window_->bounds().ToString());
   }
 }
 
 // Verifies a window can be moved from the secondary display to primary.
 TEST_F(WorkspaceWindowResizerTest,
        MAYBE_WindowDragWithMultiMonitorsRightToLeft) {
   UpdateDisplay("800x600,800x600");
   Shell::GetInstance()->shelf()->LayoutShelf();
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   ASSERT_EQ(2U, root_windows.size());
 
   window_->SetBoundsInScreen(
       gfx::Rect(800, 00, 50, 60),
       gfx::Screen::GetDisplayNearestWindow(root_windows[1]));
   EXPECT_EQ(root_windows[1], window_->GetRootWindow());
   {
-    SetGridSize(0);
     // Grab (0, 0) of the window.
     scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
         window_.get(), gfx::Point(), HTCAPTION, empty_windows()));
     ASSERT_TRUE(resizer.get());
     // Move the mouse near the right edge, (798, 0), of the primary display.
-    resizer->Drag(CalculateDragPoint(*resizer, 798, -600), 0);
+    resizer->Drag(CalculateDragPoint(*resizer, 798, -600), ui::EF_CONTROL_DOWN);
     resizer->CompleteDrag(0);
     EXPECT_EQ(root_windows[0], window_->GetRootWindow());
     EXPECT_EQ("798,0 50x60", window_->bounds().ToString());
   }
 }
 
 // Verifies the style of the drag phantom window is correct.
 TEST_F(WorkspaceWindowResizerTest, MAYBE_PhantomStyle) {
   UpdateDisplay("800x600,800x600");
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   ASSERT_EQ(2U, root_windows.size());
 
   window_->SetBoundsInScreen(gfx::Rect(0, 0, 50, 60),
                              gfx::Screen::GetPrimaryDisplay());
   EXPECT_EQ(root_windows[0], window_->GetRootWindow());
   EXPECT_FLOAT_EQ(1.0f, window_->layer()->opacity());
   {
-    SetGridSize(0);
     scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
         window_.get(), gfx::Point(), HTCAPTION, empty_windows()));
     ASSERT_TRUE(resizer.get());
     EXPECT_FALSE(resizer->snap_phantom_window_controller_.get());
     EXPECT_FALSE(resizer->drag_phantom_window_controller_.get());
 
     // The pointer is inside the primary root. Both phantoms should be NULL.
     resizer->Drag(CalculateDragPoint(*resizer, 10, 10), 0);
     EXPECT_FALSE(resizer->snap_phantom_window_controller_.get());
     EXPECT_FALSE(resizer->drag_phantom_window_controller_.get());
@@ skipping 106 matching lines @@
 
 // Verifies windows are correctly restacked when reordering multiple windows.
 TEST_F(WorkspaceWindowResizerTest, RestackAttached) {
   window_->SetBounds(gfx::Rect(   0, 0, 200, 300));
   window2_->SetBounds(gfx::Rect(200, 0, 100, 200));
   window3_->SetBounds(gfx::Rect(300, 0, 100, 100));
 
   {
     std::vector<aura::Window*> windows;
     windows.push_back(window2_.get());
-    SetGridSize(10);
     scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
         window_.get(), gfx::Point(), HTRIGHT, windows));
     ASSERT_TRUE(resizer.get());
     // Move it 100 to the right, which should expand w1 and push w2 and w3.
     resizer->Drag(CalculateDragPoint(*resizer, 100, -10), 0);
 
     // 2 should be topmost since it's initially the highest in the stack.
     EXPECT_EQ("2 1 3", WindowOrderAsString(window_->parent()));
   }
 
   {
     std::vector<aura::Window*> windows;
     windows.push_back(window3_.get());
-    SetGridSize(10);
     scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
         window2_.get(), gfx::Point(), HTRIGHT, windows));
     ASSERT_TRUE(resizer.get());
     // Move it 100 to the right, which should expand w1 and push w2 and w3.
     resizer->Drag(CalculateDragPoint(*resizer, 100, -10), 0);
 
     // 2 should be topmost since it's initially the highest in the stack.
     EXPECT_EQ("2 3 1", WindowOrderAsString(window_->parent()));
   }
 }
 
 // Makes sure we don't allow dragging below the work area.
 TEST_F(WorkspaceWindowResizerTest, DontDragOffBottom) {
   Shell::GetInstance()->SetDisplayWorkAreaInsets(
       Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 10, 0));
 
   ASSERT_EQ(1, gfx::Screen::GetNumDisplays());
 
   window_->SetBounds(gfx::Rect(100, 200, 300, 400));
-  SetGridSize(0);
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTCAPTION, empty_windows()));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, 0, 600), 0);
   int expected_y =
       kRootHeight - WorkspaceWindowResizer::kMinOnscreenHeight - 10;
   EXPECT_EQ("100," + base::IntToString(expected_y) + " 300x400",
             window_->bounds().ToString());
 }
 
 // Makes sure we don't allow dragging off the top of the work area.
 TEST_F(WorkspaceWindowResizerTest, DontDragOffTop) {
   Shell::GetInstance()->SetDisplayWorkAreaInsets(
       Shell::GetPrimaryRootWindow(), gfx::Insets(10, 0, 0, 0));
 
   window_->SetBounds(gfx::Rect(100, 200, 300, 400));
-  SetGridSize(0);
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTCAPTION, empty_windows()));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, 0, -600), 0);
   EXPECT_EQ("100,10 300x400", window_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, ResizeBottomOutsideWorkArea) {
   Shell::GetInstance()->SetDisplayWorkAreaInsets(
       Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 50, 0));
 
   window_->SetBounds(gfx::Rect(100, 200, 300, 380));
-  SetGridSize(10);
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTTOP, empty_windows()));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, 8, 0), 0);
   EXPECT_EQ("100,200 300x380", window_->bounds().ToString());
 }
 
 // Verifies snapping to edges works.
 TEST_F(WorkspaceWindowResizerTest, SnapToEdge) {
   Shell::GetInstance()->SetShelfAutoHideBehavior(
       SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   window_->SetBounds(gfx::Rect(96, 112, 320, 160));
-  SetGridSize(16);
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTCAPTION, empty_windows()));
   ASSERT_TRUE(resizer.get());
   // Move to an x-coordinate of 15, which should not snap.
   resizer->Drag(CalculateDragPoint(*resizer, -81, 0), 0);
   // An x-coordinate of 7 should snap.
   resizer->Drag(CalculateDragPoint(*resizer, -89, 0), 0);
   EXPECT_EQ("0,112 320x160", window_->bounds().ToString());
-  // Move to -20, should still snap to 0.
-  resizer->Drag(CalculateDragPoint(*resizer, -116, 0), 0);
+  // Move to -15, should still snap to 0.
+  resizer->Drag(CalculateDragPoint(*resizer, -111, 0), 0);
   EXPECT_EQ("0,112 320x160", window_->bounds().ToString());
   // At -32 should move past snap points.
   resizer->Drag(CalculateDragPoint(*resizer, -128, 0), 0);
   EXPECT_EQ("-32,112 320x160", window_->bounds().ToString());
   resizer->Drag(CalculateDragPoint(*resizer, -129, 0), 0);
   EXPECT_EQ("-33,112 320x160", window_->bounds().ToString());
 
   // Right side should similarly snap.
   resizer->Drag(CalculateDragPoint(*resizer, 800 - 320 - 96 - 15, 0), 0);
   EXPECT_EQ("465,112 320x160", window_->bounds().ToString());
   resizer->Drag(CalculateDragPoint(*resizer, 800 - 320 - 96 - 7, 0), 0);
   EXPECT_EQ("480,112 320x160", window_->bounds().ToString());
-  resizer->Drag(CalculateDragPoint(*resizer, 800 - 320 - 96 + 20, 0), 0);
+  resizer->Drag(CalculateDragPoint(*resizer, 800 - 320 - 96 + 15, 0), 0);
   EXPECT_EQ("480,112 320x160", window_->bounds().ToString());
   resizer->Drag(CalculateDragPoint(*resizer, 800 - 320 - 96 + 32, 0), 0);
   EXPECT_EQ("512,112 320x160", window_->bounds().ToString());
   resizer->Drag(CalculateDragPoint(*resizer, 800 - 320 - 96 + 33, 0), 0);
   EXPECT_EQ("513,112 320x160", window_->bounds().ToString());
 
   // And the bottom should snap too.
-  resizer->Drag(CalculateDragPoint(*resizer, 0, 600 - 160 - 112 - 15), 0);
-  EXPECT_EQ("96,432 320x160", window_->bounds().ToString());
-  resizer->Drag(CalculateDragPoint(*resizer, 0, 600 - 160 - 112 + 20), 0);
-  EXPECT_EQ("96,432 320x160", window_->bounds().ToString());
-  resizer->Drag(CalculateDragPoint(*resizer, 0, 600 - 160 - 112 + 32), 0);
-  EXPECT_EQ("96,472 320x160", window_->bounds().ToString());
-  resizer->Drag(CalculateDragPoint(*resizer, 0, 600 - 160 - 112 + 33), 0);
-  EXPECT_EQ("96,473 320x160", window_->bounds().ToString());
+  resizer->Drag(CalculateDragPoint(*resizer, 0, 600 - 160 - 112 - 2 - 7), 0);
+  EXPECT_EQ("96,438 320x160", window_->bounds().ToString());
+  resizer->Drag(CalculateDragPoint(*resizer, 0, 600 - 160 - 112 - 2 + 15), 0);
+  EXPECT_EQ("96,438 320x160", window_->bounds().ToString());
+  resizer->Drag(CalculateDragPoint(*resizer, 0, 600 - 160 - 112 - 2 + 32), 0);
+  EXPECT_EQ("96,470 320x160", window_->bounds().ToString());
+  resizer->Drag(CalculateDragPoint(*resizer, 0, 600 - 160 - 112 - 2 + 33), 0);
+  EXPECT_EQ("96,471 320x160", window_->bounds().ToString());
 
   // And the top should snap too.
   resizer->Drag(CalculateDragPoint(*resizer, 0, -112 + 20), 0);
   EXPECT_EQ("96,20 320x160", window_->bounds().ToString());
   resizer->Drag(CalculateDragPoint(*resizer, 0, -112 + 7), 0);
   EXPECT_EQ("96,0 320x160", window_->bounds().ToString());
   // No need to test dragging < 0 as we force that to 0.
 }
 
 // Verifies a window taller than work area height doesn't snap above the top of
 // the work area.
 TEST_F(WorkspaceWindowResizerTest, TallWindow) {
   aura::RootWindow* root = Shell::GetPrimaryRootWindow();
   Shell::GetInstance()->SetDisplayWorkAreaInsets(
       root, gfx::Insets(0, 0, 50, 0));
   window_->SetBounds(gfx::Rect(0, 0, 320, 560));
-  SetGridSize(16);
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTCAPTION, empty_windows()));
   resizer->Drag(CalculateDragPoint(*resizer, 0, 9), 0);
   EXPECT_EQ("0,9 320x560", window_->bounds().ToString());
 }
 
-TEST_F(WorkspaceWindowResizerTest, DragResizeSnapToGrid) {
+TEST_F(WorkspaceWindowResizerTest, CtrlDragResizeToExactPosition) {
   window_->SetBounds(gfx::Rect(96, 112, 320, 160));
-  SetGridSize(16);
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTBOTTOMRIGHT, empty_windows()));
   ASSERT_TRUE(resizer.get());
-  // Resize the right bottom to add 10 in width, 12 in height.
-  resizer->Drag(CalculateDragPoint(*resizer, 10, 12), 0);
-  // Both bottom and right sides should snap to grids.
-  EXPECT_EQ("96,112 336x176", window_->bounds().ToString());
-}
-
-TEST_F(WorkspaceWindowResizerTest, CtrlDragResizeToExactPosition) {
-  window_->SetBounds(gfx::Rect(96, 112, 320, 160));
-  SetGridSize(16);
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
-      window_.get(), gfx::Point(), HTBOTTOMRIGHT, empty_windows()));
-  ASSERT_TRUE(resizer.get());
   // Resize the right bottom to add 10 in width, 12 in height.
   resizer->Drag(CalculateDragPoint(*resizer, 10, 12), ui::EF_CONTROL_DOWN);
   // Both bottom and right sides to resize to exact size requested.
   EXPECT_EQ("96,112 330x172", window_->bounds().ToString());
 }
 
-TEST_F(WorkspaceWindowResizerTest, CompleteDragMoveSnapToGrid) {
-  window_->SetBounds(gfx::Rect(96, 112, 320, 160));
-  SetGridSize(16);
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
-      window_.get(), gfx::Point(), HTCAPTION, empty_windows()));
-  ASSERT_TRUE(resizer.get());
-  // Drag the window to new poistion by adding (10, 12) to original point,
-  // the window should snap to the closed grid.
-  resizer->Drag(CalculateDragPoint(*resizer, 10, 12), 0);
-  resizer->CompleteDrag(0);
-  EXPECT_EQ("112,128 320x160", window_->bounds().ToString());
-}
-
 TEST_F(WorkspaceWindowResizerTest, CtrlCompleteDragMoveToExactPosition) {
   window_->SetBounds(gfx::Rect(96, 112, 320, 160));
-  SetGridSize(16);
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTCAPTION, empty_windows()));
   ASSERT_TRUE(resizer.get());
   // Ctrl + drag the window to new poistion by adding (10, 12) to its origin,
   // the window should move to the exact position.
   resizer->Drag(CalculateDragPoint(*resizer, 10, 12), 0);
   resizer->CompleteDrag(ui::EF_CONTROL_DOWN);
   EXPECT_EQ("106,124 320x160", window_->bounds().ToString());
 }
 
 // Check that only usable sizes get returned by the resizer.
 TEST_F(WorkspaceWindowResizerTest, TestProperSizerResolutions) {
   window_->SetBounds(gfx::Rect(96, 112, 320, 160));
-  SetGridSize(16);
   scoped_ptr<SnapSizer> resizer(new SnapSizer(
-      window_.get(), gfx::Point(), SnapSizer::LEFT_EDGE, 1));
+      window_.get(), gfx::Point(), SnapSizer::LEFT_EDGE));
   ASSERT_TRUE(resizer.get());
   gfx::Rect rect = resizer->GetTargetBoundsForSize(0);
   EXPECT_EQ("0,0 720x552", rect.ToString());
   rect = resizer->GetTargetBoundsForSize(1);
   EXPECT_EQ("0,0 720x552", rect.ToString());
   rect = resizer->GetTargetBoundsForSize(2);
   EXPECT_EQ("0,0 720x552", rect.ToString());
   rect = resizer->GetTargetBoundsForSize(3);
   EXPECT_EQ("0,0 640x552", rect.ToString());
 }
 
 }  // namespace internal
 }  // namespace ash