Enables docked windows by default

ash/wm/workspace/workspace_window_resizer_unittest.cc

Index: ash/wm/workspace/workspace_window_resizer_unittest.cc
diff --git a/ash/wm/workspace/workspace_window_resizer_unittest.cc b/ash/wm/workspace/workspace_window_resizer_unittest.cc
index 1e75349d39375045997241b6b39f1a4b109b1e96..5d9b333e5d633eb5169ede66dfc8afe2ce44d809 100644
--- a/ash/wm/workspace/workspace_window_resizer_unittest.cc
+++ b/ash/wm/workspace/workspace_window_resizer_unittest.cc
@@ -168,7 +168,7 @@ class WorkspaceWindowResizerTest : public test::AshTestBase {
   }
 
  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();
@@ -237,6 +237,11 @@ class WorkspaceWindowResizerTestSticky : public WorkspaceWindowResizerTest {
   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
@@ -541,36 +546,41 @@ TEST_F(WorkspaceWindowResizerTest, AttachedResize_BOTTOM_3_Compress) {
 
 // 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());
   }
 
@@ -580,29 +590,30 @@ TEST_F(WorkspaceWindowResizerTest, Edge) {
   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 =
-        ScreenAsh::GetDisplayWorkAreaBoundsInParent(window_.get()).bottom();
-    EXPECT_EQ("800,10 50x60", window_->GetBoundsInScreen().ToString());
+    EXPECT_EQ("800,10 400x60", window_->GetBoundsInScreen().ToString());
 
-    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, 199, 00), 0);
+    resizer->Drag(CalculateDragPoint(*resizer, 499, 00), 0);
+    int bottom =
+        ScreenAsh::GetDisplayWorkAreaBoundsInParent(window_.get()).bottom();
     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());
   }
 }
@@ -612,9 +623,9 @@ 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);
@@ -634,21 +645,23 @@ TEST_F(WorkspaceWindowResizerTest, CancelSnapPhantom) {
   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());
   }
 }
 
@@ -695,9 +708,9 @@ TEST_F(WorkspaceWindowResizerTest, DontDragOffBottom) {
   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 =
@@ -725,9 +738,9 @@ TEST_F(WorkspaceWindowResizerTest, DontDragOffBottomWithMultiDisplay) {
     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;
@@ -736,13 +749,17 @@ TEST_F(WorkspaceWindowResizerTest, DontDragOffBottomWithMultiDisplay) {
     // 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 =
@@ -751,18 +768,21 @@ TEST_F(WorkspaceWindowResizerTest, DontDragOffBottomWithMultiDisplay) {
     // 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);
   }
 }
 
@@ -772,9 +792,9 @@ TEST_F(WorkspaceWindowResizerTest, DontDragOffTop) {
       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());
@@ -785,9 +805,9 @@ TEST_F(WorkspaceWindowResizerTest, ResizeBottomOutsideWorkArea) {
       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());
@@ -801,9 +821,9 @@ TEST_F(WorkspaceWindowResizerTest, ResizeWindowOutsideLeftWorkArea) {
   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 " +
@@ -820,9 +840,9 @@ TEST_F(WorkspaceWindowResizerTest, ResizeWindowOutsideRightWorkArea) {
   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) +
@@ -840,9 +860,9 @@ TEST_F(WorkspaceWindowResizerTest, ResizeWindowOutsideBottomWorkArea) {
   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," +
@@ -866,9 +886,9 @@ TEST_F(WorkspaceWindowResizerTest, DragWindowOutsideRightToSecondaryDisplay) {
   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) +
@@ -894,6 +914,8 @@ TEST_F(WorkspaceWindowResizerTest, DragWindowOutsideRightToSecondaryDisplay) {
 
 // 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));
@@ -967,6 +989,8 @@ TEST_F(WorkspaceWindowResizerTest, SnapToEdge) {
 
 // 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,
@@ -978,6 +1002,8 @@ TEST_F(WorkspaceWindowResizerTest, SnapToWorkArea_TOPLEFT) {
 
 // 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()));
@@ -995,6 +1021,8 @@ TEST_F(WorkspaceWindowResizerTest, SnapToWorkArea_TOPRIGHT) {
 
 // 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()));
@@ -1013,6 +1041,8 @@ TEST_F(WorkspaceWindowResizerTest, SnapToWorkArea_BOTTOMRIGHT) {
 
 // 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()));
@@ -1035,11 +1065,11 @@ TEST_F(WorkspaceWindowResizerTestSticky, StickToEdge) {
   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);
@@ -1078,9 +1108,9 @@ 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);
@@ -1092,9 +1122,9 @@ TEST_F(WorkspaceWindowResizerTestSticky, NoStickToEdgeWhenOutside) {
 // 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());
@@ -1105,9 +1135,9 @@ 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);
@@ -1122,9 +1152,9 @@ 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);
@@ -1139,9 +1169,9 @@ 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);
@@ -1153,9 +1183,9 @@ TEST_F(WorkspaceWindowResizerTestSticky, StickToWorkArea_BOTTOMLEFT) {
 
 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);
@@ -1165,9 +1195,9 @@ TEST_F(WorkspaceWindowResizerTest, CtrlDragResizeToExactPosition) {
 
 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.
@@ -1181,9 +1211,9 @@ 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.
@@ -1201,9 +1231,9 @@ TEST_F(WorkspaceWindowResizerTest, RevertResizeOperation) {
 
   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.
@@ -1220,9 +1250,9 @@ TEST_F(WorkspaceWindowResizerTest, MagneticallyAttach) {
   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.
@@ -1251,9 +1281,9 @@ TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_TOP) {
   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());
@@ -1265,9 +1295,9 @@ TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_TOPLEFT) {
   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());
@@ -1276,9 +1306,9 @@ TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_TOPLEFT) {
 
   {
     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());
@@ -1292,9 +1322,9 @@ TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_TOPRIGHT) {
 
   {
     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());
@@ -1303,9 +1333,9 @@ TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_TOPRIGHT) {
 
   {
     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());
@@ -1318,9 +1348,9 @@ TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_RIGHT) {
   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());
@@ -1332,9 +1362,9 @@ TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_BOTTOMRIGHT) {
 
   {
     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());
@@ -1343,9 +1373,9 @@ TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_BOTTOMRIGHT) {
 
   {
     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());
@@ -1358,9 +1388,9 @@ TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_BOTTOM) {
   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());
@@ -1372,9 +1402,9 @@ TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_BOTTOMLEFT) {
 
   {
     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());
@@ -1383,9 +1413,9 @@ TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_BOTTOMLEFT) {
 
   {
     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());
@@ -1398,24 +1428,24 @@ TEST_F(WorkspaceWindowResizerTest, MagneticallyResize_LEFT) {
   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);
@@ -1427,9 +1457,9 @@ TEST_F(WorkspaceWindowResizerTest, CheckUserWindowMangedFlags) {
 
   // 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);
@@ -1444,9 +1474,9 @@ 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());
@@ -1457,9 +1487,9 @@ 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());
@@ -1470,25 +1500,52 @@ 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));
+    WorkspaceWindowResizer* workspace_resizer =
+        WorkspaceWindowResizer::instance_;
+    resizer->Drag(CalculateDragPoint(*resizer, 801, 0), 0);
+    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, 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());
+    EXPECT_FALSE(workspace_resizer->snap_phantom_window_controller_.get());
+    resizer->RevertDrag();
   }
 }
 
@@ -1877,18 +1934,20 @@ TEST_F(WorkspaceWindowResizerTest, PhantomWindowShow) {
   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));