Windows docking should get triggered by pressing against the screen edge

ash/wm/dock/docked_window_layout_manager_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_layout_manager.h"
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_controller.h"
 #include "ash/launcher/launcher.h"
 #include "ash/launcher/launcher_model.h"
@@ skipping 79 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 53 matching lines @@
   // 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) {
     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, 25, 5));
       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));
 
+    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());
+    }
   }
 
  private:
   scoped_ptr<WindowResizer> resizer_;
   scoped_ptr<test::LauncherViewTestAPI> launcher_view_test_;
   aura::client::WindowType window_type_;
 
   // Location at start of the drag in |window->parent()|'s coordinates.
   gfx::Point initial_location_in_parent_;
 
@@ skipping 57 matching lines @@
   // The windows should be attached and snapped to the right side of the screen.
   EXPECT_EQ(w1->GetRootWindow()->bounds().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(w2->GetRootWindow()->bounds().right(),
             w2->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, w2->parent()->id());
 
   // Drag w2 above w1.
   ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromwindowOrigin(w2.get(), 0, 20));
-  DragMove(0, w1->bounds().y() - w2->bounds().y() - 20);
+  DragMove(0, w1->bounds().y() - w2->bounds().y() + 20);
   DragEnd();
 
   // Test the new windows order and that the gaps differ at most by a pixel.
   int gap1 = w2->GetBoundsInScreen().y();
   int gap2 = w1->GetBoundsInScreen().y() - w2->GetBoundsInScreen().bottom();
   int gap3 = ScreenAsh::GetDisplayWorkAreaBoundsInParent(w1.get()).bottom() -
       w1->GetBoundsInScreen().bottom();
   EXPECT_LE(abs(gap1 - gap2), 1);
   EXPECT_LE(abs(gap2 - gap3), 1);
   EXPECT_LE(abs(gap3 - gap1), 1);
@@ skipping 125 matching lines @@
   EXPECT_EQ(0, overlap4);
 }
 
 // Tests run twice - on both panels and normal windows
 INSTANTIATE_TEST_CASE_P(NormalOrPanel,
                         DockedWindowLayoutManagerTest,
                         testing::Values(aura::client::WINDOW_TYPE_NORMAL,
                                         aura::client::WINDOW_TYPE_PANEL));
 }  // namespace internal
 }  // namespace ash