Fix initial hiding and centering cursor on Ozone

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 <algorithm>
 #include <cmath>
 #include <map>
 
@@ skipping 21 matching lines @@
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_property.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/compositor_vsync_manager.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
+#include "ui/wm/core/coordinate_conversion.h"
 #include "ui/wm/public/activation_client.h"
 
 #if defined(OS_CHROMEOS)
 #include "ash/display/display_configurator_animation.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
 #endif  // defined(OS_CHROMEOS)
 
 #if defined(USE_X11)
 #include "ui/base/x/x11_util.h"
@@ skipping 510 matching lines @@
     // Use the distance squared from the center of the dislay. This is not
     // exactly "closest" display, but good enough to pick one
     // appropriate (and there are at most two displays).
     // We don't care about actual distance, only relative to other displays, so
     // using the LengthSquared() is cheaper than Length().
 
     int64 distance_squared = (center - point_in_screen).LengthSquared();
     if (closest_distance_squared < 0 ||
         closest_distance_squared > distance_squared) {
       aura::Window* root_window = GetRootWindowForDisplayId(display.id());
-      aura::client::ScreenPositionClient* client =
-          aura::client::GetScreenPositionClient(root_window);
-      client->ConvertPointFromScreen(root_window, &center);
+      ::wm::ConvertPointFromScreen(root_window, &center);
       root_window->GetHost()->ConvertPointToNativeScreen(&center);
       dst_root_window = root_window;
       target_location_in_native = center;
       closest_distance_squared = distance_squared;
     }
   }
+
+  gfx::Point target_location_in_root = target_location_in_native;
   dst_root_window->GetHost()->ConvertPointFromNativeScreen(
-      &target_location_in_native);
-  dst_root_window->MoveCursorTo(target_location_in_native);
+      &target_location_in_root);
+
+#if defined(USE_OZONE)
+  gfx::Point target_location_in_screen = target_location_in_root;
+  ::wm::ConvertPointToScreen(dst_root_window, &target_location_in_root);

[Jun Mukai, 2015/02/18 23:14:21]

&target_location_in_screen?

[pkotwicz, 2015/02/19 01:01:17]

Thanks for noticing!

+
+  // Do not move the cursor if the cursor's location did not change. This avoids
+  // moving (and showing) the cursor on startup.
+  // |cursor_location_in_native_coords_for_restore_| may refer to a different
+  // display than when it was set. This occurs when swapping the primary
+  // display. Ozone takes care of moving the cursor in this case.
+  if (target_location_in_native !=
+          cursor_location_in_native_coords_for_restore_ ||
+      target_location_in_screen !=
+          cursor_location_in_screen_coords_for_restore_) {

[Jun Mukai, 2015/02/18 23:14:21]

EnsurePointerInDisplay ensures mouse left outside of Ash's coordinates. Wouldn't
it be good to compare display id's instead of locations?  If the dst_root_window
is corresponded with the display where the mouse cursor resides at
PreDisplayConfigurationChange(), we can say we don't have to move mouse cursor
at all.

[pkotwicz, 2015/02/19 01:01:17]

In some cases we still need to call WindowTreeHost::MoveCursorTo() even though
the cursor did not change displays and did not move
- If the display's rotation or scale factor changes, the cursor does not move
but it's screen location does. aura::Env::last_mouse_location() should be
updated
- WindowTreeHost::MoveCursorTo() has useful side effects such as updating the
cursor's rotation and scale factor. We currently rely on
DisplayController::EnsurePointerInDisplays() to do this updating.

[Jun Mukai, 2015/02/19 01:50:06]

Aah, right. thanks.

+    dst_root_window->MoveCursorTo(target_location_in_root);
+  }
+#else
+  // X11 does not move the cursor if
+  // |cursor_location_in_native_coords_for_restore_| refers to a different
+  // display than when it was set.
+  dst_root_window->MoveCursorTo(target_location_in_root);
+#endif
 }
 
 bool DisplayController::UpdateWorkAreaOfDisplayNearestWindow(
     const aura::Window* window,
     const gfx::Insets& insets) {
   const aura::Window* root_window = window->GetRootWindow();
   int64 id = GetRootWindowSettings(root_window)->display_id;
   // if id is |kInvaildDisplayID|, it's being deleted.
   DCHECK(id != gfx::Display::kInvalidDisplayID);
   return GetDisplayManager()->UpdateWorkAreaOfDisplay(id, insets);
@@ skipping 112 matching lines @@
   // to handle the cursor_window at all. See: http://crbug.com/412910
   if (!cursor_window_controller_->is_cursor_compositing_enabled())
     cursor_window_controller_->UpdateContainer();
 }
 
 void DisplayController::PreDisplayConfigurationChange(bool clear_focus) {
   FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanging());
   focus_activation_store_->Store(clear_focus);
   gfx::Screen* screen = Shell::GetScreen();
   gfx::Point point_in_screen = screen->GetCursorScreenPoint();
+  cursor_location_in_screen_coords_for_restore_ = point_in_screen;
+
+  gfx::Point point_in_native = point_in_screen;
   gfx::Display display = screen->GetDisplayNearestPoint(point_in_screen);
   aura::Window* root_window = GetRootWindowForDisplayId(display.id());
-
-  aura::client::ScreenPositionClient* client =
-      aura::client::GetScreenPositionClient(root_window);
-  client->ConvertPointFromScreen(root_window, &point_in_screen);
-  root_window->GetHost()->ConvertPointToNativeScreen(&point_in_screen);
-  cursor_location_in_native_coords_for_restore_ = point_in_screen;
+  ::wm::ConvertPointFromScreen(root_window, &point_in_native);
+  root_window->GetHost()->ConvertPointToNativeScreen(&point_in_native);
+  cursor_location_in_native_coords_for_restore_ = point_in_native;
 }
 
 void DisplayController::PostDisplayConfigurationChange() {
   if (limiter_)
     limiter_->SetThrottleTimeout(kAfterDisplayChangeThrottleTimeoutMs);
 
   focus_activation_store_->Restore();
 
   DisplayManager* display_manager = GetDisplayManager();
   DisplayLayoutStore* layout_store = display_manager->layout_store();
@@ skipping 76 matching lines @@
     std::string name =
         root_windows[i] == primary ? "aura_root_0" : "aura_root_x";
     gfx::AcceleratedWidget xwindow =
         root_windows[i]->GetHost()->GetAcceleratedWidget();
     XStoreName(gfx::GetXDisplay(), xwindow, name.c_str());
   }
 #endif
 }
 
 }  // namespace ash