Enables docked windows by default

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/ash_constants.h"
 #include "ash/ash_switches.h"
 #include "ash/display/display_manager.h"
 #include "ash/root_window_controller.h"
@@ skipping 150 matching lines @@
       if (*i == window_ || *i == window2_ || *i == window3_) {
         if (!result.empty())
           result += " ";
         result += base::IntToString((*i)->id());
       }
     }
     return result;
   }
 
  protected:
-  gfx::Point CalculateDragPoint(const WorkspaceWindowResizer& resizer,
+  gfx::Point CalculateDragPoint(const WindowResizer& resizer,
                                 int delta_x,
                                 int delta_y) const {
     gfx::Point location = resizer.GetInitialLocation();
     location.set_x(location.x() + delta_x);
     location.set_y(location.y() + delta_y);
     return location;
   }
 
   std::vector<aura::Window*> empty_windows() const {
     return std::vector<aura::Window*>();
@@ skipping 48 matching lines @@
   virtual void SetUp() OVERRIDE {
     CommandLine::ForCurrentProcess()->AppendSwitch(
         ash::switches::kAshEnableStickyEdges);
     WorkspaceWindowResizerTest::SetUp();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WorkspaceWindowResizerTestSticky);
 };
 
+bool IsStickyEdgesEnabled() {
+  return (CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kAshEnableStickyEdges));
+}
+
 }  // namespace
 
 // 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());
@@ skipping 217 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());
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(

[flackr, 2013/11/06 20:02:31]

You didn't change all of the WorkspaceWindowResizer::Create calls, intentional?

[varkha, 2013/11/06 21:19:53]

Yes, This is testing the creation path from
MultiWindowResizeController::StartResize which resizes multiple adjacent
windows. This path is orthogonal to docking so we can use WorskpaceWindowResizer
directly here - similar to how it is used in real Chrome.

       window_.get(), gfx::Point(), HTBOTTOM,
       aura::client::WINDOW_MOVE_SOURCE_MOUSE, windows));
   ASSERT_TRUE(resizer.get());
   // Move it 100 down, 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 things should compress.
@@ skipping 46 matching lines @@
   // 100 up again.
   resizer->Drag(CalculateDragPoint(*resizer, -10, -100), 0);
   EXPECT_EQ("0,0 200x100", window_->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::GetDisplayWorkAreaBoundsInParent(window_.get()).bottom();
-  window_->SetBounds(gfx::Rect(20, 30, 50, 60));
+  // TODO(varkha): Insets are reset after every drag because of
+  // http://crbug.com/292238.
+  // Window is wide enough not to get docked right away.
+  window_->SetBounds(gfx::Rect(20, 30, 400, 60));
   wm::WindowState* window_state = wm::GetWindowState(window_.get());
 
   {
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(

[flackr, 2013/11/06 20:02:31]

While this is probably a worthwhile cleanup to these tests to have them
instantiate the real chain of resizers, it seems to me like none of the changes
in this unit test are necessary because of enabling docking by default. Can this
be deferred to a different CL?

[varkha, 2013/11/06 21:19:53]

Since WorkspaceWindowResizer manipulates the phantom controller and calls into
DockedWindowLayoutManager we need the same resizer chain as in real Chrome to
keep the state in DockedLayoutWindowManager correct. I have changed the tests to
use scoped_ptr<WindowResizer> where possible.

         window_.get(), gfx::Point(), HTCAPTION,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
     ASSERT_TRUE(resizer.get());
     resizer->Drag(CalculateDragPoint(*resizer, 0, 10), 0);
+    int bottom =
+        ScreenAsh::GetDisplayWorkAreaBoundsInParent(window_.get()).bottom();
     resizer->CompleteDrag(0);
     EXPECT_EQ("0,0 720x" + base::IntToString(bottom),
               window_->bounds().ToString());
     ASSERT_TRUE(window_state->HasRestoreBounds());
-    EXPECT_EQ("20,30 50x60",
+    EXPECT_EQ("20,30 400x60",
               window_state->GetRestoreBoundsInScreen().ToString());
   }
   // Try the same with the right side.
   {
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
         window_.get(), gfx::Point(), HTCAPTION,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
     ASSERT_TRUE(resizer.get());
     resizer->Drag(CalculateDragPoint(*resizer, 800, 10), 0);
+    int bottom =
+        ScreenAsh::GetDisplayWorkAreaBoundsInParent(window_.get()).bottom();
     resizer->CompleteDrag(0);
     EXPECT_EQ("80,0 720x" + base::IntToString(bottom),
               window_->bounds().ToString());
     ASSERT_TRUE(window_state->HasRestoreBounds());
-    EXPECT_EQ("20,30 50x60",
+    EXPECT_EQ("20,30 400x60",
               window_state->GetRestoreBoundsInScreen().ToString());
   }
 
   // Test if the restore bounds is correct in multiple displays.
   window_state->ClearRestoreBounds();
 
   if (!SupportsMultipleDisplays())
     return;
 
-  UpdateDisplay("800x600,200x600");
+  UpdateDisplay("800x600,500x600");
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   EXPECT_EQ(root_windows[0], window_->GetRootWindow());
-  window_->SetBoundsInScreen(gfx::Rect(800, 10, 50, 60),
+  // Window is wide enough not to get docked right away.
+  window_->SetBoundsInScreen(gfx::Rect(800, 10, 400, 60),
                              ScreenAsh::GetSecondaryDisplay());
   EXPECT_EQ(root_windows[1], window_->GetRootWindow());
   {
-    bottom =
+    EXPECT_EQ("800,10 400x60", window_->GetBoundsInScreen().ToString());
+
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
+        window_.get(), gfx::Point(), HTCAPTION,
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
+    ASSERT_TRUE(resizer.get());
+    resizer->Drag(CalculateDragPoint(*resizer, 499, 00), 0);
+    int bottom =
         ScreenAsh::GetDisplayWorkAreaBoundsInParent(window_.get()).bottom();
-    EXPECT_EQ("800,10 50x60", window_->GetBoundsInScreen().ToString());
-
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
-        window_.get(), gfx::Point(), HTCAPTION,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
-    ASSERT_TRUE(resizer.get());
-
-    resizer->Drag(CalculateDragPoint(*resizer, 199, 00), 0);
     resizer->CompleteDrag(0);
-    // With the resolution of 200x600 we will hit in this case the 50% screen
+    // With the resolution of 500x600 we will hit in this case the 50% screen
     // size setting.
-    EXPECT_EQ("100,0 100x" + base::IntToString(bottom),
+    // TODO(varkha): Insets are updated because of http://crbug.com/292238
+    EXPECT_EQ("250,0 250x" + base::IntToString(bottom),
               window_->bounds().ToString());
-    EXPECT_EQ("800,10 50x60",
+    EXPECT_EQ("800,10 400x60",
               window_state->GetRestoreBoundsInScreen().ToString());
   }
 }
 
 // Check that non resizable windows will not get resized.
 TEST_F(WorkspaceWindowResizerTest, NonResizableWindows) {
   window_->SetBounds(gfx::Rect(20, 30, 50, 60));
   window_->SetProperty(aura::client::kCanResizeKey, false);
 
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTCAPTION,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, -20, 0), 0);
   resizer->CompleteDrag(0);
   EXPECT_EQ("0,30 50x60", window_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, CancelSnapPhantom) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("800x600,800x600");
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   ASSERT_EQ(2U, root_windows.size());
 
   window_->SetBoundsInScreen(gfx::Rect(0, 0, 50, 60),
                              Shell::GetScreen()->GetPrimaryDisplay());
   EXPECT_EQ(root_windows[0], window_->GetRootWindow());
   EXPECT_FLOAT_EQ(1.0f, window_->layer()->opacity());
   {
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
         window_.get(), gfx::Point(), HTCAPTION,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
     ASSERT_TRUE(resizer.get());
-    EXPECT_FALSE(resizer->snap_phantom_window_controller_.get());
+    WorkspaceWindowResizer* workspace_resizer =
+        WorkspaceWindowResizer::instance_;
+    EXPECT_FALSE(workspace_resizer->snap_phantom_window_controller_.get());
 
     // The pointer is on the edge but not shared. The snap phantom window
     // controller should be non-NULL.
     resizer->Drag(CalculateDragPoint(*resizer, 799, 0), 0);
-    EXPECT_TRUE(resizer->snap_phantom_window_controller_.get());
+    EXPECT_TRUE(workspace_resizer->snap_phantom_window_controller_.get());
 
     // Move the cursor across the edge. Now the snap phantom window controller
     // should be canceled.
     resizer->Drag(CalculateDragPoint(*resizer, 800, 0), 0);
-    EXPECT_FALSE(resizer->snap_phantom_window_controller_.get());
+    EXPECT_FALSE(workspace_resizer->snap_phantom_window_controller_.get());
   }
 }
 
 // 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));
 
   {
@@ skipping 26 matching lines @@
 }
 
 // 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, Shell::GetScreen()->GetNumDisplays());
 
   window_->SetBounds(gfx::Rect(100, 200, 300, 400));
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTCAPTION,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   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 on the work area with multidisplay.
 TEST_F(WorkspaceWindowResizerTest, DontDragOffBottomWithMultiDisplay) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("800x600,800x600");
   ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays());
 
   Shell::GetInstance()->SetDisplayWorkAreaInsets(
       Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 10, 0));
 
   // Positions the secondary display at the bottom the primary display.
   Shell::GetInstance()->display_manager()->SetLayoutForCurrentDisplays(
       ash::DisplayLayout(ash::DisplayLayout::BOTTOM, 0));
 
   {
     window_->SetBounds(gfx::Rect(100, 200, 300, 20));
     DCHECK_LT(window_->bounds().height(),
               WorkspaceWindowResizer::kMinOnscreenHeight);
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
         window_.get(), gfx::Point(), HTCAPTION,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
     ASSERT_TRUE(resizer.get());
     resizer->Drag(CalculateDragPoint(*resizer, 0, 400), 0);
     int expected_y = kRootHeight - window_->bounds().height() - 10;
     // When the mouse cursor is in the primary display, the window cannot move
     // on non-work area but can get all the way towards the bottom,
     // restricted only by the window height.
     EXPECT_EQ("100," + base::IntToString(expected_y) + " 300x20",
               window_->bounds().ToString());
+    // Revert the drag in order to not remember the restore bounds.
+    resizer->RevertDrag();
   }
 
+  Shell::GetInstance()->SetDisplayWorkAreaInsets(
+      Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 10, 0));
   {
     window_->SetBounds(gfx::Rect(100, 200, 300, 400));
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
         window_.get(), gfx::Point(), HTCAPTION,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
     ASSERT_TRUE(resizer.get());
     resizer->Drag(CalculateDragPoint(*resizer, 0, 400), 0);
     int expected_y =
         kRootHeight - WorkspaceWindowResizer::kMinOnscreenHeight - 10;
     // When the mouse cursor is in the primary display, the window cannot move
     // on non-work area with kMinOnscreenHeight margin.
     EXPECT_EQ("100," + base::IntToString(expected_y) + " 300x400",
               window_->bounds().ToString());
+    resizer->CompleteDrag(0);
   }
 
   {
     window_->SetBounds(gfx::Rect(100, 200, 300, 400));
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
-        window_.get(), gfx::Point(), HTCAPTION,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
+        window_.get(), window_->bounds().origin(), HTCAPTION,
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
     ASSERT_TRUE(resizer.get());
-    resizer->Drag(CalculateDragPoint(*resizer, 0, 600), 0);
+    // Drag down avoiding getting stuck against the shelf on the bottom screen.
+    resizer->Drag(CalculateDragPoint(*resizer, 0, 500), 0);
     // The window can move to the secondary display beyond non-work area of
     // the primary display.
-    EXPECT_EQ("100,800 300x400", window_->bounds().ToString());
+    EXPECT_EQ("100,700 300x400", window_->bounds().ToString());
+    resizer->CompleteDrag(0);
   }
 }
 
 // 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));
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTCAPTION,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   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));
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTTOP,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, 8, 0), 0);
   EXPECT_EQ("100,200 300x380", window_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, ResizeWindowOutsideLeftWorkArea) {
   Shell::GetInstance()->SetDisplayWorkAreaInsets(
       Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 50, 0));
   int left = ScreenAsh::GetDisplayWorkAreaBoundsInParent(window_.get()).x();
   int pixels_to_left_border = 50;
   int window_width = 300;
   int window_x = left - window_width + pixels_to_left_border;
   window_->SetBounds(gfx::Rect(window_x, 100, window_width, 380));
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(pixels_to_left_border, 0), HTRIGHT,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, -window_width, 0), 0);
   EXPECT_EQ(base::IntToString(window_x) + ",100 " +
             base::IntToString(kMinimumOnScreenArea - window_x) +
             "x380", window_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, ResizeWindowOutsideRightWorkArea) {
   Shell::GetInstance()->SetDisplayWorkAreaInsets(
       Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 50, 0));
   int right = ScreenAsh::GetDisplayWorkAreaBoundsInParent(
       window_.get()).right();
   int pixels_to_right_border = 50;
   int window_width = 300;
   int window_x = right - pixels_to_right_border;
   window_->SetBounds(gfx::Rect(window_x, 100, window_width, 380));
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(window_x, 0), HTLEFT,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, window_width, 0), 0);
   EXPECT_EQ(base::IntToString(right - kMinimumOnScreenArea) +
             ",100 " +
             base::IntToString(window_width - pixels_to_right_border +
                               kMinimumOnScreenArea) +
             "x380", window_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, ResizeWindowOutsideBottomWorkArea) {
   Shell::GetInstance()->SetDisplayWorkAreaInsets(
       Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 50, 0));
   int bottom = ScreenAsh::GetDisplayWorkAreaBoundsInParent(
       window_.get()).bottom();
   int delta_to_bottom = 50;
   int height = 380;
   window_->SetBounds(gfx::Rect(100, bottom - delta_to_bottom, 300, height));
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(0, bottom - delta_to_bottom), HTTOP,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, 0, bottom), 0);
   EXPECT_EQ("100," +
             base::IntToString(bottom - kMinimumOnScreenArea) +
             " 300x" +
             base::IntToString(height - (delta_to_bottom -
                                         kMinimumOnScreenArea)),
             window_->bounds().ToString());
 }
 
 // Verifies that 'outside' check of the resizer take into account the extended
 // desktop in case of repositions.
 TEST_F(WorkspaceWindowResizerTest, DragWindowOutsideRightToSecondaryDisplay) {
   // Only primary display.  Changes the window position to fit within the
   // display.
   Shell::GetInstance()->SetDisplayWorkAreaInsets(
       Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 50, 0));
   int right = ScreenAsh::GetDisplayWorkAreaBoundsInParent(
       window_.get()).right();
   int pixels_to_right_border = 50;
   int window_width = 300;
   int window_x = right - pixels_to_right_border;
   window_->SetBounds(gfx::Rect(window_x, 100, window_width, 380));
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(window_x, 0), HTCAPTION,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, window_width, 0), 0);
   EXPECT_EQ(base::IntToString(right - kMinimumOnScreenArea) +
             ",100 " +
             base::IntToString(window_width) +
             "x380", window_->bounds().ToString());
 
   if (!SupportsMultipleDisplays())
     return;
 
   // With secondary display.  Operation itself is same but doesn't change
   // the position because the window is still within the secondary display.
   UpdateDisplay("1000x600,600x400");
   Shell::GetInstance()->SetDisplayWorkAreaInsets(
       Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 50, 0));
   window_->SetBounds(gfx::Rect(window_x, 100, window_width, 380));
   resizer->Drag(CalculateDragPoint(*resizer, window_width, 0), 0);
   EXPECT_EQ(base::IntToString(window_x + window_width) +
             ",100 " +
             base::IntToString(window_width) +
             "x380", window_->bounds().ToString());
 }
 
 // Verifies snapping to edges works.
 TEST_F(WorkspaceWindowResizerTest, SnapToEdge) {
+  if (IsStickyEdgesEnabled())
+    return;
   Shell::GetPrimaryRootWindowController()->GetShelfLayoutManager()->
       SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   window_->SetBounds(gfx::Rect(96, 112, 320, 160));
   // Click 50px to the right so that the mouse pointer does not leave the
   // workspace ensuring sticky behavior.
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(),
       window_->bounds().origin() + gfx::Vector2d(50, 0),
       HTCAPTION,
       aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
@@ skipping 53 matching lines @@
   EXPECT_EQ("-32,470 320x160", window_->bounds().ToString());
   resizer->Drag(
       CalculateDragPoint(*resizer, -33 - 96, 600 - 160 - 112 - 2 + 33), 0);
   EXPECT_EQ("-33,471 320x160", window_->bounds().ToString());
 
   // No need to test dragging < 0 as we force that to 0.
 }
 
 // Verifies a resize snap when dragging TOPLEFT.
 TEST_F(WorkspaceWindowResizerTest, SnapToWorkArea_TOPLEFT) {
+  if (IsStickyEdgesEnabled())
+    return;
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTTOPLEFT,
       aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, -98, -199), 0);
   EXPECT_EQ("0,0 120x230", window_->bounds().ToString());
 }
 
 // Verifies a resize snap when dragging TOPRIGHT.
 TEST_F(WorkspaceWindowResizerTest, SnapToWorkArea_TOPRIGHT) {
+  if (IsStickyEdgesEnabled())
+    return;
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
   gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(
                           window_.get()));
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTTOPRIGHT,
       aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(
       CalculateDragPoint(*resizer, work_area.right() - 120 - 1, -199), 0);
   EXPECT_EQ(100, window_->bounds().x());
   EXPECT_EQ(work_area.y(), window_->bounds().y());
   EXPECT_EQ(work_area.right() - 100, window_->bounds().width());
   EXPECT_EQ(230, window_->bounds().height());
 }
 
 // Verifies a resize snap when dragging BOTTOMRIGHT.
 TEST_F(WorkspaceWindowResizerTest, SnapToWorkArea_BOTTOMRIGHT) {
+  if (IsStickyEdgesEnabled())
+    return;
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
   gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(
                           window_.get()));
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTBOTTOMRIGHT,
       aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(
       CalculateDragPoint(*resizer, work_area.right() - 120 - 1,
                          work_area.bottom() - 220 - 2), 0);
   EXPECT_EQ(100, window_->bounds().x());
   EXPECT_EQ(200, window_->bounds().y());
   EXPECT_EQ(work_area.right() - 100, window_->bounds().width());
   EXPECT_EQ(work_area.bottom() - 200, window_->bounds().height());
 }
 
 // Verifies a resize snap when dragging BOTTOMLEFT.
 TEST_F(WorkspaceWindowResizerTest, SnapToWorkArea_BOTTOMLEFT) {
+  if (IsStickyEdgesEnabled())
+    return;
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
   gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(
                           window_.get()));
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTBOTTOMLEFT,
       aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(
       CalculateDragPoint(*resizer, -98, work_area.bottom() - 220 - 2), 0);
   EXPECT_EQ(0, window_->bounds().x());
   EXPECT_EQ(200, window_->bounds().y());
   EXPECT_EQ(120, window_->bounds().width());
   EXPECT_EQ(work_area.bottom() - 200, window_->bounds().height());
 }
 
 // Verifies sticking to edges works.
 TEST_F(WorkspaceWindowResizerTestSticky, StickToEdge) {
   Shell::GetPrimaryRootWindowController()->GetShelfLayoutManager()->
       SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   window_->SetBounds(gfx::Rect(96, 112, 320, 160));
   // Click 50px to the right so that the mouse pointer does not leave the
   // workspace ensuring sticky behavior.
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(),
       window_->bounds().origin() + gfx::Vector2d(50, 0),
       HTCAPTION,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   // Move to an x-coordinate of 15, which should not stick.
   resizer->Drag(CalculateDragPoint(*resizer, 15 - 96, 0), 0);
   // Move to -15, should still stick to 0.
   resizer->Drag(CalculateDragPoint(*resizer, -15 - 96, 0), 0);
   EXPECT_EQ("0,112 320x160", window_->bounds().ToString());
   // At -100 should move past edge.
   resizer->Drag(CalculateDragPoint(*resizer, -100 - 96, 0), 0);
   EXPECT_EQ("-100,112 320x160", window_->bounds().ToString());
   resizer->Drag(CalculateDragPoint(*resizer, -101 - 96, 0), 0);
@@ skipping 18 matching lines @@
   EXPECT_EQ("96,539 320x160", window_->bounds().ToString());
 
   // No need to test dragging < 0 as we force that to 0.
 }
 
 // Verifies not sticking to edges when a mouse pointer is outside of work area.
 TEST_F(WorkspaceWindowResizerTestSticky, NoStickToEdgeWhenOutside) {
   Shell::GetPrimaryRootWindowController()->GetShelfLayoutManager()->
       SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   window_->SetBounds(gfx::Rect(96, 112, 320, 160));
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTCAPTION,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   // Move to an x-coordinate of 15, which should not stick.
   resizer->Drag(CalculateDragPoint(*resizer, 15 - 96, 0), 0);
   // Move to -15, should still stick to 0.
   resizer->Drag(CalculateDragPoint(*resizer, -15 - 96, 0), 0);
   EXPECT_EQ("-15,112 320x160", window_->bounds().ToString());
 }
 
 // Verifies a resize sticks when dragging TOPLEFT.
 TEST_F(WorkspaceWindowResizerTestSticky, StickToWorkArea_TOPLEFT) {
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTTOPLEFT,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, -15 - 100, -15 -200), 0);
   EXPECT_EQ("0,0 120x230", window_->bounds().ToString());
 }
 
 // Verifies a resize sticks when dragging TOPRIGHT.
 TEST_F(WorkspaceWindowResizerTestSticky, StickToWorkArea_TOPRIGHT) {
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
   gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(
                           window_.get()));
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTTOPRIGHT,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, work_area.right() - 100 + 20,
                                    -200 - 15), 0);
   EXPECT_EQ(100, window_->bounds().x());
   EXPECT_EQ(work_area.y(), window_->bounds().y());
   EXPECT_EQ(work_area.right() - 100, window_->bounds().width());
   EXPECT_EQ(230, window_->bounds().height());
 }
 
 // Verifies a resize snap when dragging BOTTOMRIGHT.
 TEST_F(WorkspaceWindowResizerTestSticky, StickToWorkArea_BOTTOMRIGHT) {
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
   gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(
                           window_.get()));
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTBOTTOMRIGHT,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, work_area.right() - 100 - 20 + 15,
                                    work_area.bottom() - 200 - 30 + 15), 0);
   EXPECT_EQ(100, window_->bounds().x());
   EXPECT_EQ(200, window_->bounds().y());
   EXPECT_EQ(work_area.right() - 100, window_->bounds().width());
   EXPECT_EQ(work_area.bottom() - 200, window_->bounds().height());
 }
 
 // Verifies a resize snap when dragging BOTTOMLEFT.
 TEST_F(WorkspaceWindowResizerTestSticky, StickToWorkArea_BOTTOMLEFT) {
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
   gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(
                           window_.get()));
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTBOTTOMLEFT,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, -15 - 100,
                                    work_area.bottom() - 200 - 30 + 15), 0);
   EXPECT_EQ(0, window_->bounds().x());
   EXPECT_EQ(200, window_->bounds().y());
   EXPECT_EQ(120, window_->bounds().width());
   EXPECT_EQ(work_area.bottom() - 200, window_->bounds().height());
 }
 
 TEST_F(WorkspaceWindowResizerTest, CtrlDragResizeToExactPosition) {
   window_->SetBounds(gfx::Rect(96, 112, 320, 160));
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTBOTTOMRIGHT,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   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, CtrlCompleteDragMoveToExactPosition) {
   window_->SetBounds(gfx::Rect(96, 112, 320, 160));
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTCAPTION,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   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());
 }
 
 // Verifies that a dragged window will restore to its pre-maximized size.
 TEST_F(WorkspaceWindowResizerTest, RestoreToPreMaximizeCoordinates) {
   window_->SetBounds(gfx::Rect(0, 0, 1000, 1000));
   wm::WindowState* window_state = wm::GetWindowState(window_.get());
   window_state->SetRestoreBoundsInScreen(gfx::Rect(96, 112, 320, 160));
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTCAPTION,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   // Drag the window to new position by adding (10, 10) to original point,
   // the window should get restored.
   resizer->Drag(CalculateDragPoint(*resizer, 10, 10), 0);
   resizer->CompleteDrag(0);
   EXPECT_EQ("10,10 320x160", window_->bounds().ToString());
   // The restore rectangle should get cleared as well.
   EXPECT_FALSE(window_state->HasRestoreBounds());
 }
 
 // Verifies that a dragged window will restore to its pre-maximized size.
 TEST_F(WorkspaceWindowResizerTest, RevertResizeOperation) {
   const gfx::Rect initial_bounds(0, 0, 200, 400);
   window_->SetBounds(initial_bounds);
 
   wm::WindowState* window_state = wm::GetWindowState(window_.get());
   window_state->SetRestoreBoundsInScreen(gfx::Rect(96, 112, 320, 160));
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTCAPTION,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   // Drag the window to new poistion by adding (180, 16) to original point,
   // the window should get restored.
   resizer->Drag(CalculateDragPoint(*resizer, 180, 16), 0);
   resizer->RevertDrag();
   EXPECT_EQ(initial_bounds.ToString(), window_->bounds().ToString());
   EXPECT_EQ("96,112 320x160",
             window_state->GetRestoreBoundsInScreen().ToString());
 }
 
 // Check that only usable sizes get returned by the resizer.
 TEST_F(WorkspaceWindowResizerTest, MagneticallyAttach) {
   window_->SetBounds(gfx::Rect(10, 10, 20, 30));
   window2_->SetBounds(gfx::Rect(150, 160, 25, 20));
   window2_->Show();
 
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTCAPTION,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   // Move |window| one pixel to the left of |window2|. Should snap to right and
   // top.
   resizer->Drag(CalculateDragPoint(*resizer, 119, 145), 0);
   EXPECT_EQ("130,160 20x30", window_->bounds().ToString());
 
   // Move |window| one pixel to the right of |window2|. Should snap to left and
   // top.
   resizer->Drag(CalculateDragPoint(*resizer, 164, 145), 0);
   EXPECT_EQ("175,160 20x30", window_->bounds().ToString());
 
   // Move |window| one pixel above |window2|. Should snap to top and left.
   resizer->Drag(CalculateDragPoint(*resizer, 142, 119), 0);
   EXPECT_EQ("150,130 20x30", window_->bounds().ToString());
 
   // Move |window| one pixel above the bottom of |window2|. Should snap to
   // bottom and left.
   resizer->Drag(CalculateDragPoint(*resizer, 142, 169), 0);
   EXPECT_EQ("150,180 20x30", window_->bounds().ToString());
 }
 
 // The following variants verify magnetic snapping during resize when dragging a
 // particular edge.
 TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_TOP) {
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
   window2_->SetBounds(gfx::Rect(99, 179, 10, 20));
   window2_->Show();
 
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
-    window_.get(), gfx::Point(), HTTOP,
-    aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
+      window_.get(), gfx::Point(), HTTOP,
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, 0, 0), 0);
   EXPECT_EQ("100,199 20x31", window_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_TOPLEFT) {
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
   window2_->SetBounds(gfx::Rect(99, 179, 10, 20));
   window2_->Show();
 
   {
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
         window_.get(), gfx::Point(), HTTOPLEFT,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
     ASSERT_TRUE(resizer.get());
     resizer->Drag(CalculateDragPoint(*resizer, 0, 0), 0);
     EXPECT_EQ("99,199 21x31", window_->bounds().ToString());
     resizer->RevertDrag();
   }
 
   {
     window2_->SetBounds(gfx::Rect(88, 201, 10, 20));
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
         window_.get(), gfx::Point(), HTTOPLEFT,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
     ASSERT_TRUE(resizer.get());
     resizer->Drag(CalculateDragPoint(*resizer, 0, 0), 0);
     EXPECT_EQ("98,201 22x29", window_->bounds().ToString());
     resizer->RevertDrag();
   }
 }
 
 TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_TOPRIGHT) {
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
   window2_->Show();
 
   {
     window2_->SetBounds(gfx::Rect(111, 179, 10, 20));
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
         window_.get(), gfx::Point(), HTTOPRIGHT,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
     ASSERT_TRUE(resizer.get());
     resizer->Drag(CalculateDragPoint(*resizer, 0, 0), 0);
     EXPECT_EQ("100,199 21x31", window_->bounds().ToString());
     resizer->RevertDrag();
   }
 
   {
     window2_->SetBounds(gfx::Rect(121, 199, 10, 20));
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
         window_.get(), gfx::Point(), HTTOPRIGHT,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
     ASSERT_TRUE(resizer.get());
     resizer->Drag(CalculateDragPoint(*resizer, 0, 0), 0);
     EXPECT_EQ("100,199 21x31", window_->bounds().ToString());
     resizer->RevertDrag();
   }
 }
 
 TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_RIGHT) {
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
   window2_->SetBounds(gfx::Rect(121, 199, 10, 20));
   window2_->Show();
 
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTRIGHT,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, 0, 0), 0);
   EXPECT_EQ("100,200 21x30", window_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_BOTTOMRIGHT) {
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
   window2_->Show();
 
   {
     window2_->SetBounds(gfx::Rect(122, 212, 10, 20));
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
         window_.get(), gfx::Point(), HTBOTTOMRIGHT,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
     ASSERT_TRUE(resizer.get());
     resizer->Drag(CalculateDragPoint(*resizer, 0, 0), 0);
     EXPECT_EQ("100,200 22x32", window_->bounds().ToString());
     resizer->RevertDrag();
   }
 
   {
     window2_->SetBounds(gfx::Rect(111, 233, 10, 20));
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
         window_.get(), gfx::Point(), HTBOTTOMRIGHT,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
     ASSERT_TRUE(resizer.get());
     resizer->Drag(CalculateDragPoint(*resizer, 0, 0), 0);
     EXPECT_EQ("100,200 21x33", window_->bounds().ToString());
     resizer->RevertDrag();
   }
 }
 
 TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_BOTTOM) {
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
   window2_->SetBounds(gfx::Rect(111, 233, 10, 20));
   window2_->Show();
 
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
-        window_.get(), gfx::Point(), HTBOTTOM,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
+      window_.get(), gfx::Point(), HTBOTTOM,
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, 0, 0), 0);
   EXPECT_EQ("100,200 20x33", window_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_BOTTOMLEFT) {
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
   window2_->Show();
 
   {
     window2_->SetBounds(gfx::Rect(99, 231, 10, 20));
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
         window_.get(), gfx::Point(), HTBOTTOMLEFT,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
     ASSERT_TRUE(resizer.get());
     resizer->Drag(CalculateDragPoint(*resizer, 0, 0), 0);
     EXPECT_EQ("99,200 21x31", window_->bounds().ToString());
     resizer->RevertDrag();
   }
 
   {
     window2_->SetBounds(gfx::Rect(89, 209, 10, 20));
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
         window_.get(), gfx::Point(), HTBOTTOMLEFT,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
     ASSERT_TRUE(resizer.get());
     resizer->Drag(CalculateDragPoint(*resizer, 0, 0), 0);
     EXPECT_EQ("99,200 21x29", window_->bounds().ToString());
     resizer->RevertDrag();
   }
 }
 
 TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_LEFT) {
   window2_->SetBounds(gfx::Rect(89, 209, 10, 20));
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
   window2_->Show();
 
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTLEFT,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, 0, 0), 0);
   EXPECT_EQ("99,200 21x30", window_->bounds().ToString());
 }
 
 // Test that the user user moved window flag is getting properly set.
-TEST_F(WorkspaceWindowResizerTest, CheckUserWindowMangedFlags) {
+TEST_F(WorkspaceWindowResizerTest, CheckUserWindowManagedFlags) {
   window_->SetBounds(gfx::Rect( 0,  50, 400, 200));
 
   std::vector<aura::Window*> no_attached_windows;
   // Check that an abort doesn't change anything.
   {
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
         window_.get(), gfx::Point(), HTCAPTION,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, no_attached_windows));
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
     ASSERT_TRUE(resizer.get());
     // Move it 100 to the bottom.
     resizer->Drag(CalculateDragPoint(*resizer, 0, 100), 0);
     EXPECT_EQ("0,150 400x200", window_->bounds().ToString());
     resizer->RevertDrag();
 
     EXPECT_FALSE(wm::GetWindowState(window_.get())->bounds_changed_by_user());
   }
 
   // Check that a completed move / size does change the user coordinates.
   {
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
         window_.get(), gfx::Point(), HTCAPTION,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, no_attached_windows));
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
     ASSERT_TRUE(resizer.get());
     // Move it 100 to the bottom.
     resizer->Drag(CalculateDragPoint(*resizer, 0, 100), 0);
     EXPECT_EQ("0,150 400x200", window_->bounds().ToString());
     resizer->CompleteDrag(0);
     EXPECT_TRUE(wm::GetWindowState(window_.get())->bounds_changed_by_user());
   }
 }
 
 // Test that a window with a specified max size doesn't exceed it when dragged.
 TEST_F(WorkspaceWindowResizerTest, TestMaxSizeEnforced) {
   window_->SetBounds(gfx::Rect(0, 0, 400, 300));
   delegate_.set_max_size(gfx::Size(401, 301));
 
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTBOTTOMRIGHT,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   resizer->Drag(CalculateDragPoint(*resizer, 2, 2), 0);
   EXPECT_EQ(401, window_->bounds().width());
   EXPECT_EQ(301, window_->bounds().height());
 }
 
 // Test that a window with a specified max width doesn't restrict its height.
 TEST_F(WorkspaceWindowResizerTest, TestPartialMaxSizeEnforced) {
   window_->SetBounds(gfx::Rect(0, 0, 400, 300));
   delegate_.set_max_size(gfx::Size(401, 0));
 
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
       window_.get(), gfx::Point(), HTBOTTOMRIGHT,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   resizer->Drag(CalculateDragPoint(*resizer, 2, 2), 0);
   EXPECT_EQ(401, window_->bounds().width());
   EXPECT_EQ(302, window_->bounds().height());
 }
 
 // Test that a window with a specified max size can't be snapped.
 TEST_F(WorkspaceWindowResizerTest, PhantomSnapMaxSize) {
   {
     // With max size not set we get a phantom window controller for dragging off
     // the right hand side.
-    window_->SetBounds(gfx::Rect(0, 0, 300, 200));
+    // Make the window wider than maximum docked width.
+    window_->SetBounds(gfx::Rect(0, 0, 400, 200));
 
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
         window_.get(), gfx::Point(), HTCAPTION,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
-    EXPECT_FALSE(resizer->snap_phantom_window_controller_.get());
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
+    WorkspaceWindowResizer* workspace_resizer =
+        WorkspaceWindowResizer::instance_;
+    EXPECT_FALSE(workspace_resizer->snap_phantom_window_controller_.get());
     resizer->Drag(CalculateDragPoint(*resizer, 801, 0), 0);
-    EXPECT_TRUE(resizer->snap_phantom_window_controller_.get());
+    EXPECT_TRUE(workspace_resizer->snap_phantom_window_controller_.get());
+    resizer->RevertDrag();
   }
   {
-    // With max size defined, we get no phantom window.
-    window_->SetBounds(gfx::Rect(0, 0, 300, 200));
-    delegate_.set_max_size(gfx::Size(300, 200));
+    // With max size defined, we get no phantom window for snapping but we still
+    // get a phantom window (docking guide).
+    window_->SetBounds(gfx::Rect(0, 0, 400, 200));
+    delegate_.set_max_size(gfx::Size(400, 200));
 
-    scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
         window_.get(), gfx::Point(), HTCAPTION,
-        aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
+    WorkspaceWindowResizer* workspace_resizer =
+        WorkspaceWindowResizer::instance_;
     resizer->Drag(CalculateDragPoint(*resizer, 801, 0), 0);
-    EXPECT_FALSE(resizer->snap_phantom_window_controller_.get());
+    if (switches::UseDockedWindows())
+      EXPECT_TRUE(workspace_resizer->snap_phantom_window_controller_.get());
+    else
+      EXPECT_FALSE(workspace_resizer->snap_phantom_window_controller_.get());
+    resizer->RevertDrag();
+  }
+  {
+    // With max size defined, we get no phantom window for snapping.
+    window_->SetBounds(gfx::Rect(0, 0, 400, 200));
+    delegate_.set_max_size(gfx::Size(400, 200));
+    // With min size defined, we get no phantom window for docking.
+    delegate_.set_min_size(gfx::Size(400, 200));
+
+    scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
+        window_.get(), gfx::Point(), HTCAPTION,
+        aura::client::WINDOW_MOVE_SOURCE_MOUSE));
+    WorkspaceWindowResizer* workspace_resizer =
+        WorkspaceWindowResizer::instance_;
+    resizer->Drag(CalculateDragPoint(*resizer, 801, 0), 0);
+    EXPECT_FALSE(workspace_resizer->snap_phantom_window_controller_.get());
+    resizer->RevertDrag();
   }
 }
 
 TEST_F(WorkspaceWindowResizerTest, DontRewardRightmostWindowForOverflows) {
   UpdateDisplay("600x800");
   aura::Window* root = Shell::GetPrimaryRootWindow();
   Shell::GetInstance()->SetDisplayWorkAreaInsets(root, gfx::Insets());
 
   // Four 100x100 windows flush against eachother, starting at 100,100.
   window_->SetBounds(gfx::Rect( 100, 100, 100, 100));
@@ skipping 368 matching lines @@
 TEST_F(WorkspaceWindowResizerTest, PhantomWindowShow) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("500x400,500x400");
   window_->SetBoundsInScreen(gfx::Rect(0, 0, 50, 60),
                              Shell::GetScreen()->GetPrimaryDisplay());
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   EXPECT_EQ(root_windows[0], window_->GetRootWindow());
 
-  scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
-      window_.get(), gfx::Point(0,0), HTCAPTION,
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
+  scoped_ptr<WindowResizer> resizer(CreateWindowResizer(
+      window_.get(), gfx::Point(), HTCAPTION,
+      aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
-  EXPECT_FALSE(resizer->snap_phantom_window_controller_.get());
+  WorkspaceWindowResizer* workspace_resizer =
+      WorkspaceWindowResizer::instance_;
+  EXPECT_FALSE(workspace_resizer->snap_phantom_window_controller_.get());
 
   // The pointer is on the edge but not shared. The snap phantom window
   // controller should be non-NULL.
   resizer->Drag(CalculateDragPoint(*resizer, -1, 0), 0);
-  EXPECT_TRUE(resizer->snap_phantom_window_controller_.get());
+  EXPECT_TRUE(workspace_resizer->snap_phantom_window_controller_.get());
   PhantomWindowController* phantom_controller(
-      resizer->snap_phantom_window_controller_.get());
+      workspace_resizer->snap_phantom_window_controller_.get());
 
   // phantom widget only in the left screen.
   phantom_controller->Show(gfx::Rect(100, 100, 50, 60));
   EXPECT_TRUE(phantom_controller->phantom_widget_);
   EXPECT_FALSE(phantom_controller->phantom_widget_start_);
   EXPECT_EQ(
       root_windows[0],
       phantom_controller->phantom_widget_->GetNativeWindow()->GetRootWindow());
 
   // Move phantom widget into the right screen. Test that 2 widgets got created.
@@ skipping 68 matching lines @@
   RunAnimationTillComplete(phantom_controller->animation_.get());
 
   // Hide phantom controller. Both widgets should close.
   phantom_controller->Hide();
   EXPECT_FALSE(phantom_controller->phantom_widget_);
   EXPECT_FALSE(phantom_controller->phantom_widget_start_);
 }
 
 }  // namespace internal
 }  // namespace ash