Switch DRM platform to using a separate thread

ui/ozone/platform/drm/gpu/drm_device.cc

Index: ui/ozone/platform/drm/gpu/drm_device.cc
diff --git a/ui/ozone/platform/drm/gpu/drm_device.cc b/ui/ozone/platform/drm/gpu/drm_device.cc
index e150cec0b45df56dd5e6fb85319c98ab231d913c..581aa8ccf3ff0d76d1b87c6125c5b5b11b0cd261 100644
--- a/ui/ozone/platform/drm/gpu/drm_device.cc
+++ b/ui/ozone/platform/drm/gpu/drm_device.cc
@@ -12,8 +12,6 @@
 
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
-#include "base/stl_util.h"
-#include "base/synchronization/waitable_event.h"
 #include "base/task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
@@ -115,10 +113,10 @@ bool CanQueryForResources(int fd) {
 
 }  // namespace
 
-class DrmDevice::PageFlipManager
-    : public base::RefCountedThreadSafe<DrmDevice::PageFlipManager> {
+class DrmDevice::PageFlipManager {
  public:
   PageFlipManager() : next_id_(0) {}
+  ~PageFlipManager() {}
 
   void OnPageFlip(uint32_t frame,
                   uint32_t seconds,
@@ -150,9 +148,6 @@ class DrmDevice::PageFlipManager
   }
 
  private:
-  friend class base::RefCountedThreadSafe<DrmDevice::PageFlipManager>;
-  ~PageFlipManager() {}
-
   struct PageFlip {
     uint64_t id;
     uint32_t pending_calls;
@@ -174,87 +169,54 @@ class DrmDevice::PageFlipManager
   DISALLOW_COPY_AND_ASSIGN(PageFlipManager);
 };
 
-class DrmDevice::IOWatcher
-    : public base::RefCountedThreadSafe<DrmDevice::IOWatcher>,
-      public base::MessagePumpLibevent::Watcher {
+class DrmDevice::IOWatcher : public base::MessagePumpLibevent::Watcher {
  public:
-  IOWatcher(int fd,
-            const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
-            const scoped_refptr<DrmDevice::PageFlipManager>& page_flip_manager)
-      : main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-        io_task_runner_(io_task_runner),
-        page_flip_manager_(page_flip_manager),
-        paused_(true),
-        fd_(fd) {}
+  IOWatcher(int fd, DrmDevice::PageFlipManager* page_flip_manager)
+      : page_flip_manager_(page_flip_manager), paused_(true), fd_(fd) {}
+
+  ~IOWatcher() override {
+    if (!paused_)
+      Unregister();
+  }
 
   void SetPaused(bool paused) {
     if (paused_ == paused)
       return;
 
     paused_ = paused;
-    base::WaitableEvent done(false, false);
-    io_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&IOWatcher::SetPausedOnIO, this, &done));
-    done.Wait();
-  }
-
-  void Shutdown() {
-    if (!paused_)
-      io_task_runner_->PostTask(FROM_HERE,
-                                base::Bind(&IOWatcher::UnregisterOnIO, this));
+    if (paused_)
+      Unregister();
+    else
+      Register();
   }
 
  private:
-  friend class base::RefCountedThreadSafe<IOWatcher>;
-
-  ~IOWatcher() override {}
-
-  void RegisterOnIO() {
+  void Register() {
     DCHECK(base::MessageLoopForIO::IsCurrent());
+    TRACE_EVENT0("drm", "DrmDevice::RegisterOnIO");
     base::MessageLoopForIO::current()->WatchFileDescriptor(
         fd_, true, base::MessageLoopForIO::WATCH_READ, &controller_, this);
   }
 
-  void UnregisterOnIO() {
+  void Unregister() {
     DCHECK(base::MessageLoopForIO::IsCurrent());
+    TRACE_EVENT0("drm", "DrmDevice::UnregisterOnIO");
     controller_.StopWatchingFileDescriptor();
   }
 
-  void SetPausedOnIO(base::WaitableEvent* done) {
-    DCHECK(base::MessageLoopForIO::IsCurrent());
-    if (paused_)
-      UnregisterOnIO();
-    else
-      RegisterOnIO();
-    done->Signal();
-  }
-
-  void OnPageFlipOnIO(uint32_t frame,
-                      uint32_t seconds,
-                      uint32_t useconds,
-                      uint64_t id) {
-    main_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&DrmDevice::PageFlipManager::OnPageFlip, page_flip_manager_,
-                   frame, seconds, useconds, id));
-  }
-
   // base::MessagePumpLibevent::Watcher overrides:
   void OnFileCanReadWithoutBlocking(int fd) override {
     DCHECK(base::MessageLoopForIO::IsCurrent());
     TRACE_EVENT1("drm", "OnDrmEvent", "socket", fd);
 
-    if (!ProcessDrmEvent(
-            fd, base::Bind(&DrmDevice::IOWatcher::OnPageFlipOnIO, this)))
-      UnregisterOnIO();
+    if (!ProcessDrmEvent(fd, base::Bind(&DrmDevice::PageFlipManager::OnPageFlip,
+                                        base::Unretained(page_flip_manager_))))
+      Unregister();
   }
 
   void OnFileCanWriteWithoutBlocking(int fd) override { NOTREACHED(); }
 
-  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
-  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
-
-  scoped_refptr<DrmDevice::PageFlipManager> page_flip_manager_;
+  DrmDevice::PageFlipManager* page_flip_manager_;
 
   base::MessagePumpLibevent::FileDescriptorWatcher controller_;
 
@@ -267,13 +229,11 @@ class DrmDevice::IOWatcher
 DrmDevice::DrmDevice(const base::FilePath& device_path, base::File file)
     : device_path_(device_path),
       file_(file.Pass()),
-      page_flip_manager_(new PageFlipManager()) {
-}
+      page_flip_manager_(new PageFlipManager()),
+      watcher_(
+          new IOWatcher(file_.GetPlatformFile(), page_flip_manager_.get())) {}
 
-DrmDevice::~DrmDevice() {
-  if (watcher_)
-    watcher_->Shutdown();
-}
+DrmDevice::~DrmDevice() {}
 
 bool DrmDevice::Initialize(bool use_atomic) {
   // Ignore devices that cannot perform modesetting.
@@ -301,14 +261,6 @@ bool DrmDevice::Initialize(bool use_atomic) {
   return true;
 }
 
-void DrmDevice::InitializeTaskRunner(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
-  DCHECK(!task_runner_);
-  task_runner_ = task_runner;
-  watcher_ =
-      new IOWatcher(file_.GetPlatformFile(), task_runner_, page_flip_manager_);
-}
-
 ScopedDrmCrtcPtr DrmDevice::GetCrtc(uint32_t crtc_id) {
   DCHECK(file_.IsValid());
   return ScopedDrmCrtcPtr(drmModeGetCrtc(file_.GetPlatformFile(), crtc_id));
@@ -401,9 +353,9 @@ bool DrmDevice::PageFlip(uint32_t crtc_id,
     if (is_sync || !watcher_) {
       TRACE_EVENT1("drm", "OnDrmEvent", "socket", file_.GetPlatformFile());
 
-      ProcessDrmEvent(
-          file_.GetPlatformFile(),
-          base::Bind(&PageFlipManager::OnPageFlip, page_flip_manager_));
+      ProcessDrmEvent(file_.GetPlatformFile(),
+                      base::Bind(&PageFlipManager::OnPageFlip,
+                                 base::Unretained(page_flip_manager_.get())));
     }
 
     return true;
@@ -568,9 +520,9 @@ bool DrmDevice::CommitProperties(drmModePropertySet* properties,
     if (is_sync || !watcher_) {
       TRACE_EVENT1("drm", "OnDrmEvent", "socket", file_.GetPlatformFile());
 
-      ProcessDrmEvent(
-          file_.GetPlatformFile(),
-          base::Bind(&PageFlipManager::OnPageFlip, page_flip_manager_));
+      ProcessDrmEvent(file_.GetPlatformFile(),
+                      base::Bind(&PageFlipManager::OnPageFlip,
+                                 base::Unretained(page_flip_manager_.get())));
     }
     return true;
   }