Switch DRM platform to using a separate thread

ui/ozone/platform/drm/gpu/drm_device.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/drm/gpu/drm_device.h"
 
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #include <xf86drm.h>
 #include <xf86drmMode.h>
 
 #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"
 #include "third_party/skia/include/core/SkImageInfo.h"
 #include "ui/display/types/gamma_ramp_rgb_entry.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
 #include "ui/ozone/platform/drm/gpu/hardware_display_plane_manager_legacy.h"
 
 #if defined(USE_DRM_ATOMIC)
 #include "ui/ozone/platform/drm/gpu/hardware_display_plane_manager_atomic.h"
@@ skipping 81 matching lines @@
 bool CanQueryForResources(int fd) {
   drm_mode_card_res resources;
   memset(&resources, 0, sizeof(resources));
   // If there is no error getting DRM resources then assume this is a
   // modesetting device.
   return !drmIoctl(fd, DRM_IOCTL_MODE_GETRESOURCES, &resources);
 }
 
 }  // 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,
                   uint32_t useconds,
                   uint64_t id) {
     auto it =
         std::find_if(callbacks_.begin(), callbacks_.end(), FindCallback(id));
     if (it == callbacks_.end()) {
       LOG(WARNING) << "Could not find callback for page flip id=" << id;
       return;
@@ skipping 11 matching lines @@
 
   uint64_t GetNextId() { return next_id_++; }
 
   void RegisterCallback(uint64_t id,
                         uint64_t pending_calls,
                         const DrmDevice::PageFlipCallback& callback) {
     callbacks_.push_back({id, pending_calls, callback});
   }
 
  private:
-  friend class base::RefCountedThreadSafe<DrmDevice::PageFlipManager>;
-  ~PageFlipManager() {}
-
   struct PageFlip {
     uint64_t id;
     uint32_t pending_calls;
     DrmDevice::PageFlipCallback callback;
   };
 
   struct FindCallback {
     FindCallback(uint64_t id) : id(id) {}
 
     bool operator()(const PageFlip& flip) const { return flip.id == id; }
 
     uint64_t id;
   };
 
   uint64_t next_id_;
 
   std::vector<PageFlip> callbacks_;
 
   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_;
 
   bool paused_;
   int fd_;
 
   DISALLOW_COPY_AND_ASSIGN(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.
   if (!CanQueryForResources(file_.GetPlatformFile())) {
     VLOG(2) << "Cannot query for resources for '" << device_path_.value()
             << "'";
     return false;
   }
 
 #if defined(USE_DRM_ATOMIC)
   // Use atomic only if the build, kernel & flags all allow it.
   if (use_atomic && SetCapability(DRM_CLIENT_CAP_ATOMIC, 1))
     plane_manager_.reset(new HardwareDisplayPlaneManagerAtomic());
 #endif  // defined(USE_DRM_ATOMIC)
 
   if (!plane_manager_)
     plane_manager_.reset(new HardwareDisplayPlaneManagerLegacy());
   if (!plane_manager_->Initialize(this)) {
     LOG(ERROR) << "Failed to initialize the plane manager for "
                << device_path_.value();
     plane_manager_.reset();
     return false;
   }
 
   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));
 }
 
 bool DrmDevice::SetCrtc(uint32_t crtc_id,
                         uint32_t framebuffer,
                         std::vector<uint32_t> connectors,
                         drmModeModeInfo* mode) {
   DCHECK(file_.IsValid());
@@ skipping 72 matching lines @@
   if (!drmModePageFlip(file_.GetPlatformFile(), crtc_id, framebuffer,
                        DRM_MODE_PAGE_FLIP_EVENT, reinterpret_cast<void*>(id))) {
     // If successful the payload will be removed by a PageFlip event.
     page_flip_manager_->RegisterCallback(id, 1, callback);
 
     // If the flip was requested synchronous or if no watcher has been installed
     // yet, then synchronously handle the page flip events.
     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;
   }
 
   return false;
 }
 
 bool DrmDevice::PageFlipOverlay(uint32_t crtc_id,
                                 uint32_t framebuffer,
@@ skipping 144 matching lines @@
     page_flip_manager_->RegisterCallback(id, crtc_count, callback);
 
     if (watcher_)
       watcher_->SetPaused(is_sync);
 
     // If the flip was requested synchronous or if no watcher has been installed
     // yet, then synchronously handle the page flip events.
     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;
   }
 #endif  // defined(USE_DRM_ATOMIC)
   return false;
 }
 
 bool DrmDevice::SetCapability(uint64_t capability, uint64_t value) {
   DCHECK(file_.IsValid());
   return !drmSetClientCap(file_.GetPlatformFile(), capability, value);
@@ skipping 33 matching lines @@
     b.push_back(lut[i].b);
   }
 
   DCHECK(file_.IsValid());
   TRACE_EVENT0("drm", "DrmDevice::SetGamma");
   return (drmModeCrtcSetGamma(file_.GetPlatformFile(), crtc_id, r.size(), &r[0],
                               &g[0], &b[0]) == 0);
 }
 
 }  // namespace ui