Add more tests for mouse rotation,scale&position after display change

ash/display/cursor_window_controller.cc

 // Copyright 2014 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/cursor_window_controller.h"
 
 #include "ash/display/display_controller.h"
 #include "ash/display/mirror_window_controller.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
@@ skipping 76 matching lines @@
   gfx::Size size_;
 
   DISALLOW_COPY_AND_ASSIGN(CursorWindowDelegate);
 };
 
 CursorWindowController::CursorWindowController()
     : is_cursor_compositing_enabled_(false),
       container_(NULL),
       cursor_type_(ui::kCursorNone),
       cursor_set_(ui::CURSOR_SET_NORMAL),
-      cursor_rotation_(gfx::Display::ROTATE_0),
       delegate_(new CursorWindowDelegate()) {
 }
 
 CursorWindowController::~CursorWindowController() {
   SetContainer(NULL);
 }
 
 void CursorWindowController::SetCursorCompositingEnabled(bool enabled) {
   if (is_cursor_compositing_enabled_ != enabled) {
     is_cursor_compositing_enabled_ = enabled;
@@ skipping 13 matching lines @@
       SetDisplay(display);
   } else {
     aura::Window* mirror_window = Shell::GetInstance()->
         display_controller()->
         mirror_window_controller()->
         GetWindow();
     if (mirror_window)
       display_ = Shell::GetScreen()->GetPrimaryDisplay();
     SetContainer(mirror_window);
   }
-  // Updates the hot point based on the current display/container.
+  // Updates the hot point based on the current display.
   UpdateCursorImage();
 }
 
 void CursorWindowController::SetDisplay(const gfx::Display& display) {
   if (!is_cursor_compositing_enabled_)
     return;
 
   display_ = display;
   aura::Window* root_window = Shell::GetInstance()->display_controller()->
       GetRootWindowForDisplayId(display.id());
   if (!root_window)
     return;
 
   SetContainer(GetRootWindowController(root_window)->GetContainer(
       kShellWindowId_MouseCursorContainer));
   SetBoundsInScreen(display.bounds());
+  // Updates the hot point based on the current display.
+  UpdateCursorImage();

[oshima, 2015/03/09 23:08:20]

can you move the method to private, then you don't need this.

[pkotwicz, 2015/03/10 03:13:05]

I don't think I understand your comment.

CursorWindowController::SetDisplay() cannot be private because it is used by
AshNativeCursorManager::SetDisplay().

 }
 
 void CursorWindowController::UpdateLocation() {
   if (!cursor_window_)
     return;
   gfx::Point point = aura::Env::GetInstance()->last_mouse_location();
   if (!is_cursor_compositing_enabled_) {
     Shell::GetPrimaryRootWindow()->GetHost()->ConvertPointToHost(&point);
   } else {
     point.Offset(-bounds_in_screen_.x(), -bounds_in_screen_.y());
   }
   point.Offset(-hot_point_.x(), -hot_point_.y());
   gfx::Rect bounds = cursor_window_->bounds();
   bounds.set_origin(point);
   cursor_window_->SetBounds(bounds);
 }
 
 void CursorWindowController::SetCursor(gfx::NativeCursor cursor) {
-  if (cursor_type_ == cursor.native_type() &&
-      cursor_rotation_ == display_.rotation())
+  if (cursor_type_ == cursor.native_type())
     return;
   cursor_type_ = cursor.native_type();
-  cursor_rotation_ = display_.rotation();
   UpdateCursorImage();
 }
 
 void CursorWindowController::SetCursorSet(ui::CursorSetType cursor_set) {
   cursor_set_ = cursor_set;
   UpdateCursorImage();
 }
 
 void CursorWindowController::SetVisibility(bool visible) {
   if (!cursor_window_)
@@ skipping 13 matching lines @@
     return;
   }
 
   // Reusing the window does not work when the display is disconnected.
   // Just creates a new one instead. crbug.com/384218.
   cursor_window_.reset(new aura::Window(delegate_.get()));
   cursor_window_->SetTransparent(true);
   cursor_window_->Init(aura::WINDOW_LAYER_TEXTURED);
   cursor_window_->set_ignore_events(true);
   cursor_window_->set_owned_by_parent(false);
+  // Call UpdateCursorImage() to figure out |cursor_window_|'s desired size.
   UpdateCursorImage();
 
   container->AddChild(cursor_window_.get());
   cursor_window_->Show();
   SetBoundsInScreen(container->bounds());
 }
 
 void CursorWindowController::SetBoundsInScreen(const gfx::Rect& bounds) {
   bounds_in_screen_ = bounds;
   UpdateLocation();
 }
 
 void CursorWindowController::UpdateCursorImage() {
   int resource_id;
   // TODO(hshi): support custom cursor set.
   if (!ui::GetCursorDataFor(cursor_set_,
                             cursor_type_,
                             display_.device_scale_factor(),
                             &resource_id,
                             &hot_point_)) {
     return;
   }
   const gfx::ImageSkia* image =
       ResourceBundle::GetSharedInstance().GetImageSkiaNamed(resource_id);
   gfx::ImageSkia rotated = *image;
   if (!is_cursor_compositing_enabled_) {
-    switch (cursor_rotation_) {
+    switch (display_.rotation()) {
       case gfx::Display::ROTATE_0:
         break;
       case gfx::Display::ROTATE_90:
         rotated = gfx::ImageSkiaOperations::CreateRotatedImage(
             *image, SkBitmapOperations::ROTATION_90_CW);
         hot_point_.SetPoint(
             rotated.width() - hot_point_.y(),
             hot_point_.x());
         break;
       case gfx::Display::ROTATE_180:
@@ skipping 18 matching lines @@
   delegate_->SetCursorImage(rotated, display_);
   if (cursor_window_) {
     cursor_window_->SetBounds(gfx::Rect(delegate_->size()));
     cursor_window_->SchedulePaintInRect(
         gfx::Rect(cursor_window_->bounds().size()));
     UpdateLocation();
   }
 }
 
 }  // namespace ash