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"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_types.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/launcher_view_test_api.h"
 #include "ash/test/shell_test_api.h"
 #include "ash/test/test_launcher_delegate.h"
+#include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/panels/panel_layout_manager.h"
 #include "ash/wm/window_resizer.h"
 #include "ash/wm/window_settings.h"
 #include "ash/wm/window_util.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
@@ skipping 60 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) {
+                                         int dx, int dy) {
     initial_location_in_parent_ =
         window->bounds().origin() + gfx::Vector2d(dx, dy);
     resizer_.reset(CreateSomeWindowResizer(window,
                                            initial_location_in_parent_,
                                            HTCAPTION));
     ASSERT_TRUE(resizer_.get());
   }
 
   void DragMove(int dx, int dy) {
     resizer_->Drag(initial_location_in_parent_ + gfx::Vector2d(dx, dy), 0);
@@ skipping 42 matching lines @@
                                             int dx,
                                             int y) {
     gfx::Rect initial_bounds = window->GetBoundsInScreen();
     DragVerticallyAndRelativeToEdge(edge, window, dx, y - initial_bounds.y());
   }
 
   // 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();
+                                       int dx, int dy) {
     gfx::Rect initial_bounds = window->GetBoundsInScreen();
-
-    if (window_type_ == aura::client::WINDOW_TYPE_PANEL) {
-      ASSERT_NO_FATAL_FAILURE(DragStart(window));
-      EXPECT_TRUE(wm::GetWindowSettings(window)->panel_attached());
-
-      // 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(wm::GetWindowSettings(window)->panel_attached());
-      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();
+    gfx::Point initial_location_in_screen = initial_location_in_parent_;
+    wm::ConvertPointToScreen(window->parent(), &initial_location_in_screen);
     // 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_screen.x();
     else if (edge == DOCKED_EDGE_RIGHT)
-      dx += window->GetRootWindow()->bounds().right() - initial_bounds.right();
-    DragMove(dx, window_type_ == aura::client::WINDOW_TYPE_PANEL ? 0 : dy);
+      dx += work_area.right() - 1 - initial_location_in_screen.x();
+    DragMove(dx, 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 109 matching lines @@
 
   // |window1| should be flush left and |window2| flush right.
   EXPECT_EQ("0,32 231x320", window1->bounds().ToString());
   EXPECT_EQ(
       base::IntToString(
           desktop_area.width() - window2->bounds().width() -
           manager->docked_width_ - DockedWindowLayoutManager::kMinDockGap) +
       ",48 256x512", window2->bounds().ToString());
 }
 
-// Tests that with a window docked on the left the auto-placing logic in
-// RearrangeVisibleWindowOnShow places windows flush with work area edges.
-// Test case for the secondary screen.
-TEST_P(DockedWindowLayoutManagerTest, AutoPlacingLeftSecondScreen) {
-  if (!SupportsMultipleDisplays() || !SupportsHostWindowResize())
-    return;
-
-  // Create two screen layout.
-  UpdateDisplay("600x600,600x600");
-
-  gfx::Rect bounds(600, 0, 201, 201);
-  scoped_ptr<aura::Window> window(CreateTestWindow(bounds));
-  DragRelativeToEdge(DOCKED_EDGE_LEFT, window.get(), 600);
-
-  // The window should be attached and snapped to the right side of the screen.
-  EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().x(),
-            window->GetBoundsInScreen().x());
-  EXPECT_EQ(internal::kShellWindowId_DockedContainer, window->parent()->id());
-
-  DockedWindowLayoutManager* manager = static_cast<DockedWindowLayoutManager*>(
-      window->parent()->layout_manager());
-
-  // Create two additional windows and test their auto-placement
-  bounds = gfx::Rect(850, 32, 231, 320);
-  scoped_ptr<aura::Window> window1(
-      CreateTestWindowInShellWithDelegate(NULL, 1, bounds));
-  gfx::Rect desktop_area = window1->parent()->bounds();
-  wm::GetWindowSettings(window1.get())->set_window_position_managed(true);
-  window1->Hide();
-  window1->Show();
-  // |window1| should be centered in work area.
-  EXPECT_EQ(base::IntToString(
-      600 + manager->docked_width_ + DockedWindowLayoutManager::kMinDockGap +
-      (desktop_area.width() - manager->docked_width_ -
-       DockedWindowLayoutManager::kMinDockGap - window1->bounds().width()) / 2)+
-      ",32 231x320", window1->GetBoundsInScreen().ToString());
-
-  bounds = gfx::Rect(850, 48, 150, 300);
-  scoped_ptr<aura::Window> window2(
-      CreateTestWindowInShellWithDelegate(NULL, 2, bounds));
-  wm::GetWindowSettings(window2.get())->set_window_position_managed(true);
-  // To avoid any auto window manager changes due to SetBounds, the window
-  // gets first hidden and then shown again.
-  window2->Hide();
-  window2->Show();
-
-  // |window1| should be flush left and |window2| flush right.
-  EXPECT_EQ(
-      base::IntToString(600 +
-          manager->docked_width_ + DockedWindowLayoutManager::kMinDockGap) +
-      ",32 231x320", window1->GetBoundsInScreen().ToString());
-  EXPECT_EQ(
-      base::IntToString(
-          600 + desktop_area.width() - window2->bounds().width()) +
-      ",48 150x300", window2->GetBoundsInScreen().ToString());
-}
-
 // Tests that with a window docked on the right the auto-placing logic in
 // RearrangeVisibleWindowOnShow places windows flush with work area edges.
 // Test case for the secondary screen.
 TEST_P(DockedWindowLayoutManagerTest, AutoPlacingRightSecondScreen) {
   if (!SupportsMultipleDisplays() || !SupportsHostWindowResize())
     return;
 
   // Create two screen layout.
   UpdateDisplay("600x600,600x600");
 
   gfx::Rect bounds(600, 0, 201, 201);
   scoped_ptr<aura::Window> window(CreateTestWindow(bounds));
-  DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 600);
+  // Drag pointer to the right edge of the second screen.
+  DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0);
 
   // The window should be attached and snapped to the right side of the screen.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(internal::kShellWindowId_DockedContainer, window->parent()->id());
 
   DockedWindowLayoutManager* manager = static_cast<DockedWindowLayoutManager*>(
       window->parent()->layout_manager());
 
   // Create two additional windows and test their auto-placement
@@ skipping 70 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 123 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