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>
@@ skipping 96 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),
-        fd_(fd) {
-    io_task_runner_->PostTask(FROM_HERE,
-                              base::Bind(&IOWatcher::RegisterOnIO, this));
+  IOWatcher(int fd, DrmDevice::PageFlipManager* page_flip_manager)
+      : page_flip_manager_(page_flip_manager), fd_(fd) {
+    Register();
   }
 
-  void Shutdown() {
-    io_task_runner_->PostTask(FROM_HERE,
-                              base::Bind(&IOWatcher::UnregisterOnIO, this));
-  }
+  ~IOWatcher() override { Unregister(); }
 
  private:
-  friend class base::RefCountedThreadSafe<IOWatcher>;
-
-  ~IOWatcher() override {}
-
-  void RegisterOnIO() {
+  void Register() {
     DCHECK(base::MessageLoopForIO::IsCurrent());
     base::MessageLoopForIO::current()->WatchFileDescriptor(
         fd_, true, base::MessageLoopForIO::WATCH_READ, &controller_, this);
   }
 
-  void UnregisterOnIO() {
+  void Unregister() {
     DCHECK(base::MessageLoopForIO::IsCurrent());
     controller_.StopWatchingFileDescriptor();
   }
 
-  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_;
 
   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()) {}
 
-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;
   }
 
+  watcher_.reset(
+      new IOWatcher(file_.GetPlatformFile(), page_flip_manager_.get()));
+
   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 271 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