Simplify DisplayController::WarpMouseCursorIfNecessary using Virtual Screen Coordinates

ash/display/display_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/display/display_controller.h"
 
 #include "ash/ash_switches.h"
 #include "ash/display/multi_display_manager.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
+#include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 
 namespace ash {
 namespace internal {
 
 DisplayController::DisplayController()
@@ skipping 88 matching lines @@
   return controllers;
 }
 
 void DisplayController::SetSecondaryDisplayLayout(
     SecondaryDisplayLayout layout) {
   secondary_display_layout_ = layout;
   UpdateDisplayBoundsForLayout();
 }
 
 bool DisplayController::WarpMouseCursorIfNecessary(
-    aura::Window* current_root,
-    const gfx::Point& location_in_root) {
+    aura::RootWindow* current_root,
+    const gfx::Point& point_in_root) {
   if (root_windows_.size() < 2)
     return false;
-  // Only 1 external display is supported in extended desktop mode.
-  DCHECK_EQ(2U, root_windows_.size());
 
-  bool in_primary = current_root == root_windows_[0];
+  gfx::Rect root_bounds = current_root->bounds();
+  int offset_x = 0;
+  int offset_y = 0;
+  if (point_in_root.x() <= root_bounds.x()) {
+    offset_x = -1;
+  } else if (point_in_root.x() >= root_bounds.right() - 1) {
+    offset_x = 1;
+  } else if (point_in_root.y() <= root_bounds.y()) {
+    offset_y = -1;
+  } else if (point_in_root.y() >= root_bounds.bottom() - 1) {
+    offset_y = 1;
+  } else {
+    return false;
+  }
 
-  std::map<int, aura::RootWindow*>::iterator iter = root_windows_.begin();
-  aura::RootWindow* alternate_root = iter->second != current_root ?
-      iter->second : (++iter)->second;
-  gfx::Rect alternate_bounds = alternate_root->bounds();
-  gfx::Point alternate_point;
+  gfx::Point point_in_screen(point_in_root);
+  aura::client::ScreenPositionClient* screen_position_client =
+      aura::client::GetScreenPositionClient(current_root);
+  screen_position_client->ConvertPointToScreen(current_root,
+                                               &point_in_screen);
+  point_in_screen.Offset(offset_x, offset_y);
+  aura::RootWindow* dst_root = Shell::GetRootWindowAt(point_in_screen);
+  gfx::Point point_in_dst_root(point_in_screen);
 
-  // TODO(oshima): This is temporary code until the virtual screen
-  // coordinate is fully implemented.
-  gfx::Rect display_area(ScreenAsh::ConvertRectFromScreen(
-      current_root,
-      gfx::Screen::GetDisplayNearestWindow(current_root).bounds()));
-
-  if (location_in_root.x() <= display_area.x()) {
-    if (location_in_root.y() < alternate_bounds.height() &&
-        ((in_primary && secondary_display_layout_ == LEFT) ||
-         (!in_primary && secondary_display_layout_ == RIGHT))) {
-      alternate_point = gfx::Point(
-          alternate_bounds.right() - (location_in_root.x() - display_area.x()),
-          location_in_root.y());
-    } else {
-      alternate_root = NULL;
-    }
-  } else if (location_in_root.x() >= display_area.right() - 1) {
-    if (location_in_root.y() < alternate_bounds.height() &&
-        ((in_primary && secondary_display_layout_ == RIGHT) ||
-         (!in_primary && secondary_display_layout_ == LEFT))) {
-      alternate_point = gfx::Point(location_in_root.x() - display_area.right(),
-                                   location_in_root.y());
-    } else {
-      alternate_root = NULL;
-    }
-  } else if (location_in_root.y() < display_area.y()) {
-    if (location_in_root.x() < alternate_bounds.width() &&
-        ((in_primary && secondary_display_layout_ == TOP) ||
-         (!in_primary && secondary_display_layout_ == BOTTOM))) {
-      alternate_point = gfx::Point(
-          location_in_root.x(),
-          alternate_bounds.bottom() -
-          (location_in_root.y() - display_area.y()));
-    } else {
-      alternate_root = NULL;
-    }
-  } else if (location_in_root.y() >= display_area.bottom() - 1) {
-    if (location_in_root.x() < alternate_bounds.width() &&
-        ((in_primary && secondary_display_layout_ == BOTTOM) ||
-         (!in_primary && secondary_display_layout_ == TOP))) {
-      alternate_point = gfx::Point(
-          location_in_root.x(), location_in_root.y() - display_area.bottom());
-    } else {
-      alternate_root = NULL;
-    }
-  } else {
-    alternate_root = NULL;
-  }
-  if (alternate_root) {
-    DCHECK_NE(alternate_root, current_root);
-    alternate_root->MoveCursorTo(alternate_point);
+  screen_position_client->ConvertPointFromScreen(dst_root,
+                                                 &point_in_dst_root);
+  if (dst_root->bounds().Contains(point_in_dst_root)) {
+    DCHECK_NE(dst_root, current_root);
+    dst_root->MoveCursorTo(point_in_dst_root);
     return true;
   }
   return false;
 }
 
 void DisplayController::OnDisplayBoundsChanged(const gfx::Display& display) {
   root_windows_[display.id()]->SetHostBounds(display.bounds_in_pixel());
   UpdateDisplayBoundsForLayout();
 }
 
@@ skipping 82 matching lines @@
       break;
   }
   gfx::Insets insets = secondary_display->GetWorkAreaInsets();
   secondary_display->set_bounds(
       gfx::Rect(new_secondary_origin, secondary_bounds.size()));
   secondary_display->UpdateWorkAreaFromInsets(insets);
 }
 
 }  // namespace internal
 }  // namespace ash