Allow the cursor to warp even when a window is dragged

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 "ash/display/display_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
+#include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/cursor_manager.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace/phantom_window_controller.h"
 #include "ash/wm/workspace/snap_sizer.h"
+#include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
+#include "ui/aura/root_window.h"

[Daniel Erat, 2012/08/06 18:16:20]

nit: fix alphabetization

[Yusuke Sato, 2012/08/06 18:27:06]

Done.

 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/transform.h"
 
 namespace ash {
 namespace internal {
 
 namespace {
 
 // Duration of the animation when snapping the window into place.
 const int kSnapDurationMS = 100;
 
 // Returns true if should snap to the edge.
 bool ShouldSnapToEdge(int distance_from_edge, int grid_size) {
   return distance_from_edge <= grid_size / 2 &&
       distance_from_edge > -grid_size * 2;
 }
 
 }  // namespace
 
 // static
 const int WorkspaceWindowResizer::kMinOnscreenSize = 20;
 
 // static
 const int WorkspaceWindowResizer::kMinOnscreenHeight = 32;
 
 WorkspaceWindowResizer::~WorkspaceWindowResizer() {
-  ash::Shell::GetInstance()->cursor_manager()->UnlockCursor();
+  Shell* shell = Shell::GetInstance();
+  shell->display_controller()->set_dont_warp_mouse(false);
+  shell->cursor_manager()->UnlockCursor();
 }
 
 // static
 WorkspaceWindowResizer* WorkspaceWindowResizer::Create(
     aura::Window* window,
     const gfx::Point& location_in_parent,
     int window_component,
     const std::vector<aura::Window*>& attached_windows) {
   Details details(window, location_in_parent, window_component);
   return details.is_resizable ?
       new WorkspaceWindowResizer(details, attached_windows) : NULL;
 }
 
 void WorkspaceWindowResizer::Drag(const gfx::Point& location, int event_flags) {
+  std::pair<aura::RootWindow*, gfx::Point> actual_location =
+      wm::GetRootWindowRelativeToWindow(window()->parent(), location);
+
+  // TODO(yusukes): Implement dragging a window from one display to another.
+  aura::RootWindow* current_root = actual_location.first;
+  if (current_root != window()->GetRootWindow())
+    return;
+
   int grid_size = event_flags & ui::EF_CONTROL_DOWN ?
                   0 : ash::Shell::GetInstance()->GetGridSize();
   gfx::Rect bounds = CalculateBoundsForDrag(details_, location, grid_size);
 
   if (wm::IsWindowNormal(details_.window))
     AdjustBoundsForMainWindow(&bounds, grid_size);
   if (bounds != details_.window->bounds()) {
     if (!did_move_or_resize_)
       RestackWindows();
     did_move_or_resize_ = true;
@@ skipping 83 matching lines @@
     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) {
   DCHECK(details_.is_resizable);
-  ash::Shell::GetInstance()->cursor_manager()->LockCursor();
+
+  Shell* shell = Shell::GetInstance();
+  shell->cursor_manager()->LockCursor();
+
+  // The pointer should be confined in one display during resizing a window
+  // because the window cannot span two displays at the same time anyway. The
+  // exception is window/tab dragging operation. During that operation,
+  // |dont_warp_mouse_| should be set to false so that the user could move a
+  // window/tab to another display.
+  shell->display_controller()->set_dont_warp_mouse(!ShouldAllowMouseWarp());
 
   // 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;
@@ skipping 256 matching lines @@
   // TODO: this likely only wants total display area, not the area of a single
   // display.
   gfx::Rect area(ScreenAsh::GetDisplayBoundsInParent(details_.window));
   if (location.x() <= area.x())
     return SNAP_LEFT_EDGE;
   if (location.x() >= area.right() - 1)
     return SNAP_RIGHT_EDGE;
   return SNAP_NONE;
 }
 
+bool WorkspaceWindowResizer::ShouldAllowMouseWarp() const {
+  return (details_.window_component == HTCAPTION) &&
+      (window()->GetProperty(aura::client::kModalKey) == ui::MODAL_TYPE_NONE) &&
+      (window()->type() == aura::client::WINDOW_TYPE_NORMAL);
+}
+
 }  // namespace internal
 }  // namespace ash