Extract the code for supporing extended desktop from WorkspaceWindowResizer into DragWindowResizer.

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/display/display_controller.h"
-#include "ash/display/mouse_cursor_event_filter.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/cursor_manager.h"
 #include "ash/wm/default_window_resizer.h"
-#include "ash/wm/drag_window_controller.h"
+#include "ash/wm/drag_window_resizer.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/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"
 
 namespace ash {
 
 scoped_ptr<WindowResizer> CreateWindowResizer(aura::Window* window,
                                               const gfx::Point& point_in_parent,
                                               int window_component) {
   DCHECK(window);
   // No need to return a resizer when the window cannot get resized.
   if (!wm::CanResizeWindow(window) && window_component != HTCAPTION)
     return scoped_ptr<WindowResizer>();
 
+  WindowResizer::Details details(window, point_in_parent, window_component);
+  if (!details.is_resizable)
+    return scoped_ptr<WindowResizer>();
+
+  WindowResizer* window_resizer = NULL;
   if (window->parent() &&
       window->parent()->id() == internal::kShellWindowId_WorkspaceContainer) {
     // Allow dragging maximized windows if it's not tracked by workspace. This
     // is set by tab dragging code.
     if (!wm::IsWindowNormal(window) &&
         (window_component != HTCAPTION || GetTrackedByWorkspace(window)))
       return scoped_ptr<WindowResizer>();
-    return make_scoped_ptr<WindowResizer>(
-        internal::WorkspaceWindowResizer::Create(window,
-                                                 point_in_parent,
-                                                 window_component,
-                                                 std::vector<aura::Window*>()));
+    window_resizer = new internal::WorkspaceWindowResizer(
+        details, std::vector<aura::Window*>());
   } else if (wm::IsWindowNormal(window)) {
-    return make_scoped_ptr<WindowResizer>(DefaultWindowResizer::Create(
-        window,
-        point_in_parent,
-        window_component));
-  } else {
-    return scoped_ptr<WindowResizer>();
+    window_resizer = new DefaultWindowResizer(details);
   }
+  if (window_resizer)
+    window_resizer = new internal::DragWindowResizer(window_resizer, details);
+  return make_scoped_ptr<WindowResizer>(window_resizer);
 }
 
 namespace internal {
 
 namespace {
 
 // Duration of the animation when snapping the window into place.
 const int kSnapDurationMS = 100;
 
-// The maximum opacity of the drag phantom window.
-const float kMaxOpacity = 0.8f;
-
 // Returns true if should snap to the edge.
 bool ShouldSnapToEdge(int distance_from_edge, int grid_size) {
   return distance_from_edge < grid_size &&
       distance_from_edge > -grid_size * 2;
 }
 
-// Returns true if Ash has more than one root window.
-bool HasSecondaryRootWindow() {
-  return Shell::GetAllRootWindows().size() > 1;
-}
-
-// When there are two root windows, returns one of the root windows which is not
-// |root_window|. Returns NULL if only one root window exists.
-aura::RootWindow* GetAnotherRootWindow(aura::RootWindow* root_window) {
-  Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
-  if (root_windows.size() < 2)
-    return NULL;
-  DCHECK_EQ(2U, root_windows.size());
-  if (root_windows[0] == root_window)
-    return root_windows[1];
-  return root_windows[0];
-}
-
 // Returns the coordinate along the secondary axis to snap to.
 int CoordinateAlongSecondaryAxis(SecondaryMagnetismEdge edge,
                                  int leading,
                                  int trailing,
                                  int none) {
   switch (edge) {
     case SECONDARY_MAGNETISM_EDGE_LEADING:
       return leading;
     case SECONDARY_MAGNETISM_EDGE_TRAILING:
       return trailing;
@@ skipping 191 matching lines @@
   }
 
  private:
   int size_;
   int min_;
   int max_;
 };
 
 WorkspaceWindowResizer::~WorkspaceWindowResizer() {
   Shell* shell = Shell::GetInstance();
-  shell->mouse_cursor_filter()->set_mouse_warp_mode(
-      MouseCursorEventFilter::WARP_ALWAYS);
-  shell->mouse_cursor_filter()->HideSharedEdgeIndicator();
   shell->cursor_manager()->UnlockCursor();
-
-  if (destroyed_)
-    *destroyed_ = true;
 }
 
 // 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 ?
@@ skipping 28 matching lines @@
   // Hide a phantom window for snapping if the cursor is in another root window.
   if (in_original_root && wm::CanResizeWindow(window())) {
     UpdateSnapPhantomWindow(location_in_parent, bounds);
   } else {
     snap_type_ = SNAP_NONE;
     snap_phantom_window_controller_.reset();
   }
 
   if (!attached_windows_.empty())
     LayoutAttachedWindows(&bounds);
-  if (bounds != window()->bounds()) {
-    bool destroyed = false;
-    destroyed_ = &destroyed;
+  if (bounds != window()->bounds())
     window()->SetBounds(bounds);
-    if (destroyed)
-      return;
-    destroyed_ = NULL;
-  }
-  // Show a phantom window for dragging in another root window.
-  if (HasSecondaryRootWindow())
-    UpdateDragWindow(bounds, in_original_root);
-  else
-    drag_window_controller_.reset();
-
 }
 
 void WorkspaceWindowResizer::CompleteDrag(int event_flags) {
   wm::SetUserHasChangedWindowPositionOrSize(details_.window, true);
-  window()->layer()->SetOpacity(details_.initial_opacity);
-  drag_window_controller_.reset();
   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 thw 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()) &&
       (snap_type_ == SNAP_LEFT_EDGE || snap_type_ == SNAP_RIGHT_EDGE)) {
     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());
     return;
   }
-  gfx::Rect bounds(GetFinalBounds(window()->bounds()));
-
-  // Check if the destination is another display.
-  gfx::Point last_mouse_location_in_screen = last_mouse_location_;
-  wm::ConvertPointToScreen(window()->parent(), &last_mouse_location_in_screen);
-  gfx::Screen* screen = Shell::GetScreen();
-  const gfx::Display dst_display =
-      screen->GetDisplayNearestPoint(last_mouse_location_in_screen);
-
-  if (dst_display.id() !=
-      screen->GetDisplayNearestWindow(window()->GetRootWindow()).id()) {
-    // Don't animate when moving to another display.
-    const gfx::Rect dst_bounds =
-        ScreenAsh::ConvertRectToScreen(window()->parent(), bounds);
-    window()->SetBoundsInScreen(dst_bounds, dst_display);
-  }
 }
 
 void WorkspaceWindowResizer::RevertDrag() {
-  window()->layer()->SetOpacity(details_.initial_opacity);
-  drag_window_controller_.reset();
   snap_phantom_window_controller_.reset();
-  Shell::GetInstance()->mouse_cursor_filter()->HideSharedEdgeIndicator();
 
   if (!did_move_or_resize_)
     return;
 
   window()->SetBounds(details_.initial_bounds_in_parent);
   if (!details_.restore_bounds.IsEmpty())
     SetRestoreBoundsInScreen(details_.window, details_.restore_bounds);
 
   if (details_.window_component == HTRIGHT) {
     int last_x = details_.initial_bounds_in_parent.right();
@@ skipping 23 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),
-      destroyed_(NULL),
       magnetism_window_(NULL) {
   DCHECK(details_.is_resizable);
 
   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,
-  // |mouse_warp_mode_| should be set to WARP_DRAG so that the user could move a
-  // window/tab to another display.
-  MouseCursorEventFilter* mouse_cursor_filter = shell->mouse_cursor_filter();
-  mouse_cursor_filter->set_mouse_warp_mode(
-      ShouldAllowMouseWarp() ?
-      MouseCursorEventFilter::WARP_DRAG : MouseCursorEventFilter::WARP_NONE);
-  if (ShouldAllowMouseWarp()) {
-    mouse_cursor_filter->ShowSharedEdgeIndicator(
-        details.window->GetRootWindow());
-  }
-
   // 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) {
@@ skipping 308 matching lines @@
     case HTRIGHT:
       return x;
     case HTBOTTOM:
       return y;
     default:
       NOTREACHED();
   }
   return 0;
 }
 
-void WorkspaceWindowResizer::UpdateDragWindow(const gfx::Rect& bounds,
-                                              bool in_original_root) {
-  if (!did_move_or_resize_ || details_.window_component != HTCAPTION ||
-      !ShouldAllowMouseWarp()) {
-    return;
-  }
-
-  // It's available. Show a phantom window on the display if needed.
-  aura::RootWindow* another_root =
-      GetAnotherRootWindow(window()->GetRootWindow());
-  const gfx::Rect root_bounds_in_screen(another_root->GetBoundsInScreen());
-  const gfx::Rect bounds_in_screen =
-      ScreenAsh::ConvertRectToScreen(window()->parent(), bounds);
-  gfx::Rect bounds_in_another_root =
-      gfx::IntersectRects(root_bounds_in_screen, bounds_in_screen);
-
-  const float fraction_in_another_window =
-      (bounds_in_another_root.width() * bounds_in_another_root.height()) /
-      static_cast<float>(bounds.width() * bounds.height());
-  const float phantom_opacity =
-      !in_original_root ? 1 : (kMaxOpacity * fraction_in_another_window);
-  const float window_opacity =
-      in_original_root ? 1 : (kMaxOpacity * (1 - fraction_in_another_window));
-
-  if (fraction_in_another_window > 0) {
-    if (!drag_window_controller_.get()) {
-      drag_window_controller_.reset(
-          new DragWindowController(window()));
-      // Always show the drag phantom on the |another_root| window.
-      drag_window_controller_->SetDestinationDisplay(
-          Shell::GetScreen()->GetDisplayMatching(
-              another_root->GetBoundsInScreen()));
-      drag_window_controller_->Show();
-    } else {
-      // No animation.
-      drag_window_controller_->SetBounds(bounds_in_screen);
-    }
-    drag_window_controller_->SetOpacity(phantom_opacity);
-    window()->layer()->SetOpacity(window_opacity);
-  } else {
-    drag_window_controller_.reset();
-    window()->layer()->SetOpacity(1.0f);
-  }
-}
-
 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;
 
   SnapType last_type = snap_type_;
   snap_type_ = GetSnapType(location);
@@ skipping 57 matching lines @@
   // TODO: this likely only wants total display area, not the area of a single
   // display.
   gfx::Rect area(ScreenAsh::GetDisplayBoundsInParent(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