Move a window if the sceren bounds being set is in other display.

ash/wm/stacking_controller.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/stacking_controller.h"
 
 #include "ash/display/display_controller.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/always_on_top_controller.h"
@@ skipping 13 matching lines @@
 // return the active root window.
 aura::RootWindow* FindContainerRoot(const gfx::Rect& bounds) {
   if (!DisplayController::IsVirtualScreenCoordinatesEnabled() ||
       (bounds.origin().x() == 0 && bounds.origin().y() == 0
        && bounds.IsEmpty())) {
     return Shell::GetActiveRootWindow();
   }
   return Shell::GetRootWindowMatching(bounds);
 }
 
-aura::Window* GetContainerById(const gfx::Rect& bounds, int id) {
-  return Shell::GetContainer(FindContainerRoot(bounds), id);
+aura::Window* GetContainerById(aura::RootWindow* root, int id) {
+  return Shell::GetContainer(root, id);
 }
 
 aura::Window* GetContainerForWindow(aura::Window* window) {
   aura::Window* container = window->parent();
   while (container && container->type() != aura::client::WINDOW_TYPE_UNKNOWN)
     container = container->parent();
   return container;
 }
 
 bool IsSystemModal(aura::Window* window) {
@@ skipping 15 matching lines @@
 }
 
 StackingController::~StackingController() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // StackingController, aura::StackingClient implementation:
 
 aura::Window* StackingController::GetDefaultParent(aura::Window* window,
                                                    const gfx::Rect& bounds) {
+  aura::RootWindow* target_root = NULL;
+  if (window->transient_parent()) {
+    // Transient window should use the same root as its transient parent.
+    target_root = window->transient_parent()->GetRootWindow();
+  } else {
+    target_root = FindContainerRoot(bounds);
+  }
+
   switch (window->type()) {
     case aura::client::WINDOW_TYPE_NORMAL:
     case aura::client::WINDOW_TYPE_POPUP:
       if (IsSystemModal(window))
-        return GetSystemModalContainer(window, bounds);
+        return GetSystemModalContainer(target_root, window);
       else if (IsWindowModal(window))
         return GetContainerForWindow(window->transient_parent());
-      return GetAlwaysOnTopController(bounds)->GetContainer(window);
+      return GetAlwaysOnTopController(target_root)->GetContainer(window);
     case aura::client::WINDOW_TYPE_PANEL:
-      return GetContainerById(bounds, internal::kShellWindowId_PanelContainer);
+      return GetContainerById(target_root,
+                              internal::kShellWindowId_PanelContainer);
     case aura::client::WINDOW_TYPE_MENU:
-      return GetContainerById(bounds, internal::kShellWindowId_MenuContainer);
+      return GetContainerById(
+          target_root, internal::kShellWindowId_MenuContainer);
     case aura::client::WINDOW_TYPE_TOOLTIP:
       return GetContainerById(
-          bounds, internal::kShellWindowId_DragImageAndTooltipContainer);
+          target_root, internal::kShellWindowId_DragImageAndTooltipContainer);
     case aura::client::WINDOW_TYPE_CONTROL:
       return GetContainerById(
-          bounds, internal::kShellWindowId_UnparentedControlContainer);
+          target_root, internal::kShellWindowId_UnparentedControlContainer);
     default:
       NOTREACHED() << "Window " << window->id()
                    << " has unhandled type " << window->type();
       break;
   }
   return NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // StackingController, private:
 
 aura::Window* StackingController::GetSystemModalContainer(
-    aura::Window* window,
-    const gfx::Rect& bounds) const {
+    aura::RootWindow* root,
+    aura::Window* window) const {
   DCHECK(IsSystemModal(window));
 
   // If screen lock is not active, all modal windows are placed into the
   // normal modal container.
-  // TODO(oshima): support multiple root windows.
   aura::Window* lock_container =
-      GetContainerById(bounds, internal::kShellWindowId_LockScreenContainer);
+      GetContainerById(root, internal::kShellWindowId_LockScreenContainer);
   if (!lock_container->children().size()) {
-    return GetContainerById(bounds,
+    return GetContainerById(root,
                             internal::kShellWindowId_SystemModalContainer);
   }
 
   // Otherwise those that originate from LockScreen container and above are
   // placed in the screen lock modal container.
   int lock_container_id = lock_container->id();
   int window_container_id = window->transient_parent()->parent()->id();
 
   aura::Window* container = NULL;
   if (window_container_id < lock_container_id) {
     container = GetContainerById(
-        bounds, internal::kShellWindowId_SystemModalContainer);
+        root, internal::kShellWindowId_SystemModalContainer);
   } else {
     container = GetContainerById(
-        bounds, internal::kShellWindowId_LockSystemModalContainer);
+        root, internal::kShellWindowId_LockSystemModalContainer);
   }
 
   return container;
 }
 
+// TODO(oshima): Remove this once extended desktop is on by default.
 internal::AlwaysOnTopController*
-StackingController::GetAlwaysOnTopController(const gfx::Rect& bounds) {
-  aura::RootWindow* root_window = FindContainerRoot(bounds);
+StackingController::GetAlwaysOnTopController(
+    aura::RootWindow* root_window) {
   internal::AlwaysOnTopController* controller =
       root_window->GetProperty(internal::kAlwaysOnTopControllerKey);
   if (!controller) {
     controller = new internal::AlwaysOnTopController;
     controller->SetContainers(
         root_window->GetChildById(internal::kShellWindowId_DefaultContainer),
         root_window->GetChildById(
             internal::kShellWindowId_AlwaysOnTopContainer));
     // RootWindow owns the AlwaysOnTopController object.
     root_window->SetProperty(kAlwaysOnTopControllerKey, controller);
   }
   return controller;
 }
 
 }  // namespace internal
 }  // namespace ash