exo: Rotate cursor snapshot for rotated displays

components/exo/pointer.cc

 // Copyright 2015 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 "components/exo/pointer.h"
 
 #include "ash/public/cpp/shell_window_ids.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "components/exo/pointer_delegate.h"
@@ skipping 263 matching lines @@
   // Reparent the cursor to the root window where the mouse is located.
   if (container->GetRootWindow() != cursor_->GetRootWindow()) {
     if (cursor_->parent())
       cursor_->parent()->RemoveChild(cursor_.get());
     container->AddChild(cursor_.get());
   }
 
   auto info = helper->GetDisplayInfo(display.id());
   display_scale_ = info.GetEffectiveUIScale() * info.device_scale_factor();
   device_scale_factor_ = display.device_scale_factor();
+  rotation_ = display.rotation();
 
   if (focus_ && surface_)
     CaptureCursor();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SurfaceDelegate overrides:
 
 void Pointer::OnSurfaceCommit() {
   surface_->CheckIfSurfaceHierarchyNeedsCommitToNewSurfaces();
@@ skipping 35 matching lines @@
 
 void Pointer::CaptureCursor() {
   DCHECK(surface_);
   DCHECK(focus_);
 
   float scale = cursor_scale_ * display_scale_;
   float layer_scale = scale / device_scale_factor_;
 
   gfx::Transform transform;
   transform.Scale(layer_scale, layer_scale);
+  transform.Rotate(display::Display::RotateToDegree(rotation_));
   surface_->window()->SetTransform(transform);
 
+  gfx::Point hotspot = hotspot_;
+  aura::Window::ConvertPointToTarget(surface_->window(), cursor_.get(),
+                                     &hotspot);
+
   std::unique_ptr<cc::CopyOutputRequest> request =
       cc::CopyOutputRequest::CreateBitmapRequest(
           base::Bind(&Pointer::OnCursorCaptured,
                      cursor_capture_weak_ptr_factory_.GetWeakPtr(),
-                     gfx::ScaleToFlooredPoint(hotspot_, scale)));
+                     gfx::ScaleToFlooredPoint(hotspot, scale)));
 
   request->set_source(cursor_capture_source_id_);
   cursor_->layer()->RequestCopyOfOutput(std::move(request));
 }
 
-void Pointer::OnCursorCaptured(const gfx::Point& hotspot,
+void Pointer::OnCursorCaptured(gfx::Point hotspot,
                                std::unique_ptr<cc::CopyOutputResult> result) {
   if (!focus_)
     return;
 
   gfx::NativeCursor cursor = ui::CursorType::kNull;
   if (!result->IsEmpty()) {
     DCHECK(result->HasBitmap());
     std::unique_ptr<SkBitmap> bitmap = result->TakeBitmap();
 
+    switch (rotation_) {
+      case display::Display::ROTATE_0:
+        break;
+
+      case display::Display::ROTATE_90:
+        hotspot += gfx::Vector2d(bitmap->height(), 0);
+        break;
+
+      case display::Display::ROTATE_180:
+        hotspot += gfx::Vector2d(bitmap->width(), bitmap->height());
+        break;
+
+      case display::Display::ROTATE_270:
+        hotspot += gfx::Vector2d(0, bitmap->width());
+        break;
+    }
+
     ui::PlatformCursor platform_cursor;
 #if defined(USE_OZONE)
     // TODO(reveman): Add interface for creating cursors from GpuMemoryBuffers
     // and use that here instead of the current bitmap API. crbug.com/686600
     platform_cursor = ui::CursorFactoryOzone::GetInstance()->CreateImageCursor(
         *bitmap.get(), hotspot, cursor_scale_);
 #elif defined(USE_X11)
     XcursorImage* image = ui::SkBitmapToXcursorImage(bitmap.get(), hotspot);
     platform_cursor = ui::CreateReffedCustomXCursor(image);
 #endif
@@ skipping 16 matching lines @@
   if (!root_window)
     return;
 
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(root_window);
   if (cursor_client)
     cursor_client->SetCursor(cursor);
 }
 
 }  // namespace exo