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 477 matching lines @@
   std::vector<DisplayInfo> display_info_list;
   display_info_list.push_back(display_manager->GetDisplayInfo(
       primary_display_id));
   display_info_list.push_back(display_manager->GetDisplayInfo(
       ScreenUtil::GetSecondaryDisplay().id()));
   GetDisplayManager()->set_force_bounds_changed(true);
   GetDisplayManager()->UpdateDisplays(display_info_list);
   GetDisplayManager()->set_force_bounds_changed(false);
 }
 
 void DisplayController::EnsurePointerInDisplays() {

[Jun Mukai, 2015/02/19 18:07:55]

This does not "ensure" pointers in displays anymore (actually it's not been a
while). As we discussed, it needs to be called for screen rotations and
primary-display-swap for X11.

Could you rename this like UpdateMouseLocationAfterDisplayChange (seen in
oshima's comment) or SyncMouseLocationAfter... or something.

   // If the mouse is currently on a display in native location,
   // use the same native location. Otherwise find the display closest
   // to the current cursor location in screen coordinates.
 
   gfx::Point point_in_screen = Shell::GetScreen()->GetCursorScreenPoint();
   gfx::Point target_location_in_native;
   int64 closest_distance_squared = -1;
   DisplayManager* display_manager = GetDisplayManager();
 
   aura::Window* dst_root_window = NULL;
@@ skipping 12 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)

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

This check itself doesn't look ozone specific -- although it can happen only on
ozone, it's safe to check on X11 too, right?

[pkotwicz, 2015/02/19 02:43:43]

Ozone moves the mouse for us if the mouse's native position did not change but
the mouse is now on another display. X11 does not. When swapping the primary
display, the mouse moves to a different display even though it's native and
screen coordinates stay the same.

I think that Oshima mentioned that we move the cursor to prevent some X11
badness. I am unsure when this badness occurrs. Maybe it makes sense to wait for
him to come back

Notwithstanding X11 badness if we checked whether the display that the cursor is
on changed in addition to the other two checks, then we would be able to use the
same logic on X11 and Ozone 

[Jun Mukai, 2015/02/19 02:57:24]

Hm, okay. For display swapping, I guess the X11 badness means that the mouse
cursor location (from X11 point of view) gets inconsistent with the location
maintained by aura::Env or Ash.

Let me make sure what will happen for the display swapping in ozone with this
CL:
- EnsurePointerInDisplays() does not move the cursor position, stays on the same
location
- This however means the mouse cursor stays in the same root window, i.e. cursor
looks like jumping to the swapped display

correct?

+  gfx::Point target_location_in_screen = target_location_in_root;
+  ::wm::ConvertPointToScreen(dst_root_window, &target_location_in_screen);
+
+  // 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_) {
+    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.

[Jun Mukai, 2015/02/19 18:07:55]

Could you add a comment why we should move the cursor even if the cursor
location did not change at all?

+  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