Windows docking should get triggered by pressing against the screen edge

ash/wm/dock/docked_window_resizer_unittest.cc

 // Copyright (c) 2013 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/dock/docked_window_resizer.h"
 
 #include "ash/ash_switches.h"
 #include "ash/launcher/launcher.h"
 #include "ash/launcher/launcher_model.h"
 #include "ash/root_window_controller.h"
@@ skipping 77 matching lines @@
       const gfx::Point& point_in_parent,
       int window_component) {
     return CreateWindowResizer(
         window,
         point_in_parent,
         window_component,
         aura::client::WINDOW_MOVE_SOURCE_MOUSE).release();
   }
 
   void DragStart(aura::Window* window) {
-    initial_location_in_parent_ = window->bounds().origin();
-    resizer_.reset(CreateSomeWindowResizer(window,
-                                           initial_location_in_parent_,
-                                           HTCAPTION));
-    ASSERT_TRUE(resizer_.get());
+    DragStartAtOffsetFromwindowOrigin(window, 0, 0);
   }
 
   void DragStartAtOffsetFromwindowOrigin(aura::Window* window,
                                          int dx,
                                          int dy) {
     initial_location_in_parent_ =
         window->bounds().origin() + gfx::Vector2d(dx, dy);
     resizer_.reset(CreateSomeWindowResizer(window,
                                            initial_location_in_parent_,
                                            HTCAPTION));
@@ skipping 37 matching lines @@
 
   // Test dragging the window vertically (to detach if it is a panel) and then
   // horizontally to the edge with an added offset from the edge of |dx|.
   void DragRelativeToEdge(DockedEdge edge,
                           aura::Window* window,
                           int dx) {
     DragVerticallyAndRelativeToEdge(
         edge,
         window,
         dx,
-        window_type_ == aura::client::WINDOW_TYPE_PANEL ? -100 : 20);
+        window_type_ == aura::client::WINDOW_TYPE_PANEL ? -100 : 20,
+        25,
+        5);

[flackr, 2013/09/11 18:35:56]

nit: As per the style guide
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Functi...
this only should be one arg per line if it makes it more readable. I think this
would be more readable with multiple args on each line (possibly grouping x and
y pairs onto the same line).

[varkha, 2013/09/11 18:45:56]

Done.

   }
 
   void DragToVerticalPositionAndToEdge(DockedEdge edge,
                                        aura::Window* window,
                                        int y) {
     DragToVerticalPositionRelativeToEdge(edge, window, 0, y);
   }
 
   void DragToVerticalPositionRelativeToEdge(DockedEdge edge,
                                             aura::Window* window,
                                             int dx,
                                             int y) {
     gfx::Rect initial_bounds = window->GetBoundsInScreen();
-    DragVerticallyAndRelativeToEdge(edge, window, dx, y - initial_bounds.y());
+    DragVerticallyAndRelativeToEdge(edge,
+                                    window,
+                                    dx,
+                                    y - initial_bounds.y(),
+                                    25,
+                                    5);
   }
 
   // Detach if our window is a panel, then drag it vertically by |dy| and
   // horizontally to the edge with an added offset from the edge of |dx|.
   void DragVerticallyAndRelativeToEdge(DockedEdge edge,
                                        aura::Window* window,
                                        int dx,
-                                       int dy) {
+                                       int dy,
+                                       int grab_x,
+                                       int grab_y) {
     aura::RootWindow* root_window = window->GetRootWindow();
     gfx::Rect initial_bounds = window->GetBoundsInScreen();
 
     if (window_type_ == aura::client::WINDOW_TYPE_PANEL) {
-      ASSERT_NO_FATAL_FAILURE(DragStart(window));
+      ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromwindowOrigin(window,
+                                                                grab_x,
+                                                                grab_y));
       EXPECT_TRUE(window->GetProperty(kPanelAttachedKey));
 
       // Drag enough to detach since our tests assume panels to be initially
       // detached.
       DragMove(0, dy);
       EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id());
       EXPECT_EQ(initial_bounds.x(), window->GetBoundsInScreen().x());
       EXPECT_EQ(initial_bounds.y() + dy, window->GetBoundsInScreen().y());
 
       // The panel should be detached when the drag completes.
       DragEnd();
 
       EXPECT_FALSE(window->GetProperty(kPanelAttachedKey));
       EXPECT_EQ(internal::kShellWindowId_DefaultContainer,
                 window->parent()->id());
       EXPECT_EQ(root_window, window->GetRootWindow());
     }
 
     // avoid snap by clicking away from the border
-    ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromwindowOrigin(window, 25, 5));
+    ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromwindowOrigin(window,
+                                                              grab_x,
+                                                              grab_y));
 
+    gfx::Rect work_area =
+        Shell::GetScreen()->GetDisplayNearestWindow(window).work_area();
     // Drag the window left or right to the edge (or almost to it).
     if (edge == DOCKED_EDGE_LEFT)
-      dx += window->GetRootWindow()->bounds().x() - initial_bounds.x();
+      dx += work_area.x() - initial_location_in_parent_.x();
     else if (edge == DOCKED_EDGE_RIGHT)
-      dx += window->GetRootWindow()->bounds().right() - initial_bounds.right();
+      dx += work_area.right() - 1 - initial_location_in_parent_.x();
     DragMove(dx, window_type_ == aura::client::WINDOW_TYPE_PANEL ? 0 : dy);
     EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id());
     // Release the mouse and the panel should be attached to the dock.
     DragEnd();
 
     // x-coordinate can get adjusted by snapping or sticking.
     // y-coordinate could be changed by possible automatic layout if docked.
-    if (window->parent()->id() != internal::kShellWindowId_DockedContainer)
+    if (window->parent()->id() != internal::kShellWindowId_DockedContainer &&
+        GetRestoreBoundsInScreen(window) == NULL) {
       EXPECT_EQ(initial_bounds.y() + dy, window->GetBoundsInScreen().y());
+    }
   }
 
   bool test_panels() const {
     return window_type_ == aura::client::WINDOW_TYPE_PANEL;
   }
 
  private:
   scoped_ptr<WindowResizer> resizer_;
   LauncherModel* model_;
   aura::client::WindowType window_type_;
@@ skipping 13 matching lines @@
   scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // The window should be attached and snapped to the right edge.
   EXPECT_EQ(window->GetRootWindow()->bounds().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, window->parent()->id());
 }
 
 // Verifies a window can be dragged and attached to the dock
-// even if we overshoot the screen edge by a few pixels (sticky edge)
+// even if pointer overshoots the screen edge by a few pixels (sticky edge)
 TEST_P(DockedWindowResizerTest, AttachRightOvershoot) {
   if (!SupportsHostWindowResize())
     return;
 
   scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), +4);
 
   // The window should be attached and snapped to the right edge.
   EXPECT_EQ(window->GetRootWindow()->bounds().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, window->parent()->id());
 }
 
-// Verifies a window can be dragged and then if not quite reaching the screen
-// edge it does not get docked to a screen edge and stays in the desktop.
+// Verifies a window can be dragged and then if a pointer is not quite reaching
+// the screen edge the window does not get docked and stays in the desktop.
 TEST_P(DockedWindowResizerTest, AttachRightUndershoot) {
   if (!SupportsHostWindowResize())
     return;
 
   scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
-  DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), -1);
+  // Grabbing at 70px ensures that at least 30% of the window is in screen,
+  // otherwise the window would be adjusted in
+  // WorkspaceLayoutManager::AdjustWindowBoundsWhenAdded.
+  const int kGrabOffsetX = 70;
+  const int kUndershootBy = 1;
+  DragVerticallyAndRelativeToEdge(DOCKED_EDGE_RIGHT,
+                                  window.get(),
+                                  -kUndershootBy,
+                                  test_panels() ? -100 : 20,
+                                  kGrabOffsetX,
+                                  5);
 
-  // The window should not be attached to the dock.
-  EXPECT_EQ(window->GetRootWindow()->bounds().right() - 1,
+  // The window right should be past the screen edge but not docked.
+  // Initial touch point is 70px to the right which helps to find where the edge
+  // should be.
+  EXPECT_EQ(window->GetRootWindow()->bounds().right() +
+            window->bounds().width() - kGrabOffsetX - kUndershootBy - 1,
             window->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DefaultContainer,
             window->parent()->id());
 }
 
 // Verifies a window can be dragged and attached to the dock.
 TEST_P(DockedWindowResizerTest, AttachLeftPrecise) {
   if (!SupportsHostWindowResize())
     return;
 
   scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragRelativeToEdge(DOCKED_EDGE_LEFT, window.get(), 0);
 
   // The window should be attached and snapped to the left dock.
   EXPECT_EQ(window->GetRootWindow()->bounds().x(),
             window->GetBoundsInScreen().x());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, window->parent()->id());
 }
 
 // Verifies a window can be dragged and attached to the dock
-// even if we overshoot the screen edge by a few pixels (sticky edge)
+// even if pointer overshoots the screen edge by a few pixels (sticky edge)
 TEST_P(DockedWindowResizerTest, AttachLeftOvershoot) {
   if (!SupportsHostWindowResize())
     return;
 
   scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragRelativeToEdge(DOCKED_EDGE_LEFT, window.get(), -4);
 
   // The window should be attached and snapped to the left dock.
   EXPECT_EQ(window->GetRootWindow()->bounds().x(),
             window->GetBoundsInScreen().x());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, window->parent()->id());
 }
 
-// Verifies a window can be dragged and then if not quite reaching the screen
-// edge it does not get docked to a screen edge and stays in the desktop.
+// Verifies a window can be dragged and then if a pointer is not quite reaching
+// the screen edge the window does not get docked and stays in the desktop.
 TEST_P(DockedWindowResizerTest, AttachLeftUndershoot) {
   if (!SupportsHostWindowResize())
     return;
 
   scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragRelativeToEdge(DOCKED_EDGE_LEFT, window.get(), 1);
 
-  // The window should not be attached to the dock.
-  EXPECT_EQ(window->GetRootWindow()->bounds().x() + 1,
+  // The window should be touching the screen edge but not docked.
+  EXPECT_EQ(window->GetRootWindow()->bounds().x(),
             window->GetBoundsInScreen().x());
   EXPECT_EQ(internal::kShellWindowId_DefaultContainer,
             window->parent()->id());
 }
 
 // Dock on the right side, change shelf alignment, check that windows move to
 // the opposite side.
 TEST_P(DockedWindowResizerTest, AttachRightChangeShelf) {
   if (!SupportsHostWindowResize())
     return;
@@ skipping 144 matching lines @@
   scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_LEFT, w2.get(), 50);
 
   // The first window should be attached and snapped to the right edge.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
 
   // The second window should be near the left edge but not snapped.
+  // Normal window will get side-maximized while panels will not.
   EXPECT_EQ(w2->GetRootWindow()->bounds().x(), w2->GetBoundsInScreen().x());
   EXPECT_EQ(internal::kShellWindowId_DefaultContainer, w2->parent()->id());
 }
 
 // Reverting drag
 TEST_P(DockedWindowResizerTest, RevertDragRestoresAttachment) {
   if (!SupportsHostWindowResize())
     return;
 
   scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
@@ skipping 18 matching lines @@
             window->parent()->id());
 }
 
 // Move a docked window to the second display
 TEST_P(DockedWindowResizerTest, DragAcrossDisplays) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("800x800,800x800");
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
+  EXPECT_EQ(2, static_cast<int>(root_windows.size()));
   scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   gfx::Rect initial_bounds = window->GetBoundsInScreen();
   EXPECT_EQ(root_windows[0], window->GetRootWindow());
 
   DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
   // The window should be attached and snapped to the right edge.
   EXPECT_EQ(window->GetRootWindow()->bounds().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, window->parent()->id());
 
-  // Undock and move to the right - enough to get it peeking at the other screen
-  // but not enough to land in the other screen
+  // Try dragging to the right - enough to get it peeking at the other screen
+  // but not enough to land in the other screen.
+  // The window should stay on the left screen.
   ASSERT_NO_FATAL_FAILURE(DragStart(window.get()));
-  DragMove(70, 0);
-  EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id());
-  DragEnd();
-  EXPECT_NE(window->GetRootWindow()->bounds().right(),
-            window->GetBoundsInScreen().right());
-  EXPECT_EQ(internal::kShellWindowId_DefaultContainer,
-            window->parent()->id());
-  EXPECT_EQ(root_windows[0], window->GetRootWindow());
-
-  // Move back left - should dock again.
-  ASSERT_NO_FATAL_FAILURE(DragStart(window.get()));
-  DragMove(-70, 0);
+  DragMove(100, 0);
   EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id());
   DragEnd();
   EXPECT_EQ(window->GetRootWindow()->bounds().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer,
             window->parent()->id());
   EXPECT_EQ(root_windows[0], window->GetRootWindow());
 
   // Undock and move to the right - enough to get the mouse pointer past the
   // edge of the screen and into the second screen. The window should now be
   // in the second screen and not docked.
   ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromwindowOrigin(
       window.get(),
       window->bounds().width()/2 + 10,
       0));
   DragMove(window->bounds().width()/2 - 5, 0);
   EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id());
   DragEnd();
   EXPECT_NE(window->GetRootWindow()->bounds().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DefaultContainer,
             window->parent()->id());
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
 
-  // Keep dragging it to the right until it docks. The window should now be
-  // in the second screen.
+  // Keep dragging it to the right until its left edge touches the screen edge.
+  // The window should now be in the second screen and not docked.
   ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromwindowOrigin(
       window.get(),
       window->bounds().width()/2 + 10,
       0));
   DragMove(window->GetRootWindow()->GetBoundsInScreen().x() -
            window->GetBoundsInScreen().x(),
            0);
   EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id());
   DragEnd();
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().x(),
             window->GetBoundsInScreen().x());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, window->parent()->id());
+  EXPECT_EQ(internal::kShellWindowId_DefaultContainer, window->parent()->id());
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
 }
 
 // Dock two windows, undock one.
 // Test the docked windows area size and default container resizing.
 TEST_P(DockedWindowResizerTest, AttachTwoWindowsDetachOne)
 {
   if (!SupportsHostWindowResize())
     return;
 
@@ skipping 57 matching lines @@
   EXPECT_EQ(w2->GetRootWindow()->bounds().right() -
             (w2->bounds().width()/2 + 20),
             w2->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DefaultContainer, w2->parent()->id());
   // Dock width should be set to remaining single docked window.
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, manager->alignment_);
   EXPECT_EQ(w1->bounds().width(), manager->docked_width_);
 }
 
-// Dock one windows. Maximize other testing desktop resizing.
+// Dock one of the windows. Maximize other testing desktop resizing.
 TEST_P(DockedWindowResizerTest, AttachWindowMaximizeOther)
 {
   if (!SupportsHostWindowResize())
     return;
 
   scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 201)));
   // Work area should cover the whole screen.
   EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w2.get()).width(),
             ScreenAsh::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // A window should be attached and snapped to the right edge.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   DockedWindowLayoutManager* manager =
       static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, manager->alignment_);
   EXPECT_EQ(w1->bounds().width(), manager->docked_width_);
 
-  DragToVerticalPositionRelativeToEdge(DOCKED_EDGE_RIGHT,
-                                       w2.get(),
-                                       -(w2->bounds().width()/2 + 20),
-                                       50);
+  ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromwindowOrigin(w2.get(), 25, 5));
+  DragMove(w2->GetRootWindow()->bounds().right()
+           -w2->bounds().width()
+           -(w2->bounds().width()/2 + 20)
+           -w2->bounds().x(),
+           50 - w2->bounds().y());
+  DragEnd();
   // The first window should be still docked.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
 
   // The second window should be floating on the desktop.
   EXPECT_EQ(w2->GetRootWindow()->bounds().right() -
             (w2->bounds().width()/2 + 20),
             w2->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DefaultContainer, w2->parent()->id());
@@ skipping 27 matching lines @@
   EXPECT_EQ(internal::kShellWindowId_DefaultContainer, w2->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_NONE, manager->alignment_);
   EXPECT_EQ(0, manager->docked_width_);
   // The second window should now get resized and take up the whole screen.
   EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w2.get()).width(),
             w2->bounds().width());
 
   // Dock the first window to the left edge.
   // Click at an offset from origin to prevent snapping.
   ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromwindowOrigin(w1.get(), 10, 0));
-  DragMove(-w1->bounds().x(), 0);
+  // Drag left to get pointer touching the screen edge.
+  DragMove(-w1->bounds().x() - 10, 0);
   // Alignment set to "NONE" during the drag of the window when none are docked.
   EXPECT_EQ(DOCKED_ALIGNMENT_NONE, manager->alignment_);
   // Release the mouse and the window should be now attached to the edge.
   DragEnd();
   // Dock should get expanded and desktop should get shrunk.
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, manager->alignment_);
   EXPECT_EQ(w1->bounds().width(), manager->docked_width_);
   // Second window should still be in the desktop.
   EXPECT_EQ(internal::kShellWindowId_DefaultContainer, w2->parent()->id());
@@ skipping 28 matching lines @@
   DockedWindowLayoutManager* manager =
       static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager());
   // The first window should be docked.
   EXPECT_EQ(w1->GetRootWindow()->bounds().x(),
             w1->GetBoundsInScreen().x());
   // Dock width should be set to that of a single docked window.
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, manager->alignment_);
   EXPECT_EQ(w1->bounds().width(), manager->docked_width_);
 
-  // Position second window in the desktop just to the right of the docked w1.
+  // Position second window in the desktop 20px to the right of the docked w1.
   DragToVerticalPositionRelativeToEdge(DOCKED_EDGE_LEFT,
                                        w2.get(),
-                                       w1->bounds().right() + 20,
+                                       20 +
+                                       25 -
+                                       DockedWindowLayoutManager::kMinDockGap,
                                        50);
   // The second window should be floating on the desktop.
   EXPECT_EQ(w2->GetRootWindow()->bounds().x() + (w1->bounds().right() + 20),
             w2->GetBoundsInScreen().x());
   EXPECT_EQ(internal::kShellWindowId_DefaultContainer, w2->parent()->id());
   // Dock width should be set to that of a single docked window.
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, manager->alignment_);
   EXPECT_EQ(w1->bounds().width(), manager->docked_width_);
 
@@ skipping 106 matching lines @@
   // w1 is now wider than w2 and the dock should expand and be as wide as w1.
   EXPECT_EQ(previous_width + kResizeSpan1, w1->bounds().width());
   EXPECT_GT(w1->bounds().width(), w2->bounds().width());
   EXPECT_EQ(w1->bounds().width(), manager->docked_width_);
   // Desktop work area should shrink.
   EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w2.get()).width() -
             manager->docked_width_ - DockedWindowLayoutManager::kMinDockGap,
             ScreenAsh::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   // Resize the first window left by more than the dock maximum width.
-  // This should cause the window to overhang and the dock to shrink to w2.
+  // This should cause the window width to be restricted by maximum dock width.
   previous_width = w1->bounds().width();
   const int kResizeSpan2 = 250;
   ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromwindowOrigin(w1.get(),
                                                               0,
                                                               20,
                                                               HTLEFT));
   DragMove(-kResizeSpan2, 0);
   // Alignment set to "RIGHT" during the drag because dock has a window in it.
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, manager->alignment_);
   // Release the mouse and the window should be attached to the edge.
   DragEnd();
   // Dock should still have both windows in it.
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w2->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, manager->alignment_);
-  // w1 is now wider than the maximum dock width and the dock should shrink to
-  // the next widest window (w2).
-  EXPECT_EQ(previous_width + kResizeSpan2, w1->bounds().width());
+  // w1 is now as wide as the maximum dock width and the dock should get
+  // resized to the maximum width.
+  EXPECT_EQ(DockedWindowLayoutManager::kMaxDockWidth, w1->bounds().width());
   EXPECT_GT(w1->bounds().width(), w2->bounds().width());
-  EXPECT_EQ(w2->bounds().width(), manager->docked_width_);
+  EXPECT_EQ(w1->bounds().width(), manager->docked_width_);
   // Desktop work area should shrink.
   EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w2.get()).width() -
             manager->docked_width_ - DockedWindowLayoutManager::kMinDockGap,
             ScreenAsh::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   // Resize the first window right to get it completely inside the docked area.
   previous_width = w1->bounds().width();
   const int kResizeSpan3 = 100;
   ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromwindowOrigin(w1.get(),
                                                               0,
@@ skipping 20 matching lines @@
   // Resize the first window left to be overhang again.
   previous_width = w1->bounds().width();
   ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromwindowOrigin(w1.get(),
                                                               0,
                                                               20,
                                                               HTLEFT));
   DragMove(-kResizeSpan3, 0);
   DragEnd();
   EXPECT_EQ(previous_width + kResizeSpan3, w1->bounds().width());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
-  // Docked area should be as wide as the second window - the first is too wide.
-  EXPECT_EQ(w2->bounds().width(), manager->docked_width_);
+  // Docked area should be as wide as possible (maximum) and same as w1.
+  EXPECT_EQ(DockedWindowLayoutManager::kMaxDockWidth, manager->docked_width_);
+  EXPECT_EQ(w1->bounds().width(), manager->docked_width_);
 
   // Undock the second window. Docked area should shrink to its minimum size.
   ASSERT_NO_FATAL_FAILURE(DragStart(w2.get()));
   // Drag up as well to avoid attaching panels to launcher shelf.
-  DragMove(-40, -100);
+  DragMove(-(400 - 201), -100);
   // Alignment set to "RIGHT" since we have another window docked.
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, manager->alignment_);
   // Release the mouse and the window should be no longer attached to the edge.
   DragEnd();
   EXPECT_EQ(internal::kShellWindowId_DefaultContainer, w2->parent()->id());
-  // Dock should get shrunk to minimum size.
+  // Dock should be as wide as w1 (and same as maximum width).
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, manager->alignment_);
-  EXPECT_EQ(manager->kMinDockWidth, manager->docked_width_);
+  EXPECT_EQ(DockedWindowLayoutManager::kMaxDockWidth, manager->docked_width_);
+  EXPECT_EQ(w1->bounds().width(), manager->docked_width_);
   // The first window should be still docked.
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   // Desktop work area should be inset.
   EXPECT_EQ(ScreenAsh::GetDisplayBoundsInParent(w2.get()).width() -
             manager->docked_width_ - DockedWindowLayoutManager::kMinDockGap,
             ScreenAsh::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 }
 
 TEST_P(DockedWindowResizerTest, DragToShelf)
 {
@@ skipping 41 matching lines @@
   }
 }
 
 // Tests run twice - on both panels and normal windows
 INSTANTIATE_TEST_CASE_P(NormalOrPanel,
                         DockedWindowResizerTest,
                         testing::Values(aura::client::WINDOW_TYPE_NORMAL,
                                         aura::client::WINDOW_TYPE_PANEL));
 }  // namespace internal
 }  // namespace ash