[Ozone-DRI] Listen for swap events

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_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,

[alexst (slow to review), 2015/01/09 03:55:46]

You should mention which thread this task runner belongs to.

[dnicoara, 2015/01/09 15:08:24]

Added some comments. In principle it doesn't matter. If we decide to move it to
another thread it should still be the same.

+                  const DriWrapper::PageFlipCallback& callback)
+      : task_runner(task_runner), callback(callback) {}
+
+  scoped_refptr<base::TaskRunner> task_runner;
+  DriWrapper::PageFlipCallback callback;
+};
+
 bool DrmCreateDumbBuffer(int fd,
                          const SkImageInfo& info,
                          uint32_t* handle,
                          uint32_t* stride) {
   struct drm_mode_create_dumb request;
   memset(&request, 0, sizeof(request));
   request.width = info.width();
   request.height = info.height();
   request.bpp = info.bytesPerPixel() << 3;
   request.flags = 0;
@@ skipping 14 matching lines @@
   return true;
 }
 
 void DrmDestroyDumbBuffer(int fd, uint32_t handle) {
   struct drm_mode_destroy_dumb destroy_request;
   memset(&destroy_request, 0, sizeof(destroy_request));
   destroy_request.handle = handle;
   drmIoctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_request);
 }
 
+void HandlePageFlipEventOnIO(int fd,
+                             unsigned int frame,
+                             unsigned int seconds,
+                             unsigned int useconds,
+                             void* data) {
+  scoped_ptr<PageFlipPayload> payload(static_cast<PageFlipPayload*>(data));
+  payload->task_runner->PostTask(
+      FROM_HERE, base::Bind(payload->callback, frame, seconds, useconds));
+}
+
+void HandlePageFlipEventOnUI(int fd,
+                             unsigned int frame,
+                             unsigned int seconds,
+                             unsigned int useconds,
+                             void* data) {
+  scoped_ptr<PageFlipPayload> payload(static_cast<PageFlipPayload*>(data));
+  payload->callback.Run(frame, seconds, useconds);
+}
+
 }  // namespace
 
-DriWrapper::DriWrapper(const char* device_path)
-    : fd_(-1), device_path_(device_path) {
+class DriWrapper::IOWatcher
+    : public base::RefCountedThreadSafe<DriWrapper::IOWatcher>,
+      public base::MessagePumpLibevent::Watcher {
+ public:
+  IOWatcher(int fd,
+            const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
+      : io_task_runner_(io_task_runner) {
+    io_task_runner_->PostTask(FROM_HERE,
+                              base::Bind(&IOWatcher::RegisterOnIO, this, fd));
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<IOWatcher>;
+
+  ~IOWatcher() override {
+    io_task_runner_->PostTask(FROM_HERE,
+                              base::Bind(&IOWatcher::UnregisterOnIO, this));

[alexst (slow to review), 2015/01/09 03:55:46]

I am pretty sure this is not safe, we are in the destructor, once this leaves
the function, the object is invalid. Taking a ref once we go into the task
runner won't help.

[dnicoara, 2015/01/09 15:08:24]

Doh! You are right, move the post in a Shutdown() function.

+  }
+
+  void RegisterOnIO(int fd) {
+    DCHECK(base::MessageLoopForIO::IsCurrent());
+    base::MessageLoopForIO::current()->WatchFileDescriptor(
+        fd, true, base::MessageLoopForIO::WATCH_READ, &controller_, this);
+  }
+
+  void UnregisterOnIO() {
+    DCHECK(base::MessageLoopForIO::IsCurrent());

[alexst (slow to review), 2015/01/09 03:55:46]

Is this checking that an IO type thread is current? What about the other system
crated io thread?

[dnicoara, 2015/01/09 15:08:24]

Yes. It would be hard to check which IO message loop we're on (especially since
we're cannot access the other IO message loop).

+    controller_.StopWatchingFileDescriptor();
+  }
+
+  // base::MessagePumpLibevent::Watcher overrides:
+  void OnFileCanReadWithoutBlocking(int fd) override {
+    DCHECK(base::MessageLoopForIO::IsCurrent());
+    TRACE_EVENT1("dri", "OnDrmEvent", "socket", fd);
+
+    drmEventContext event;
+    event.version = DRM_EVENT_CONTEXT_VERSION;
+    event.page_flip_handler = HandlePageFlipEventOnIO;
+    event.vblank_handler = nullptr;
+
+    drmHandleEvent(fd, &event);
+  }
+
+  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 software_mode)
+    : fd_(-1),
+      software_mode_(software_mode),
+      device_path_(device_path),
+      io_thread_("DriIOThread") {
   plane_manager_.reset(new HardwareDisplayPlaneManagerLegacy());
 }
 
 DriWrapper::~DriWrapper() {
   if (fd_ >= 0)
     close(fd_);
 }
 
 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 (!software_mode_ && !watcher_) {
+    if (!io_thread_.StartWithOptions(
+            base::Thread::Options(base::MessageLoop::TYPE_IO, 0)))
+      LOG(FATAL) << "Failed to start the IO helper thread";
+
+    watcher_ = new IOWatcher(fd_, io_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,
                          drmModeModeInfo* mode) {
   DCHECK(fd_ >= 0);
@@ skipping 66 matching lines @@
 
 bool DriWrapper::RemoveFramebuffer(uint32_t framebuffer) {
   DCHECK(fd_ >= 0);
   TRACE_EVENT1("dri", "DriWrapper::RemoveFramebuffer",
                "framebuffer", framebuffer);
   return !drmModeRmFB(fd_, framebuffer);
 }
 
 bool DriWrapper::PageFlip(uint32_t crtc_id,
                           uint32_t framebuffer,
-                          void* data) {
+                          const PageFlipCallback& callback) {
   DCHECK(fd_ >= 0);
   TRACE_EVENT2("dri", "DriWrapper::PageFlip",
                "crtc", crtc_id,
                "framebuffer", framebuffer);
-  return !drmModePageFlip(fd_,
-                          crtc_id,
-                          framebuffer,
-                          DRM_MODE_PAGE_FLIP_EVENT,
-                          data);
+
+  // 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 (software_mode_) {
+      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();
+    }
+
+    return true;
+  }
+
+  return false;
 }
 
 bool DriWrapper::PageFlipOverlay(uint32_t crtc_id,
                                  uint32_t framebuffer,
                                  const gfx::Rect& location,
                                  const gfx::Rect& source,
                                  int overlay_plane) {
   DCHECK(fd_ >= 0);
   TRACE_EVENT2("dri", "DriWrapper::PageFlipOverlay",
                "crtc", crtc_id,
@@ skipping 66 matching lines @@
   DCHECK(fd_ >= 0);
   TRACE_EVENT1("dri", "DriWrapper::SetCursor", "handle", handle);
   return !drmModeSetCursor(fd_, crtc_id, handle, size.width(), size.height());
 }
 
 bool DriWrapper::MoveCursor(uint32_t crtc_id, const gfx::Point& point) {
   DCHECK(fd_ >= 0);
   return !drmModeMoveCursor(fd_, crtc_id, point.x(), point.y());
 }
 
-void DriWrapper::HandleEvent(drmEventContext& event) {
-  DCHECK(fd_ >= 0);
-  TRACE_EVENT0("dri", "DriWrapper::HandleEvent");
-  drmHandleEvent(fd_, &event);
-}
-
 bool DriWrapper::CreateDumbBuffer(const SkImageInfo& info,
                                   uint32_t* handle,
                                   uint32_t* stride,
                                   void** pixels) {
   DCHECK(fd_ >= 0);
 
   TRACE_EVENT0("dri", "DriWrapper::CreateDumbBuffer");
   if (!DrmCreateDumbBuffer(fd_, info, handle, stride))
     return false;
 
@@ skipping 19 matching lines @@
   DCHECK(fd_ >= 0);
   return (drmSetMaster(fd_) == 0);
 }
 
 bool DriWrapper::DropMaster() {
   DCHECK(fd_ >= 0);
   return (drmDropMaster(fd_) == 0);
 }
 
 }  // namespace ui