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 12 matching lines @@
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "base/command_line.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/screen_position_client.h"
+#include "ui/aura/env.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/public/activation_client.h"
@@ skipping 487 matching lines @@
   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() {
+  if (!aura::Env::GetInstance()->mouse_moved() &&

[pkotwicz, 2015/02/06 16:12:44]

I am unsure whether checking whether the mouse was moved is the best thing.

I considered checking whether the cursor has ever been visible (e.g.
aura::client::WasCursorVisible() I couldn't think of a way of correctly
initializing the cursor visibility in CursorManager though. There are issues
with passing the initial visibility to the CursorManager constructor)

+      Shell::initially_hide_cursor()) {
+    // Do not move the cursor if the cursor has not yet been moved and the
+    // cursor is initially hidden. Moving the cursor generates a mouse event
+    // which shows the cursor.
+    return;
+  }
+
   // 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 23 matching lines @@
           aura::client::GetScreenPositionClient(root_window);
       client->ConvertPointFromScreen(root_window, &center);
       root_window->GetHost()->ConvertPointToNativeScreen(&center);
       dst_root_window = root_window;
       target_location_in_native = center;
       closest_distance_squared = distance_squared;
     }
   }
   dst_root_window->GetHost()->ConvertPointFromNativeScreen(
       &target_location_in_native);
   dst_root_window->MoveCursorTo(target_location_in_native);

[oshima, 2015/02/10 22:01:57]

This was added to make sure that X cursor stays inside RootWindow that
ash manages, so this is probably not necessary on ozone.

Maybe you can initialize the mouse location during init process to the center of
display, and then skip MoveCursorTo if the native location didn't change?

[pkotwicz, 2015/02/12 01:52:55]

This bug occurs on both X and Ozone so we need to find a solution which works on
both

When DriCursor moves the cursor (e.g. DriCursor::OnWindowAdded()) a
ui::MouseEvent is not generated. Hence:
- aura::Env::last_mouse_location() is not updated
- if a user has "Large Cursors" turned on, the cursor position is not updated

More specifically, if we skipped MoveCursorTo() if the native location didn't
change, and the user had large cursors turned on, when the user swaps primary
displays:
- The large cursor will appear to jump when the user moves the mouse immediately
after having swapped the primary display 

We could make DriCursor generate mouse events when it moves the cursor, however
when DriCursor::OnWindowAdded() initially moves the cursor to the center of the
screen this would generate a ui::MouseEvent which in turn will cause the cursor
to get shown

Do you have suggestions as to where we can initialize the mouse location during
the init process? I am not sure if we want to do this. However, if we did I am
not sure where we would do it.

[oshima, 2015/02/12 02:08:57]

My point is that this method was added because cursor may leak (that is move
outside of display) on X impl. I believe it won't happen on ozone?

[pkotwicz, 2015/02/12 02:37:41]

How do you suggest fixing this bug on CrOS X11 (or should we ignore CrOS X11)

Yes, I believe that DriCursor is supposed to keep the cursor within the display
bounds
Are you suggesting:
- Making DriCursor generate mouse events when it moves the mouse so that it
stays on the display (e.g. DriCursor::OnWindowRemoved() )
- We add special logic in DriCursor so that it does not generate a mouse event
when it moves the mouse cursor to its initial location

 }
 
 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 216 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