[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/command_line.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/dri_wrapper.h"
 #include "ui/ozone/platform/dri/native_display_delegate_dri.h"
+#include "ui/ozone/public/ozone_switches.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,
-                                     IPC::Listener* main_thread_listener)
+  DriGpuPlatformSupportMessageFilter(
+      DriWindowDelegateManager* window_manager,
+      const base::Closure& on_filter_added_callback,
+      IPC::Listener* main_thread_listener)
       : window_manager_(window_manager),
+        on_filter_added_callback_(on_filter_added_callback),
         main_thread_listener_(main_thread_listener),
         main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
         pending_main_thread_operations_(0),
         cursor_animating_(false) {}
 
   void OnFilterAdded(IPC::Sender* sender) override {
     io_thread_task_runner_ = base::ThreadTaskRunnerHandle::Get();
+    main_thread_task_runner_->PostTask(FROM_HERE, on_filter_added_callback_);
   }
 
   // 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 88 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_;
+  base::Closure on_filter_added_callback_;
   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_;
 };
 }
 
 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);
+  filter_ = new DriGpuPlatformSupportMessageFilter(
+      window_manager,
+      base::Bind(&DriGpuPlatformSupport::OnFilterAdded, base::Unretained(this)),
+      this);
 }
 
 DriGpuPlatformSupport::~DriGpuPlatformSupport() {
 }
 
 void DriGpuPlatformSupport::AddHandler(scoped_ptr<GpuPlatformSupport> handler) {
   handlers_.push_back(handler.release());
 }
 
 void DriGpuPlatformSupport::OnChannelEstablished(IPC::Sender* sender) {
@@ skipping 161 matching lines @@
 
 void DriGpuPlatformSupport::OnRemoveGraphicsDevice(const base::FilePath& path) {
   NOTIMPLEMENTED();
 }
 
 void DriGpuPlatformSupport::RelinquishGpuResources(
     const base::Closure& callback) {
   callback.Run();
 }
 
+void DriGpuPlatformSupport::OnFilterAdded() {
+  base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
+  // Only surfaceless path supports async page flips. So we only initialize the
+  // helper thread if we're using async page flips.
+  if (!helper_thread_.IsRunning() &&
+      cmd->HasSwitch(switches::kOzoneUseSurfaceless)) {
+    helper_thread_.Initialize();
+    drm_->InitializeTaskRunner(helper_thread_.task_runner());
+  }
+}
+
 IPC::MessageFilter* DriGpuPlatformSupport::GetMessageFilter() {
   return filter_.get();
 }
 
 }  // namespace ui