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

ui/ozone/platform/dri/dri_wrapper.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_wrapper.h"
 
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #include <xf86drm.h>
 #include <xf86drmMode.h>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "third_party/skia/include/core/SkImageInfo.h"
+#include "ui/ozone/platform/dri/dri_helper_thread.h"
 #include "ui/ozone/platform/dri/dri_util.h"
 #include "ui/ozone/platform/dri/hardware_display_plane_manager_legacy.h"
 
 namespace ui {
 
 namespace {
 
 struct PageFlipPayload {
   PageFlipPayload(const scoped_refptr<base::TaskRunner>& task_runner,
                   const DriWrapper::PageFlipCallback& callback)
@@ skipping 107 matching lines @@
 
   void OnFileCanWriteWithoutBlocking(int fd) override { NOTREACHED(); }
 
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   base::MessagePumpLibevent::FileDescriptorWatcher controller_;
 
   DISALLOW_COPY_AND_ASSIGN(IOWatcher);
 };
 
-DriWrapper::DriWrapper(const char* device_path, bool use_sync_flips)
-    : fd_(-1),
-      use_sync_flips_(use_sync_flips),
-      device_path_(device_path),
-      io_thread_("DriIOThread") {
+DriWrapper::DriWrapper(const char* device_path, DriHelperThread* helper_thread)
+    : fd_(-1), device_path_(device_path), helper_thread_(helper_thread) {
   plane_manager_.reset(new HardwareDisplayPlaneManagerLegacy());
 }
 
 DriWrapper::~DriWrapper() {
   if (fd_ >= 0)
     close(fd_);
 
   if (watcher_)
     watcher_->Shutdown();
 }
 
 void DriWrapper::Initialize() {
   fd_ = open(device_path_, O_RDWR | O_CLOEXEC);
   if (fd_ < 0)
     PLOG(FATAL) << "open: " << device_path_;
   if (!plane_manager_->Initialize(this))
     LOG(ERROR) << "Failed to initialize the plane manager";
 }
 
 void DriWrapper::InitializeIOWatcher() {
-  if (!use_sync_flips_ && !watcher_) {
-    if (!io_thread_.StartWithOptions(
-            base::Thread::Options(base::MessageLoop::TYPE_IO, 0)))
-      LOG(FATAL) << "Failed to start the IO helper thread";
+  DCHECK(helper_thread_->IsRunning());
 
-    watcher_ = new IOWatcher(fd_, io_thread_.task_runner());
-  }
+  if (!watcher_)
+    watcher_ = new IOWatcher(fd_, helper_thread_->task_runner());
 }
 
 ScopedDrmCrtcPtr DriWrapper::GetCrtc(uint32_t crtc_id) {
   DCHECK(fd_ >= 0);
   return ScopedDrmCrtcPtr(drmModeGetCrtc(fd_, crtc_id));
 }
 
 bool DriWrapper::SetCrtc(uint32_t crtc_id,
                          uint32_t framebuffer,
                          std::vector<uint32_t> connectors,
@@ skipping 82 matching lines @@
                "framebuffer", framebuffer);
 
   // NOTE: Calling drmModeSetCrtc will immediately update the state, though
   // callbacks to already scheduled page flips will be honored by the kernel.
   scoped_ptr<PageFlipPayload> payload(
       new PageFlipPayload(base::ThreadTaskRunnerHandle::Get(), callback));
   if (!drmModePageFlip(fd_, crtc_id, framebuffer, DRM_MODE_PAGE_FLIP_EVENT,
                        payload.get())) {
     // If successful the payload will be removed by a PageFlip event.
     ignore_result(payload.release());
-    if (use_sync_flips_) {
+    if (!helper_thread_) {
       TRACE_EVENT1("dri", "OnDrmEvent", "socket", fd_);
 
       drmEventContext event;
       event.version = DRM_EVENT_CONTEXT_VERSION;
       event.page_flip_handler = HandlePageFlipEventOnUI;
       event.vblank_handler = nullptr;
 
       drmHandleEvent(fd_, &event);
     } else {
       InitializeIOWatcher();
@@ skipping 121 matching lines @@
   DCHECK(fd_ >= 0);
   return (drmSetMaster(fd_) == 0);
 }
 
 bool DriWrapper::DropMaster() {
   DCHECK(fd_ >= 0);
   return (drmDropMaster(fd_) == 0);
 }
 
 }  // namespace ui