Use mojo for cursor control in ozone drm

ui/ozone/platform/drm/host/drm_cursor.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 "ui/ozone/platform/drm/host/drm_cursor.h"
 
 #include "base/trace_event/trace_event.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/ozone/platform/drm/host/drm_window_host.h"
 #include "ui/ozone/platform/drm/host/drm_window_host_manager.h"
 
 #if defined(OS_CHROMEOS)
 #include "ui/events/ozone/chromeos/cursor_controller.h"
 #endif
 
 namespace ui {
 
 namespace {
 
 class NullProxy : public DrmCursorProxy {
  public:
   NullProxy() {}
   ~NullProxy() override {}
 
   void CursorSet(gfx::AcceleratedWidget window,
                  const std::vector<SkBitmap>& bitmaps,
                  const gfx::Point& point,
                  int frame_delay_ms) override {}
   void Move(gfx::AcceleratedWidget window, const gfx::Point& point) override {}
+  void MoveEvdev(gfx::AcceleratedWidget window,
+                 const gfx::Point& point) override {}
   void InitializeOnEvdev() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NullProxy);
 };
 
 }  // namespace
 
 DrmCursor::DrmCursor(DrmWindowHostManager* window_manager)
     : window_(gfx::kNullAcceleratedWidget),
@@ skipping 116 matching lines @@
     DrmWindowHost* drm_window_host = window_manager_->GetWindow(window);
     display_bounds_in_screen_ = drm_window_host->GetBounds();
     confined_bounds_ = drm_window_host->GetCursorConfinedBounds();
     window_ = window;
   }
 
   SetCursorLocationLocked(location);
   if (window != old_window)
     SendCursorShowLocked();
   else
-    SendCursorMoveLocked();
+    SendCursorMoveLocked(UI);
 }
 
 void DrmCursor::MoveCursorTo(const gfx::PointF& screen_location) {
   TRACE_EVENT0("drmcursor", "DrmCursor::MoveCursorTo");
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock lock(lock_);
 
   // TODO(spang): Moving between windows doesn't work here, but
   // is not needed for current uses.
   SetCursorLocationLocked(screen_location -
                           display_bounds_in_screen_.OffsetFromOrigin());
 
-  SendCursorMoveLocked();
+  SendCursorMoveLocked(UI);

[spang, 2016/07/22 19:52:54]

Assuming MoveCursorTo() is called from UI is broken, the exception is for tablet
devices.

 }
 
 void DrmCursor::MoveCursor(const gfx::Vector2dF& delta) {
   DCHECK(evdev_thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("drmcursor", "DrmCursor::MoveCursor");
   base::AutoLock lock(lock_);
 
   if (window_ == gfx::kNullAcceleratedWidget)
     return;
 
   gfx::Point location;
 #if defined(OS_CHROMEOS)
   gfx::Vector2dF transformed_delta = delta;
   ui::CursorController::GetInstance()->ApplyCursorConfigForWindow(
       window_, &transformed_delta);
   SetCursorLocationLocked(location_ + transformed_delta);
 #else
   SetCursorLocationLocked(location_ + delta);
 #endif
-  SendCursorMoveLocked();
+  SendCursorMoveLocked(EVDEV);
 }
 
 bool DrmCursor::IsCursorVisible() {
   base::AutoLock lock(lock_);
   return static_cast<bool>(bitmap_);
 }
 
 gfx::PointF DrmCursor::GetLocation() {
   base::AutoLock lock(lock_);
   return location_ + display_bounds_in_screen_.OffsetFromOrigin();
@@ skipping 25 matching lines @@
     return;
   }
   CursorSetLockTested(window_, bitmap_->bitmaps(), GetBitmapLocationLocked(),
                       bitmap_->frame_delay_ms());
 }
 
 void DrmCursor::SendCursorHideLocked() {
   CursorSetLockTested(window_, std::vector<SkBitmap>(), gfx::Point(), 0);
 }
 
-void DrmCursor::SendCursorMoveLocked() {
+void DrmCursor::SendCursorMoveLocked(ThreadType thread_type) {
   if (!bitmap_)
     return;
-  MoveLockTested(window_, GetBitmapLocationLocked());
+  MoveLockTested(thread_type, window_, GetBitmapLocationLocked());
 }
 
 // Lock-testing helpers.
 void DrmCursor::CursorSetLockTested(gfx::AcceleratedWidget window,
                                     const std::vector<SkBitmap>& bitmaps,
                                     const gfx::Point& point,
                                     int frame_delay_ms) {
   lock_.AssertAcquired();
   proxy_->CursorSet(window, bitmaps, point, frame_delay_ms);
 }
 
-void DrmCursor::MoveLockTested(gfx::AcceleratedWidget window,
+void DrmCursor::MoveLockTested(ThreadType thread_type,
+                               gfx::AcceleratedWidget window,
                                const gfx::Point& point) {
   lock_.AssertAcquired();
-  proxy_->Move(window, point);
+  if (thread_type == EVDEV)
+    proxy_->MoveEvdev(window, point);
+  else
+    proxy_->Move(window, point);
 }
 
 
 }  // namespace ui