exo: Fix multi-display hardware cursor

components/exo/pointer.h

 // 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.
 
 #ifndef COMPONENTS_EXO_POINTER_H_
 #define COMPONENTS_EXO_POINTER_H_
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/unguessable_token.h"
 #include "components/exo/surface_delegate.h"
 #include "components/exo/surface_observer.h"
 #include "components/exo/wm_helper.h"
 #include "ui/base/cursor/cursor.h"
+#include "ui/display/display.h"
 #include "ui/events/event_handler.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/native_widget_types.h"
 
 namespace cc {
 class CopyOutputResult;
 }
 
 namespace ui {
@@ skipping 24 matching lines @@
 
   // Returns the current cursor for the pointer.
   gfx::NativeCursor GetCursor();
 
   // Overridden from ui::EventHandler:
   void OnMouseEvent(ui::MouseEvent* event) override;
   void OnScrollEvent(ui::ScrollEvent* event) override;
 
   // Overridden from WMHelper::CursorObserver:
   void OnCursorSetChanged(ui::CursorSetType cursor_set) override;
+  void OnCursorDisplayChanging(const display::Display& display) override;
 
   // Overridden from SurfaceDelegate:
   void OnSurfaceCommit() override;
   bool IsSurfaceSynchronized() const override;
 
   // Overridden from SurfaceObserver:
   void OnSurfaceDestroying(Surface* surface) override;
 
  private:
   // Returns the effective target for |event|.
   Surface* GetEffectiveTargetForEvent(ui::Event* event) const;
 
-  // Recompute cursor scale and update cursor if scale changed.
-  void UpdateCursorScale();
-
   // Asynchronously update the cursor by capturing a snapshot of |surface_|.
-  void CaptureCursor();
+  void CaptureCursor(bool force);

[reveman, 2017/03/30 07:47:53]

why do we need |force|? can the behavior with force=true be used all the time?

[Dominik Laskowski, 2017/04/05 17:59:25]

No, it should only be used to bypass cursor locking. See pointer.cc for details.

 
   // Called when cursor snapshot has been captured.
-  void OnCursorCaptured(const gfx::Point& hotspot,

[reveman, 2017/03/30 07:47:53]

why not const?

[Dominik Laskowski, 2017/04/05 17:59:25]

Belongs to the dependent CL. Moved.

+  void OnCursorCaptured(gfx::Point hotspot,
+                        bool force,
                         std::unique_ptr<cc::CopyOutputResult> result);
 
-  // Update cursor to reflect the current value of |cursor_|.
-  void UpdateCursor();
+  // If |force| is true, the cursor is updated even if locked.
+  void UpdateCursor(gfx::NativeCursor cursor, bool force);
 
   // The delegate instance that all events are dispatched to.
   PointerDelegate* const delegate_;
 
   // The current pointer surface.
   Surface* surface_ = nullptr;
 
   // The current focus surface for the pointer.
   Surface* focus_ = nullptr;
 
   // The location of the pointer in the current focus surface.
   gfx::PointF location_;
 
-  // The scale applied to the cursor to compensate for the UI scale.
+  // The display-dependent scale applied to the cursor.
+  float display_scale_ = 1.0f;
+
+  // The display-independent scale applied to the cursor.
   float cursor_scale_ = 1.0f;
 
+  float device_scale_factor_ = 1.0f;

[reveman, 2017/03/30 07:47:53]

Please add a comment here for consistency.

[Dominik Laskowski, 2017/04/05 17:59:25]

Done.

+
   // The position of the pointer surface relative to the pointer location.
   gfx::Point hotspot_;
 
-  // The current cursor.
-  ui::Cursor cursor_;
+  const std::unique_ptr<aura::Window> cursor_;

[reveman, 2017/03/30 07:47:53]

why do we have to change this? We should avoid using aura::Windows except for
top level shell surfaces so I'm worried about any changes that introduce more
use of them.

[Dominik Laskowski, 2017/04/05 17:59:25]

The snapshot is requested on this layer, because the rotation transform in the
dependent CL is applied to the surface layer, relative to this layer. Also, it
simplifies the code, i.e. the surface window can be unconditionally parented to
this window, because this window is reparented between root windows whenever the
mouse crosses displays.

 
   // Source used for cursor capture copy output requests.
-  const base::UnguessableToken cursor_capture_source_id_;
+  base::UnguessableToken cursor_capture_source_id_;
 
   // Weak pointer factory used for cursor capture callbacks.
   base::WeakPtrFactory<Pointer> cursor_capture_weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Pointer);
 };
 
 }  // namespace exo
 
 #endif  // COMPONENTS_EXO_POINTER_H_