Allow ability to handle cursor position changes on gpu IO thread

ui/ozone/platform/dri/dri_gpu_platform_support.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 "ui/ozone/platform/dri/dri_gpu_platform_support.h"
 
+#include "base/bind.h"
 #include "ipc/ipc_message_macros.h"
 #include "ui/display/types/display_mode.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/ozone/common/display_util.h"
 #include "ui/ozone/common/gpu/ozone_gpu_message_params.h"
 #include "ui/ozone/common/gpu/ozone_gpu_messages.h"
 #include "ui/ozone/platform/dri/dri_window_delegate_impl.h"
 #include "ui/ozone/platform/dri/dri_window_delegate_manager.h"
 #include "ui/ozone/platform/dri/native_display_delegate_dri.h"
 
 namespace ui {
 
+namespace {
+
+class DriGpuPlatformSupportMessageFilter : public IPC::MessageFilter {
+ public:
+  DriGpuPlatformSupportMessageFilter(DriWindowDelegateManager* window_manager,
+                                     IPC::Listener* main_thread_listener)
+      : window_manager_(window_manager),
+        main_thread_listener_(main_thread_listener),
+        main_thread_task_runner_(base::MessageLoop::current()->task_runner()),
+        pending_main_thread_operations_(0) {}
+
+  void OnFilterAdded(IPC::Sender* sender) override {
+    io_thread_task_runner_ = base::MessageLoop::current()->task_runner();

[spang, 2015/01/08 18:58:30]

I think the preferred spelling of this is:

  base::ThreadTaskRunnerHandle::Get().

+  }
+
+  // This code is meant to be very temporary and only as a special case to fix
+  // cursor movement jank resulting from slowdowns on the gpu main thread.
+  // It handles cursor movement on IO thread when display config is stable
+  // and returns it to main thread during transitions.
+  bool OnMessageReceived(const IPC::Message& message) override {
+    // If this message affects the state needed to set cursor, handle it on
+    // the main thread. If a cursor move message arrives but we haven't
+    // processed the previous main thread message, keep processing on main
+    // until nothing is pending.
+    bool process_move_on_main = pending_main_thread_operations_ &&
+                                MessageAffectsCursorPosition(message.type());
+    if (MessageAffectsCursorState(message.type()) || process_move_on_main) {
+      pending_main_thread_operations_++;
+
+      base::Closure main_thread_message_handler =
+          base::Bind(base::IgnoreResult(&IPC::Listener::OnMessageReceived),
+                     base::Unretained(main_thread_listener_), message);
+      main_thread_task_runner_->PostTask(FROM_HERE,
+                                         main_thread_message_handler);
+
+      // This is an echo from the main thread to decrement pending ops.
+      // When the main thread is done with the task, it posts back to IO to
+      // signal completion.
+      base::Closure message_processed_callback = base::Bind(
+          &DriGpuPlatformSupportMessageFilter::MessageProcessedOnMain, this);
+      main_thread_task_runner_->PostTask(FROM_HERE, message_processed_callback);
+
+      return true;
+    }
+
+    // Otherwise, we are in a steady state and it's safe to move cursor on IO.
+    bool handled = true;
+    IPC_BEGIN_MESSAGE_MAP(DriGpuPlatformSupportMessageFilter, message)
+    IPC_MESSAGE_HANDLER(OzoneGpuMsg_CursorMove, OnCursorMove)
+    IPC_MESSAGE_UNHANDLED(handled = false);
+    IPC_END_MESSAGE_MAP()
+
+    return handled;
+  }
+
+ protected:
+  ~DriGpuPlatformSupportMessageFilter() override {}
+
+  void OnCursorMove(gfx::AcceleratedWidget widget, const gfx::Point& location) {
+    window_manager_->GetWindowDelegate(widget)->MoveCursor(location);
+  }
+
+  void MessageProcessedOnMain() {
+    io_thread_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &DriGpuPlatformSupportMessageFilter::DecrementPendingOperationsOnIO,
+            this));
+  }
+
+  void DecrementPendingOperationsOnIO() { pending_main_thread_operations_--; }
+
+  bool MessageAffectsCursorState(uint32 message_type) {
+    switch (message_type) {
+      case OzoneGpuMsg_CreateWindowDelegate::ID:
+      case OzoneGpuMsg_DestroyWindowDelegate::ID:
+      case OzoneGpuMsg_WindowBoundsChanged::ID:
+      case OzoneGpuMsg_ConfigureNativeDisplay::ID:
+      case OzoneGpuMsg_DisableNativeDisplay::ID:
+      case OzoneGpuMsg_CursorSet::ID:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  bool MessageAffectsCursorPosition(uint32 message_type) {
+    switch (message_type) {
+      case OzoneGpuMsg_CursorMove::ID:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  DriWindowDelegateManager* window_manager_;
+  IPC::Listener* main_thread_listener_;
+  scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_thread_task_runner_;
+  int32 pending_main_thread_operations_;
+};
+}
+
 DriGpuPlatformSupport::DriGpuPlatformSupport(
     DriWrapper* drm,
     DriWindowDelegateManager* window_manager,
     ScreenManager* screen_manager,
     scoped_ptr<NativeDisplayDelegateDri> ndd)
     : sender_(NULL),
       drm_(drm),
       window_manager_(window_manager),
       screen_manager_(screen_manager),
       ndd_(ndd.Pass()) {
+  filter_ = new DriGpuPlatformSupportMessageFilter(window_manager, this);
 }
 
 DriGpuPlatformSupport::~DriGpuPlatformSupport() {
 }
 
 void DriGpuPlatformSupport::AddHandler(scoped_ptr<GpuPlatformSupport> handler) {
   handlers_.push_back(handler.release());
 }
 
 void DriGpuPlatformSupport::OnChannelEstablished(IPC::Sender* sender) {
@@ skipping 157 matching lines @@
 void DriGpuPlatformSupport::OnRemoveGraphicsDevice(const base::FilePath& path) {
   NOTIMPLEMENTED();
 }
 
 void DriGpuPlatformSupport::RelinquishGpuResources(
     const base::Closure& callback) {
   callback.Run();
 }
 
 IPC::MessageFilter* DriGpuPlatformSupport::GetMessageFilter() {
-  return nullptr;
+  return filter_.get();
 }
 
 }  // namespace ui