Extract the code of showing a dragging window on another display from PhantomWindowController.

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/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"
-#include "ui/views/corewm/window_util.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>();
@@ skipping 262 matching lines @@
   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();
 
-  // Delete phantom controllers first so that they will never see the deleted
-  // |layer_|.
-  snap_phantom_window_controller_.reset();
-  drag_phantom_window_controller_.reset();
-
-  if (layer_)
-    views::corewm::DeepDeleteLayers(layer_);
-
   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) {
@@ skipping 40 matching lines @@
   if (bounds != window()->bounds()) {
     bool destroyed = false;
     destroyed_ = &destroyed;
     window()->SetBounds(bounds);
     if (destroyed)
       return;
     destroyed_ = NULL;
   }
   // Show a phantom window for dragging in another root window.
   if (HasSecondaryRootWindow())
-    UpdateDragPhantomWindow(bounds, in_original_root);
+    UpdateDragWindow(bounds, in_original_root);
   else
-    drag_phantom_window_controller_.reset();
+    drag_window_controller_.reset();
 
 }
 
 void WorkspaceWindowResizer::CompleteDrag(int event_flags) {
   wm::SetUserHasChangedWindowPositionOrSize(details_.window, true);
   window()->layer()->SetOpacity(details_.initial_opacity);
-  drag_phantom_window_controller_.reset();
+  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()) &&
@@ skipping 21 matching lines @@
       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_phantom_window_controller_.reset();
+  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);
 
@@ skipping 25 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),
-      layer_(NULL),
       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,
@@ skipping 329 matching lines @@
     case HTRIGHT:
       return x;
     case HTBOTTOM:
       return y;
     default:
       NOTREACHED();
   }
   return 0;
 }
 
-void WorkspaceWindowResizer::UpdateDragPhantomWindow(const gfx::Rect& bounds,
-                                                     bool in_original_root) {
+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_phantom_window_controller_.get()) {
-      drag_phantom_window_controller_.reset(
-          new PhantomWindowController(window()));
-      drag_phantom_window_controller_->set_style(
-          PhantomWindowController::STYLE_DRAGGING);
+    if (!drag_window_controller_.get()) {
+      drag_window_controller_.reset(
+          new DragWindowController(window()));
       // Always show the drag phantom on the |another_root| window.
-      drag_phantom_window_controller_->SetDestinationDisplay(
+      drag_window_controller_->SetDestinationDisplay(
           Shell::GetScreen()->GetDisplayMatching(
               another_root->GetBoundsInScreen()));
-      if (!layer_)
-        RecreateWindowLayers();
-      drag_phantom_window_controller_->Show(bounds_in_screen, layer_);
+      drag_window_controller_->Show();
     } else {
       // No animation.
-      drag_phantom_window_controller_->SetBounds(bounds_in_screen);
+      drag_window_controller_->SetBounds(bounds_in_screen);
     }
-    drag_phantom_window_controller_->SetOpacity(phantom_opacity);
+    drag_window_controller_->SetOpacity(phantom_opacity);
     window()->layer()->SetOpacity(window_opacity);
   } else {
-    drag_phantom_window_controller_.reset();
+    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()))
@@ skipping 15 matching lines @@
                                     edge,
                                     internal::SnapSizer::OTHER_INPUT));
   } else {
     snap_sizer_->Update(location);
   }
   if (!snap_phantom_window_controller_.get()) {
     snap_phantom_window_controller_.reset(
         new PhantomWindowController(window()));
   }
   snap_phantom_window_controller_->Show(ScreenAsh::ConvertRectToScreen(
-      window()->parent(), snap_sizer_->target_bounds()), NULL);
+      window()->parent(), snap_sizer_->target_bounds()));
 }
 
 void WorkspaceWindowResizer::RestackWindows() {
   if (attached_windows_.empty())
     return;
   // Build a map from index in children to window, returning if there is a
   // window with a different parent.
   typedef std::map<size_t, aura::Window*> IndexToWindowMap;
   IndexToWindowMap map;
   aura::Window* parent = window()->parent();
@@ skipping 31 matching lines @@
     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);
 }
 
-void WorkspaceWindowResizer::RecreateWindowLayers() {
-  DCHECK(!layer_);
-  layer_ = views::corewm::RecreateWindowLayers(window(), true);
-  layer_->set_delegate(window()->layer()->delegate());
-  // Place the layer at (0, 0) of the PhantomWindowController's window.
-  gfx::Rect layer_bounds = layer_->bounds();
-  layer_bounds.set_origin(gfx::Point(0, 0));
-  layer_->SetBounds(layer_bounds);
-  layer_->SetVisible(false);
-  // Detach it from the current container.
-  layer_->parent()->Remove(layer_);
-}
-
 }  // namespace internal
 }  // namespace ash