ozone: dri: add synchronous SwapBuffers support on surfaceless

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/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/ozone/platform/dri/dri_util.h"
 #include "ui/ozone/platform/dri/hardware_display_plane_manager_legacy.h"
 
 namespace ui {
 
 namespace {
@@ skipping 71 matching lines @@
 }
 
 }  // namespace
 
 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));
+      : io_task_runner_(io_task_runner), paused_(true), fd_(fd) {
+  }
+
+  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));
   }
 
   void Shutdown() {
-    io_task_runner_->PostTask(FROM_HERE,
-                              base::Bind(&IOWatcher::UnregisterOnIO, this));
+    if (!paused_)
+      io_task_runner_->PostTask(FROM_HERE,
+                                base::Bind(&IOWatcher::UnregisterOnIO, this));
   }
 
  private:
   friend class base::RefCountedThreadSafe<IOWatcher>;
 
-  ~IOWatcher() override {}
+  ~IOWatcher() override {
+    SetPaused(true);
+  }
 
-  void RegisterOnIO(int fd) {
+  void RegisterOnIO() {
     DCHECK(base::MessageLoopForIO::IsCurrent());
     base::MessageLoopForIO::current()->WatchFileDescriptor(
-        fd, true, base::MessageLoopForIO::WATCH_READ, &controller_, this);
+        fd_, true, base::MessageLoopForIO::WATCH_READ, &controller_, this);
   }
 
   void UnregisterOnIO() {
     DCHECK(base::MessageLoopForIO::IsCurrent());
     controller_.StopWatchingFileDescriptor();
   }
 
+  void SetPausedOnIO(base::WaitableEvent* done) {
+    DCHECK(base::MessageLoopForIO::IsCurrent());
+    if (paused_)
+      UnregisterOnIO();
+    else
+      RegisterOnIO();
+    done->Signal();
+  }
+
   // 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_;
 
+  bool paused_;
+  int fd_;
+
   DISALLOW_COPY_AND_ASSIGN(IOWatcher);
 };
 
 DriWrapper::DriWrapper(const base::FilePath& device_path)
     : device_path_(device_path),
       file_(device_path,
             base::File::FLAG_OPEN | base::File::FLAG_READ |
                 base::File::FLAG_WRITE) {
   LOG_IF(FATAL, !file_.IsValid())
       << "Failed to open '" << device_path_.value()
@@ skipping 101 matching lines @@
 
 bool DriWrapper::RemoveFramebuffer(uint32_t framebuffer) {
   DCHECK(file_.IsValid());
   TRACE_EVENT1("dri", "DriWrapper::RemoveFramebuffer",
                "framebuffer", framebuffer);
   return !drmModeRmFB(file_.GetPlatformFile(), framebuffer);
 }
 
 bool DriWrapper::PageFlip(uint32_t crtc_id,
                           uint32_t framebuffer,
+                          bool is_sync,
                           const PageFlipCallback& callback) {
   DCHECK(file_.IsValid());
   TRACE_EVENT2("dri", "DriWrapper::PageFlip",
                "crtc", crtc_id,
                "framebuffer", framebuffer);
 
+  if (watcher_)
+    watcher_->SetPaused(is_sync);
+
   // 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(file_.GetPlatformFile(), 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 a task runner isn't installed then fall back to synchronously handling
-    // the page flip events.
-    if (!task_runner_) {
+    // 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("dri", "OnDrmEvent", "socket", file_.GetPlatformFile());
 
       drmEventContext event;
       event.version = DRM_EVENT_CONTEXT_VERSION;
       event.page_flip_handler = HandlePageFlipEventOnUI;
       event.vblank_handler = nullptr;
 
       drmHandleEvent(file_.GetPlatformFile(), &event);
     }
 
@@ skipping 126 matching lines @@
   DCHECK(file_.IsValid());
   return (drmSetMaster(file_.GetPlatformFile()) == 0);
 }
 
 bool DriWrapper::DropMaster() {
   DCHECK(file_.IsValid());
   return (drmDropMaster(file_.GetPlatformFile()) == 0);
 }
 
 }  // namespace ui