Use mojo for cursor control in ozone drm

ui/ozone/platform/drm/gpu/drm_thread.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 UI_OZONE_PLATFORM_DRM_GPU_DRM_THREAD_H_
 #define UI_OZONE_PLATFORM_DRM_GPU_DRM_THREAD_H_
 
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/files/scoped_file.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread.h"
+#include "mojo/public/cpp/bindings/binding_set.h"
+#include "services/shell/public/cpp/connection.h"
 #include "ui/gfx/native_pixmap_handle_ozone.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/vsync_provider.h"
 #include "ui/ozone/common/gpu/ozone_gpu_message_params.h"
+#include "ui/ozone/public/interfaces/device_cursor.mojom.h"
 #include "ui/ozone/public/surface_ozone_egl.h"
 
 namespace base {
 struct FileDescriptor;
 }
 
 namespace gfx {
 class Point;
 class Rect;
 }
 
+namespace shell {
+class Connection;
+}
+
 namespace ui {
 
 class DrmDeviceManager;
 class DrmGpuDisplayManager;
 class DrmWindow;
 class DrmWindowProxy;
 class GbmBuffer;
 class ScanoutBufferGenerator;
 class ScreenManager;
 
 struct GammaRampRGBEntry;
 struct OverlayPlane;
 
 // Holds all the DRM related state and performs all DRM related operations.
 //
 // The DRM thread is used to insulate DRM operations from potential blocking
 // behaviour on the GPU main thread in order to reduce the potential for jank
 // (for example jank in the cursor if the GPU main thread is performing heavy
 // operations). The inverse is also true as blocking operations on the DRM
 // thread (such as modesetting) no longer block the GPU main thread.
-class DrmThread : public base::Thread {
+class DrmThread : public base::Thread, public ozone::mojom::DeviceCursor {
  public:
   DrmThread();
   ~DrmThread() override;
 
   void Start();
 
   // Must be called on the DRM thread.
   void CreateBuffer(gfx::AcceleratedWidget widget,
                     const gfx::Size& size,
                     gfx::BufferFormat format,
@@ skipping 11 matching lines @@
   void SchedulePageFlip(gfx::AcceleratedWidget widget,
                         const std::vector<OverlayPlane>& planes,
                         const SwapCompletionCallback& callback);
   void GetVSyncParameters(
       gfx::AcceleratedWidget widget,
       const gfx::VSyncProvider::UpdateVSyncCallback& callback);
 
   void CreateWindow(gfx::AcceleratedWidget widget);
   void DestroyWindow(gfx::AcceleratedWidget widget);
   void SetWindowBounds(gfx::AcceleratedWidget widget, const gfx::Rect& bounds);
-  void SetCursor(gfx::AcceleratedWidget widget,
+  void SetCursor(const gfx::AcceleratedWidget& widget,
                  const std::vector<SkBitmap>& bitmaps,
                  const gfx::Point& location,
-                 int frame_delay_ms);
+                 uint32_t frame_delay_ms);

[spang, 2016/07/27 17:00:59]

Should it really be unsigned? I'd say int is the correct thing to use - per the
C++ style guide, unsigned integers should be avoided (with the exception of
bitmasks) because the language's type conversion rules are poisonous.

[rjkroege, 2016/07/27 20:55:13]

But negative time into the future? That makes me sad. It happens to be
completely safe in this case but prudently done anyway.

   void MoveCursor(const gfx::AcceleratedWidget& widget,
                   const gfx::Point& location);
   void CheckOverlayCapabilities(
       gfx::AcceleratedWidget widget,
       const std::vector<OverlayCheck_Params>& overlays,
       const base::Callback<void(gfx::AcceleratedWidget,
                                 const std::vector<OverlayCheck_Params>&)>&
           callback);
   void RefreshNativeDisplays(
       const base::Callback<void(const std::vector<DisplaySnapshot_Params>&)>&
@@ skipping 18 matching lines @@
                     HDCPState state,
                     const base::Callback<void(int64_t, bool)>& callback);
   void SetColorCorrection(int64_t display_id,
                           const std::vector<GammaRampRGBEntry>& degamma_lut,
                           const std::vector<GammaRampRGBEntry>& gamma_lut,
                           const std::vector<float>& correction_matrix);
 
   // base::Thread:
   void Init() override;
 
+  // Mojo support for DeviceCursorRequest.
+  void AddBinding(ozone::mojom::DeviceCursorRequest request);
+
  private:
   std::unique_ptr<DrmDeviceManager> device_manager_;
   std::unique_ptr<ScanoutBufferGenerator> buffer_generator_;
   std::unique_ptr<ScreenManager> screen_manager_;
   std::unique_ptr<DrmGpuDisplayManager> display_manager_;
 
+  // The mojo implementation requires a BindingSet because the DrmThread serves
+  // requests from two different client threads.
+  mojo::BindingSet<ozone::mojom::DeviceCursor> bindings_;
+
   DISALLOW_COPY_AND_ASSIGN(DrmThread);
 };
 
 }  // namespace ui
 
 #endif  // UI_OZONE_PLATFORM_DRM_GPU_DRM_THREAD_H_