[Ozone-DRI] Remove the extra helper thread and reuse the IO one

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:
+  typedef base::Callback<void(
+      const scoped_refptr<base::SingleThreadTaskRunner>&)>
+      OnFilterAddedCallback;
+
   DriGpuPlatformSupportMessageFilter(
       DriWindowDelegateManager* window_manager,
-      const base::Closure& on_filter_added_callback,
+      const OnFilterAddedCallback& 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_);
+    main_thread_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(on_filter_added_callback_, io_thread_task_runner_));
   }
 
   // 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_;
+  OnFilterAddedCallback 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,
-      base::Bind(&DriGpuPlatformSupport::OnFilterAdded, base::Unretained(this)),
+      window_manager, base::Bind(&DriGpuPlatformSupport::SetIOTaskRunner,
+                                 base::Unretained(this)),
       this);
 }
 
 DriGpuPlatformSupport::~DriGpuPlatformSupport() {
 }
 
 void DriGpuPlatformSupport::AddHandler(scoped_ptr<GpuPlatformSupport> handler) {
   handlers_.push_back(handler.release());
 }
 
@@ skipping 156 matching lines @@
 
 void DriGpuPlatformSupport::OnRemoveGraphicsDevice(const base::FilePath& path) {
   NOTIMPLEMENTED();
 }
 
 void DriGpuPlatformSupport::RelinquishGpuResources(
     const base::Closure& callback) {
   callback.Run();
 }
 
-void DriGpuPlatformSupport::OnFilterAdded() {
+void DriGpuPlatformSupport::SetIOTaskRunner(
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner) {
+  io_task_runner_ = io_task_runner;
   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());
+  // Only surfaceless path supports async page flips.
+  if (cmd->HasSwitch(switches::kOzoneUseSurfaceless)) {
+    drm_->InitializeTaskRunner(io_task_runner_);
   }
 }
 
 IPC::MessageFilter* DriGpuPlatformSupport::GetMessageFilter() {
   return filter_.get();
 }
 
 }  // namespace ui