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>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/ozone/platform/dri/crtc_controller.h"
 #include "ui/ozone/platform/dri/dri_buffer.h"
 #include "ui/ozone/platform/dri/dri_wrapper.h"
 #include "ui/ozone/public/native_pixmap.h"
 
 namespace ui {
 
 HardwareDisplayController::PageFlipRequest::PageFlipRequest(
     const OverlayPlaneList& planes,
+    bool is_sync,
     const base::Closure& callback)
-    : planes(planes), callback(callback) {
+    : planes(planes), is_sync(is_sync), callback(callback) {
 }
 
 HardwareDisplayController::PageFlipRequest::~PageFlipRequest() {
 }
 
 HardwareDisplayController::HardwareDisplayController(
     scoped_ptr<CrtcController> controller)
     : is_disabled_(true) {
   memset(&mode_, 0, sizeof(mode_));
   AddCrtc(controller.Pass());
@@ skipping 17 matching lines @@
   mode_ = mode;
 
   current_planes_ = std::vector<OverlayPlane>(1, primary);
   pending_planes_.clear();
   ClearPendingRequests();
 
   // Because a page flip is pending we need to leave some state for the
   // callback. We use the modeset state since it is the only valid state.
   if (HasPendingPageFlips())
     requests_.push_back(
-        PageFlipRequest(current_planes_, base::Bind(&base::DoNothing)));
+        PageFlipRequest(current_planes_, false, base::Bind(&base::DoNothing)));
 
   return status;
 }
 
 bool HardwareDisplayController::Enable() {
   TRACE_EVENT0("dri", "HDC::Enable");
   DCHECK(!current_planes_.empty());
   const OverlayPlane* primary = OverlayPlane::GetPrimaryPlane(current_planes_);
 
   return Modeset(*primary, mode_);
 }
 
 void HardwareDisplayController::Disable() {
   TRACE_EVENT0("dri", "HDC::Disable");
   for (size_t i = 0; i < crtc_controllers_.size(); ++i)
     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));
+  requests_.push_back(PageFlipRequest(pending_planes_, is_sync, callback));
   pending_planes_.clear();
 
   // A request is being serviced right now.
   if (HasPendingPageFlips())
     return true;
 
   bool status = ActualSchedulePageFlip();
 
   // No page flip event on failure so discard failed request.
   if (!status)
@@ skipping 177 matching lines @@
     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);
   }
 
+  bool is_sync = requests_.front().is_sync;
   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