Don't move cursor location when rotation /ui scaling has changed

ash/display/display_manager.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_manager.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 340 matching lines @@
             new_display_info_list.end(),
             DisplayInfoSortFunctor());
   DisplayList removed_displays;
   std::vector<size_t> changed_display_indices;
   std::vector<size_t> added_display_indices;
 
   DisplayList::iterator curr_iter = displays_.begin();
   DisplayInfoList::const_iterator new_info_iter = new_display_info_list.begin();
 
   DisplayList new_displays;
+  bool update_mouse_location = false;
+
   while (curr_iter != displays_.end() ||
          new_info_iter != new_display_info_list.end()) {
     if (curr_iter == displays_.end()) {
       // more displays in new list.
       added_display_indices.push_back(new_displays.size());
       InsertAndUpdateDisplayInfo(*new_info_iter);
       new_displays.push_back(
           CreateDisplayFromDisplayInfoById(new_info_iter->id()));
       ++new_info_iter;
     } else if (new_info_iter == new_display_info_list.end()) {
       // more displays in current list.
       removed_displays.push_back(*curr_iter);
       ++curr_iter;
+      update_mouse_location = true;
     } else if (curr_iter->id() == new_info_iter->id()) {
       const gfx::Display& current_display = *curr_iter;
       // Copy the info because |CreateDisplayFromInfo| updates the instance.
       const DisplayInfo current_display_info =
           GetDisplayInfo(current_display.id());
       InsertAndUpdateDisplayInfo(*new_info_iter);
       gfx::Display new_display =
           CreateDisplayFromDisplayInfoById(new_info_iter->id());
       const DisplayInfo& new_display_info = GetDisplayInfo(new_display.id());
+
+      bool host_window_bounds_changed =
+          current_display_info.bounds_in_pixel() !=
+          new_display_info.bounds_in_pixel();
+
       // TODO(oshima): Rotating square dislay doesn't work as the size
       // won't change. This doesn't cause a problem now as there is no
       // such display. This will be fixed by comparing the rotation as
       // well when the rotation variable is added to gfx::Display.
       if (force_bounds_changed_ ||
-          (current_display_info.bounds_in_pixel() !=
-           new_display_info.bounds_in_pixel()) ||
+          host_window_bounds_changed ||
           (current_display.device_scale_factor() !=
            new_display.device_scale_factor()) ||
           (current_display_info.size_in_pixel() !=
            new_display.GetSizeInPixel())) {
+
+        // Don't update mouse location if the display size has
+        // changed due to rotation or zooming.
+        if (host_window_bounds_changed)
+          update_mouse_location = true;
+
         changed_display_indices.push_back(new_displays.size());
       }
 
       new_display.UpdateWorkAreaFromInsets(current_display.GetWorkAreaInsets());
       new_displays.push_back(new_display);
       ++curr_iter;
       ++new_info_iter;
     } else if (curr_iter->id() < new_info_iter->id()) {
       // more displays in current list between ids, which means it is deleted.
       removed_displays.push_back(*curr_iter);
       ++curr_iter;
+      update_mouse_location = true;
     } else {
       // more displays in new list between ids, which means it is added.
       added_display_indices.push_back(new_displays.size());
       InsertAndUpdateDisplayInfo(*new_info_iter);
       new_displays.push_back(
           CreateDisplayFromDisplayInfoById(new_info_iter->id()));
       ++new_info_iter;
     }
   }
 
   // Do not update |displays_| if there's nothing to be updated. Without this,
   // it will not update the display layout, which causes the bug
   // http://crbug.com/155948.
   if (changed_display_indices.empty() && added_display_indices.empty() &&
       removed_displays.empty()) {
     return;
   }
 
+  DisplayController* display_controller =
+      Shell::GetInstance()->display_controller();
+  gfx::Point native_mouse_location;

[Jun Mukai, 2013/04/06 03:13:39]

mouse_location_in_native would be more consistent?

[oshima, 2013/04/08 18:00:40]

Done.

+  // |display_controller| is NULL during the bootstrap.
+  if (display_controller) {
+    display_controller->NotifyDisplayConfigurationChanging();
+    native_mouse_location = display_controller->GetNativeMouseCursorLocation();
+  }
+
   displays_ = new_displays;
 
   base::AutoReset<bool> resetter(&change_display_upon_host_resize_, false);
 
   // Temporarily add displays to be removed because display object
   // being removed are accessed during shutting down the root.
   displays_.insert(displays_.end(), removed_displays.begin(),
                    removed_displays.end());
-  DisplayController* display_controller =
-      Shell::GetInstance()->display_controller();
-  // |display_controller| is NULL during the bootstrap.
-  if (display_controller)
-    display_controller->NotifyDisplayConfigurationChanging();
 
   for (DisplayList::const_reverse_iterator iter = removed_displays.rbegin();
        iter != removed_displays.rend(); ++iter) {
     Shell::GetInstance()->screen()->NotifyDisplayRemoved(displays_.back());
     displays_.pop_back();
   }
   for (std::vector<size_t>::iterator iter = added_display_indices.begin();
        iter != added_display_indices.end(); ++iter) {
     Shell::GetInstance()->screen()->NotifyDisplayAdded(displays_[*iter]);
   }
   for (std::vector<size_t>::iterator iter = changed_display_indices.begin();
        iter != changed_display_indices.end(); ++iter) {
     Shell::GetInstance()->screen()->NotifyBoundsChanged(displays_[*iter]);
   }
-  if (display_controller)
+  if (display_controller) {
     display_controller->NotifyDisplayConfigurationChanged();
-
-  EnsurePointerInDisplays();
+    if (update_mouse_location)
+      display_controller->EnsurePointerInDisplays();
+    else
+      display_controller->UpdateMouseCursor(native_mouse_location);

[Jun Mukai, 2013/04/06 03:13:39]

Why this needs to be called?

[oshima, 2013/04/08 18:00:40]

Yes, we need to update the cursor when rotated.

+  }
 #if defined(USE_X11) && defined(OS_CHROMEOS)
   if (!changed_display_indices.empty() && base::chromeos::IsRunningOnChromeOS())
     ui::ClearX11DefaultRootWindow();
 #endif
 }
 
 gfx::Display* DisplayManager::GetDisplayAt(size_t index) {
   return index < displays_.size() ? &displays_[index] : NULL;
 }
 
@@ skipping 184 matching lines @@
   return GetInvalidDisplay();
 }
 
 void DisplayManager::AddDisplayFromSpec(const std::string& spec) {
   DisplayInfo display_info = DisplayInfo::CreateFromSpec(spec);
   InsertAndUpdateDisplayInfo(display_info);
   gfx::Display display = CreateDisplayFromDisplayInfoById(display_info.id());
   displays_.push_back(display);
 }
 
-void DisplayManager::EnsurePointerInDisplays() {
-  // Don't try to move the pointer during the boot/startup.
-  if (!DisplayController::HasPrimaryDisplay())
-    return;
-  gfx::Point location_in_screen = Shell::GetScreen()->GetCursorScreenPoint();
-  gfx::Point target_location;
-  int64 closest_distance_squared = -1;
-
-  for (DisplayList::const_iterator iter = displays_.begin();
-       iter != displays_.end(); ++iter) {
-    const gfx::Rect& display_bounds = iter->bounds();
-
-    if (display_bounds.Contains(location_in_screen)) {
-      target_location = location_in_screen;
-      break;
-    }
-    gfx::Point center = display_bounds.CenterPoint();
-    // 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 - location_in_screen).LengthSquared();
-    if (closest_distance_squared < 0 ||
-        closest_distance_squared > distance_squared) {
-      target_location = center;
-      closest_distance_squared = distance_squared;
-    }
-  }
-
-  aura::RootWindow* root_window = Shell::GetPrimaryRootWindow();
-  aura::client::ScreenPositionClient* client =
-      aura::client::GetScreenPositionClient(root_window);
-  client->ConvertPointFromScreen(root_window, &target_location);
-
-  root_window->MoveCursorTo(target_location);
-}
-
 void DisplayManager::InsertAndUpdateDisplayInfo(const DisplayInfo& new_info) {
   std::map<int64, DisplayInfo>::iterator info =
       display_info_.find(new_info.id());
   if (info != display_info_.end())
     info->second.Copy(new_info);
   else {
     display_info_[new_info.id()] = new_info;
     display_info_[new_info.id()].set_native(false);
   }
   bool on_chromeos = false;
@@ skipping 25 matching lines @@
   // always (0,0) and the secondary display's bounds will be updated
   // by |DisplayController::UpdateDisplayBoundsForLayout|.
   new_display.SetScaleAndBounds(
       display_info.device_scale_factor(), gfx::Rect(bounds_in_pixel.size()));
   new_display.set_rotation(display_info.rotation());
   return new_display;
 }
 
 }  // namespace internal
 }  // namespace ash