Windows docking should get triggered by pressing against the screen edge

ash/wm/workspace/workspace_window_resizer.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 <algorithm>
 #include <cmath>
 #include <utility>
 #include <vector>
 
 #include "ash/ash_switches.h"
+#include "ash/display/display_controller.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/default_window_resizer.h"
 #include "ash/wm/dock/docked_window_resizer.h"
 #include "ash/wm/drag_window_resizer.h"
 #include "ash/wm/panels/panel_window_resizer.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace/phantom_window_controller.h"
 #include "ash/wm/workspace/snap_sizer.h"
 #include "base/command_line.h"
+#include "base/memory/weak_ptr.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/client/window_types.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/transform.h"
@@ skipping 339 matching lines @@
     if (!did_move_or_resize_) {
       if (!details_.restore_bounds.IsEmpty())
         ClearRestoreBounds(window());
       RestackWindows();
     }
     did_move_or_resize_ = true;
   }
 
   gfx::Point location_in_screen = location_in_parent;
   wm::ConvertPointToScreen(window()->parent(), &location_in_screen);
-  const bool in_original_root =
-      wm::GetRootWindowAt(location_in_screen) == window()->GetRootWindow();
+
+  aura::RootWindow* root = NULL;
+  gfx::Display display =
+      ScreenAsh::FindDisplayContainingPoint(location_in_screen);
+  // Track the last screen that the pointer was on to keep the snap phantom
+  // window there.
+  if (display.is_valid()) {
+    root = Shell::GetInstance()->display_controller()->
+        GetRootWindowForDisplayId(display.id());
+  }
+  if (!attached_windows_.empty())
+    LayoutAttachedWindows(&bounds);
+  if (bounds != window()->bounds()) {
+    // SetBounds needs to be called to update the layout which affects where the
+    // phantom window is drawn. Keep track if the window was destroyed during
+    // the drag and quit early if so.
+    base::WeakPtr<WorkspaceWindowResizer> resizer(
+        weak_ptr_factory_.GetWeakPtr());
+    window()->SetBounds(bounds);
+    if (!resizer)
+      return;
+  }
+  const bool in_original_root = !root || root == window()->GetRootWindow();
   // Hide a phantom window for snapping if the cursor is in another root window.
-  if (in_original_root && wm::CanResizeWindow(window())) {
+  if (in_original_root) {
     UpdateSnapPhantomWindow(location_in_parent, bounds);
   } else {
     snap_type_ = SNAP_NONE;
     snap_phantom_window_controller_.reset();
+    snap_sizer_.reset();
   }
-
-  if (!attached_windows_.empty())
-    LayoutAttachedWindows(&bounds);
-  if (bounds != window()->bounds())
-    window()->SetBounds(bounds);
 }
 
 void WorkspaceWindowResizer::CompleteDrag(int event_flags) {
   wm::SetUserHasChangedWindowPositionOrSize(details_.window, true);
   snap_phantom_window_controller_.reset();
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
   // When the window is not in the normal show state, we do not snap the window.
   // This happens when the user minimizes or maximizes the window by keyboard
   // shortcut while dragging it. If the window is the result of dragging a tab
   // out of a maximized window, it's already in the normal show state when this
   // is called, so it does not matter.
   if (wm::IsWindowNormal(window()) &&
       (window()->type() != aura::client::WINDOW_TYPE_PANEL ||
        !window()->GetProperty(kPanelAttachedKey)) &&
-      (snap_type_ == SNAP_LEFT_EDGE || snap_type_ == SNAP_RIGHT_EDGE)) {
+      (snap_type_ == SNAP_LEFT || snap_type_ == SNAP_RIGHT)) {
     if (!GetRestoreBoundsInScreen(window())) {
       gfx::Rect initial_bounds = ScreenAsh::ConvertRectToScreen(
           window()->parent(), details_.initial_bounds_in_parent);
       SetRestoreBoundsInScreen(window(), details_.restore_bounds.IsEmpty() ?
                                initial_bounds :
                                details_.restore_bounds);
     }
-    window()->SetBounds(snap_sizer_->target_bounds());
+    DCHECK(snap_sizer_);
+    if (wm::CanResizeWindow(window()) &&
+        !snap_sizer_->ShouldDockWindow() &&
+        !snap_sizer_->target_bounds().IsEmpty()) {
+      window()->SetBounds(snap_sizer_->target_bounds());
+    }
     return;
   }
 }
 
 void WorkspaceWindowResizer::RevertDrag() {
   snap_phantom_window_controller_.reset();
 
   if (!did_move_or_resize_)
     return;
 
@@ skipping 33 matching lines @@
 WorkspaceWindowResizer::WorkspaceWindowResizer(
     const Details& details,
     const std::vector<aura::Window*>& attached_windows)
     : details_(details),
       attached_windows_(attached_windows),
       did_move_or_resize_(false),
       total_min_(0),
       total_initial_size_(0),
       snap_type_(SNAP_NONE),
       num_mouse_moves_since_bounds_change_(0),
-      magnetism_window_(NULL) {
+      magnetism_window_(NULL),
+      weak_ptr_factory_(this) {
   DCHECK(details_.is_resizable);
 
   Shell* shell = Shell::GetInstance();
   shell->cursor_manager()->LockCursor();
 
   // Only support attaching to the right/bottom.
   DCHECK(attached_windows_.empty() ||
          (details.window_component == HTRIGHT ||
           details.window_component == HTBOTTOM));
 
   // TODO: figure out how to deal with window going off the edge.
 
   // Calculate sizes so that we can maintain the ratios if we need to resize.
   int total_available = 0;
   for (size_t i = 0; i < attached_windows_.size(); ++i) {
     gfx::Size min(attached_windows_[i]->delegate()->GetMinimumSize());
     int initial_size = PrimaryAxisSize(attached_windows_[i]->bounds().size());
     initial_size_.push_back(initial_size);
     // If current size is smaller than the min, use the current size as the min.
     // This way we don't snap on resize.
     int min_size = std::min(initial_size,
                             std::max(PrimaryAxisSize(min), kMinOnscreenSize));
     total_min_ += min_size;
     total_initial_size_ += initial_size;
     total_available += std::max(min_size, initial_size) - min_size;
   }
+  snap_type_ = GetSnapType(details_.initial_location_in_parent);
 }
 
 gfx::Rect WorkspaceWindowResizer::GetFinalBounds(
     const gfx::Rect& bounds) const {
   if (snap_phantom_window_controller_.get() &&
       snap_phantom_window_controller_->IsShowing()) {
     return snap_phantom_window_controller_->bounds_in_screen();
   }
   return bounds;
 }
@@ skipping 332 matching lines @@
       NOTREACHED();
   }
   return 0;
 }
 
 void WorkspaceWindowResizer::UpdateSnapPhantomWindow(const gfx::Point& location,
                                                      const gfx::Rect& bounds) {
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
-  if (!wm::CanSnapWindow(window()))
-    return;
-
-  if (window()->type() == aura::client::WINDOW_TYPE_PANEL &&
-      window()->GetProperty(kPanelAttachedKey)) {
-    return;
-  }
-
   SnapType last_type = snap_type_;
   snap_type_ = GetSnapType(location);
   if (snap_type_ == SNAP_NONE || snap_type_ != last_type) {
     snap_phantom_window_controller_.reset();
+    if (snap_type_ == SNAP_NONE && snap_type_ != last_type) {
+      // Create and delete a SnapSizer to maintain docked state.

[flackr, 2013/09/10 17:59:44]

Why do we create a SnapSizer only to delete it? This isn't clear to me.

[varkha, 2013/09/10 21:49:35]

This is to keep the awareness about docked state restricted to
DockedWindowResizer and SnapSizer classes. I have moved the creation of a
SnapSizer when the drag is first detected, this way I hope the state is clearer
- a SnapSizer is now always created when the window is snapped but may get
destroyed when it gets unsnapped.

[flackr, 2013/09/11 18:08:50]

Yes, I think this is clearer, thanks.

+      snap_sizer_.reset(new SnapSizer(
+          window(),
+          details_.initial_location_in_parent,
+          (last_type == SNAP_LEFT) ?
+              SnapSizer::LEFT_EDGE : SnapSizer::RIGHT_EDGE,
+              internal::SnapSizer::WORKSPACE_DRAG_INPUT));
+    }
     snap_sizer_.reset();
     if (snap_type_ == SNAP_NONE)
       return;
   }
+  SnapSizer::Edge edge = (snap_type_ == SNAP_LEFT) ?
+      SnapSizer::LEFT_EDGE : SnapSizer::RIGHT_EDGE;
+
   if (!snap_sizer_) {
-    SnapSizer::Edge edge = (snap_type_ == SNAP_LEFT_EDGE) ?
-        SnapSizer::LEFT_EDGE : SnapSizer::RIGHT_EDGE;
     snap_sizer_.reset(new SnapSizer(window(),
                                     location,
                                     edge,
-                                    internal::SnapSizer::OTHER_INPUT));
+                                    internal::SnapSizer::WORKSPACE_DRAG_INPUT));
   } else {
     snap_sizer_->Update(location);
   }
+
+  // Update phantom window when it is used for side-maximizing.
+  // In case of docking it will be called directly by the chained resizer.
+  if (!wm::CanSnapWindow(window()) && !SnapSizer::CanDockWindow(window(), edge))
+    return;
+
+  if (snap_sizer_->target_bounds().IsEmpty()) {
+    snap_phantom_window_controller_.reset();
+    return;
+  }
   if (!snap_phantom_window_controller_) {
     snap_phantom_window_controller_.reset(
         new PhantomWindowController(window()));
   }
   snap_phantom_window_controller_->Show(ScreenAsh::ConvertRectToScreen(
       window()->parent(), snap_sizer_->target_bounds()));
 }
 
 void WorkspaceWindowResizer::RestackWindows() {
   if (attached_windows_.empty())
@@ skipping 19 matching lines @@
   parent->StackChildAtTop(map.rbegin()->second);
   for (IndexToWindowMap::const_reverse_iterator i = map.rbegin();
        i != map.rend(); ) {
     aura::Window* window = i->second;
     ++i;
     if (i != map.rend())
       parent->StackChildBelow(i->second, window);
   }
 }
 
-WorkspaceWindowResizer::SnapType WorkspaceWindowResizer::GetSnapType(
+SnapType WorkspaceWindowResizer::GetSnapType(
     const gfx::Point& location) const {
   // TODO: this likely only wants total display area, not the area of a single
   // display.
-  gfx::Rect area(ScreenAsh::GetDisplayBoundsInParent(window()));
+  gfx::Rect area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(window()));
   if (location.x() <= area.x())
-    return SNAP_LEFT_EDGE;
+    return SNAP_LEFT;
   if (location.x() >= area.right() - 1)
-    return SNAP_RIGHT_EDGE;
+    return SNAP_RIGHT;
   return SNAP_NONE;
 }
 
 }  // namespace internal
 }  // namespace ash