[Ozone-Dri] Decouple the IO helper thread from DriWrapper

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 "base/thread_task_runner_handle.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_helper_thread.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 {
 
 void MessageProcessedOnMain(
     scoped_refptr<base::SingleThreadTaskRunner> io_thread_task_runner,
     const base::Closure& io_thread_task) {
   io_thread_task_runner->PostTask(FROM_HERE, io_thread_task);
 }
 
 class DriGpuPlatformSupportMessageFilter : public IPC::MessageFilter {
  public:
   DriGpuPlatformSupportMessageFilter(DriWindowDelegateManager* window_manager,
+                                     DriHelperThread* helper_thread,
                                      IPC::Listener* main_thread_listener)
       : window_manager_(window_manager),
+        helper_thread_(helper_thread),
         main_thread_listener_(main_thread_listener),
         main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
         pending_main_thread_operations_(0),
         cursor_animating_(false),
         start_on_main_(true) {}
 
   void OnFilterAdded(IPC::Sender* sender) override {
     io_thread_task_runner_ = base::ThreadTaskRunnerHandle::Get();
+    if (helper_thread_)

[alexst (slow to review), 2015/01/22 23:09:24]

So it occurred to me, we shouldn't be passing the helper_thread object between
the threads, that's not safe, the only thing that should cross thread boundaries
is the task runner.

If we call init it here, the dri_wrapper could be getting the task runner while
it's being set on another thread. It's racy.

I am thinking, should we create the thread object and initialize it here and
pass its task_runner to dri by posting to main instead?

Eventually, we will need the task runner here in the filter as well because
that's where the messages will go.

[dnicoara, 2015/01/23 17:13:06]

Done.

I've moved the helper thread in here and Initialized on main as per your
suggestion.

I think we'll need to move the helper thread but currently it is not clear to me
how the GPU initialization needs to be ordered so I'm taking it one step at a
time.

+      helper_thread_->Initialize();
   }
 
   // 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
@@ skipping 89 matching lines @@
 
     OzoneGpuMsg_CursorSet::Param param;
     if (!OzoneGpuMsg_CursorSet::Read(&message, &param))
       return;
 
     int frame_delay_ms = get<3>(param);
     cursor_animating_ = frame_delay_ms != 0;
   }
 
   DriWindowDelegateManager* window_manager_;
+  DriHelperThread* helper_thread_;
   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_;
   bool cursor_animating_;
   // The filter is not installed early enough, so some messages may
   // get routed to main thread. Once we get our first message on io, send it
   // to main to ensure all prior main thread operations are finished before we
   // continue on io.
   // TODO: remove this once filter is properly installed.
   bool start_on_main_;
 };
 }
 
 DriGpuPlatformSupport::DriGpuPlatformSupport(
     DriWrapper* drm,
     DriWindowDelegateManager* window_manager,
     ScreenManager* screen_manager,
+    DriHelperThread* helper_thread,
     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);
+  filter_ = new DriGpuPlatformSupportMessageFilter(window_manager,
+                                                   helper_thread, this);
 }
 
 DriGpuPlatformSupport::~DriGpuPlatformSupport() {
 }
 
 void DriGpuPlatformSupport::AddHandler(scoped_ptr<GpuPlatformSupport> handler) {
   handlers_.push_back(handler.release());
 }
 
 void DriGpuPlatformSupport::OnChannelEstablished(IPC::Sender* sender) {
@@ skipping 166 matching lines @@
 void DriGpuPlatformSupport::RelinquishGpuResources(
     const base::Closure& callback) {
   callback.Run();
 }
 
 IPC::MessageFilter* DriGpuPlatformSupport::GetMessageFilter() {
   return filter_.get();
 }
 
 }  // namespace ui