video_decode_accelerator_unittest: enable test on ozone 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 {
 
 struct PageFlipPayload {
   PageFlipPayload(const scoped_refptr<base::TaskRunner>& task_runner,
                   const DriWrapper::PageFlipCallback& callback)
       : task_runner(task_runner), callback(callback) {}
 
   // Task runner for the thread scheduling the page flip event. This is used to
   // run the callback on the same thread the callback was created on.
   scoped_refptr<base::TaskRunner> task_runner;
   DriWrapper::PageFlipCallback callback;
 };
 
+struct PageFlipSyncPayload {
+  unsigned int frame;
+  unsigned int seconds;
+  unsigned int useconds;
+};
+
 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 33 matching lines @@
 
 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);
 }
 
+void HandlePageFlipEventSync(int fd,
+                             unsigned int frame,
+                             unsigned int seconds,
+                             unsigned int useconds,
+                             void* data) {
+  PageFlipSyncPayload* payload = static_cast<PageFlipSyncPayload*>(data);
+  payload->frame = frame;
+  payload->seconds = seconds;
+  payload->useconds = useconds;
+}
+
 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 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_(io_task_runner), paused_(false), fd_(fd) {
     io_task_runner_->PostTask(FROM_HERE,
-                              base::Bind(&IOWatcher::RegisterOnIO, this, fd));
+                              base::Bind(&IOWatcher::RegisterOnIO, this));
+  }
+
+  void SetPaused(bool value) {
+    bool paused = !!value;
+    if (paused_ == paused)
+      return;
+
+    base::WaitableEvent done(false, false);
+    io_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&IOWatcher::SetPausedOnIO, this, paused, &done));
+    paused_ = paused;
   }
 
   void Shutdown() {
     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(bool paused, 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 99 matching lines @@
                        stride, handle, framebuffer);
 }
 
 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,

[dnicoara, 2015/02/26 16:52:59]

You can pass in an |is_sync| boolean in here and reuse most of the code and you
wouldn't have to make large changes in the callers.

[llandwerlin-old, 2015/02/26 17:37:22]

Done. New CL : https://codereview.chromium.org/960273003

                           uint32_t framebuffer,
                           const PageFlipCallback& callback) {
   DCHECK(file_.IsValid());
   TRACE_EVENT2("dri", "DriWrapper::PageFlip",
                "crtc", crtc_id,
                "framebuffer", framebuffer);
 
+  watcher_->SetPaused(false);
+
   // 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_) {
       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);
     }
 
     return true;
   }
 
   return false;
 }
 
+bool DriWrapper::PageFlipSync(uint32_t crtc_id,
+                              uint32_t framebuffer,
+                              const PageFlipCallback& callback) {
+  DCHECK(file_.IsValid());
+  TRACE_EVENT2("dri", "DriWrapper::PageFlip", "crtc", crtc_id, "framebuffer",
+               framebuffer);
+
+  watcher_->SetPaused(true);
+
+  PageFlipSyncPayload payload;
+  if (!drmModePageFlip(file_.GetPlatformFile(), crtc_id, framebuffer,
+                       DRM_MODE_PAGE_FLIP_EVENT, &payload)) {
+    TRACE_EVENT1("dri", "OnDrmEvent", "socket", file_.GetPlatformFile());
+
+    drmEventContext event;
+    event.version = DRM_EVENT_CONTEXT_VERSION;
+    event.page_flip_handler = HandlePageFlipEventSync;
+    event.vblank_handler = nullptr;
+
+    drmHandleEvent(file_.GetPlatformFile(), &event);
+
+    callback.Run(payload.frame, payload.seconds, payload.useconds);
+    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(file_.IsValid());
   TRACE_EVENT2("dri", "DriWrapper::PageFlipOverlay",
                "crtc", crtc_id,
                "framebuffer", framebuffer);
   return !drmModeSetPlane(file_.GetPlatformFile(), overlay_plane, crtc_id,
@@ skipping 110 matching lines @@
   DCHECK(file_.IsValid());
   return (drmSetMaster(file_.GetPlatformFile()) == 0);
 }
 
 bool DriWrapper::DropMaster() {
   DCHECK(file_.IsValid());
   return (drmDropMaster(file_.GetPlatformFile()) == 0);
 }
 
 }  // namespace ui