ozone: dri: add synchronous SwapBuffers support on surfaceless

ui/ozone/platform/dri/hardware_display_controller.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/hardware_display_controller.h"
 
 #include <drm.h>
 #include <errno.h>
 #include <string.h>
 #include <xf86drm.h>
@@ skipping 71 matching lines @@
     crtc_controllers_[i]->Disable();
 
   is_disabled_ = true;
 }
 
 void HardwareDisplayController::QueueOverlayPlane(const OverlayPlane& plane) {
   pending_planes_.push_back(plane);
 }
 
 bool HardwareDisplayController::SchedulePageFlip(
+    bool is_sync,
     const base::Closure& callback) {
   TRACE_EVENT0("dri", "HDC::SchedulePageFlip");
 
   // Ignore requests with no planes to schedule.
   if (pending_planes_.empty()) {
     callback.Run();
     return true;
   }
 
   requests_.push_back(PageFlipRequest(pending_planes_, callback));

[dnicoara, 2015/02/26 22:16:29]

You'll need to add the |is_sync| param to the PageFlipRequest otherwise queued
buffers will execute synchronously.

This is relevant to the asynchronous path where we are queuing requests on
startup.

[llandwerlin-old, 2015/02/27 10:56:47]

Done.

   pending_planes_.clear();
 
   // A request is being serviced right now.
   if (HasPendingPageFlips())
     return true;
 
-  bool status = ActualSchedulePageFlip();
+  bool status = ActualSchedulePageFlip(is_sync);
 
   // No page flip event on failure so discard failed request.
   if (!status)
     requests_.pop_front();
 
   return status;
 }
 
 bool HardwareDisplayController::SetCursor(
     const scoped_refptr<ScanoutBuffer>& buffer) {
@@ skipping 120 matching lines @@
     return;
 
   if (!requests_.empty())
     ProcessPageFlipRequest();
 
   // ProcessPageFlipRequest() consumes a request.
   if (requests_.empty())
     return;
 
   // At this point we still have requests pending, so schedule the next request.
-  bool status = ActualSchedulePageFlip();
+  bool status = ActualSchedulePageFlip(false);

[dnicoara, 2015/02/26 22:16:29]

Then |is_sync| will be taken from the PageFlipRequest.

[llandwerlin-old, 2015/02/27 10:56:47]

Done, thanks a lot.

   if (!status) {
     PageFlipRequest request = requests_.front();
     requests_.pop_front();
 
     // Normally the caller would handle the error call, but because we're in a
     // delayed schedule the initial SchedulePageFlip() already returned true,
     // thus we need to run the callback.
     request.callback.Run();
   }
 }
 
 scoped_refptr<DriWrapper> HardwareDisplayController::GetAllocationDriWrapper()
     const {
   DCHECK(!crtc_controllers_.empty());
   // TODO(dnicoara) When we support mirroring across DRM devices, figure out
   // which device should be used for allocations.
   return crtc_controllers_[0]->drm();
 }
 
 bool HardwareDisplayController::HasPendingPageFlips() const {
   for (size_t i = 0; i < crtc_controllers_.size(); ++i)
     if (crtc_controllers_[i]->page_flip_pending())
       return true;
 
   return false;
 }
 
-bool HardwareDisplayController::ActualSchedulePageFlip() {
+bool HardwareDisplayController::ActualSchedulePageFlip(bool is_sync) {
   TRACE_EVENT0("dri", "HDC::ActualSchedulePageFlip");
   DCHECK(!requests_.empty());
 
   if (is_disabled_) {
     ProcessPageFlipRequest();
     return true;
   }
 
   OverlayPlaneList pending_planes = requests_.front().planes;
   std::sort(pending_planes.begin(), pending_planes.end(),
             [](const OverlayPlane& l, const OverlayPlane& r) {
     return l.z_order < r.z_order;
   });
 
   bool status = true;
   for (size_t i = 0; i < crtc_controllers_.size(); ++i) {
     status &= crtc_controllers_[i]->SchedulePageFlip(
         owned_hardware_planes_.get(crtc_controllers_[i]->drm().get()),
         pending_planes);
   }
 
   for (const auto& planes : owned_hardware_planes_) {
-    if (!planes.first->plane_manager()->Commit(planes.second)) {
+    if (!planes.first->plane_manager()->Commit(planes.second, is_sync)) {
       status = false;
     }
   }
 
   return status;
 }
 
 void HardwareDisplayController::ProcessPageFlipRequest() {
   DCHECK(!requests_.empty());
   PageFlipRequest request = requests_.front();
   requests_.pop_front();
 
   current_planes_.swap(request.planes);
   request.callback.Run();
 }
 
 void HardwareDisplayController::ClearPendingRequests() {
   while (!requests_.empty()) {
     PageFlipRequest request = requests_.front();
     requests_.pop_front();
     request.callback.Run();
   }
 }
 
 }  // namespace ui