Ozone: Avoid blocking in Swapbuffer Call.

ui/ozone/platform/dri/gbm_surfaceless.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/gbm_surfaceless.h"
 
 #include "ui/ozone/platform/dri/dri_vsync_provider.h"
 #include "ui/ozone/platform/dri/dri_window_delegate.h"
 #include "ui/ozone/platform/dri/gbm_buffer.h"
 #include "ui/ozone/platform/dri/hardware_display_controller.h"
+#include "ui/ozone/platform/dri/page_flip_event_handler.h"
 
 namespace ui {
 
-GbmSurfaceless::GbmSurfaceless(DriWindowDelegate* window_delegate)
-    : window_delegate_(window_delegate) {
+GbmSurfaceless::GbmSurfaceless(DriWindowDelegate* window_delegate,
+                               PageFilpEventHandler* handler)
+    : window_delegate_(window_delegate), flip_handler_(handler) {
 }
 
 GbmSurfaceless::~GbmSurfaceless() {}
 
 intptr_t GbmSurfaceless::GetNativeWindow() {
   NOTREACHED();
   return 0;
 }
 
 bool GbmSurfaceless::ResizeNativeWindow(const gfx::Size& viewport_size) {
   NOTIMPLEMENTED();
   return false;
 }
 
 bool GbmSurfaceless::OnSwapBuffers() {
   HardwareDisplayController* controller = window_delegate_->GetController();
   if (!controller)
     return true;
 
+  // Make sure any previous Page Flip requests have been processed, otherwise
+  // the drivers will complain as EBusy. We don't have support for Flip queue
+  // in any of the drivers.
+  if (flip_handler_)
+    flip_handler_->EnsurePreviousFlipHandled();

[brianderson, 2014/12/10 22:48:05]

Looks like this is a blocking call. Is this on a critical thread?

If so, would it work for this to be a DCHECK that
flip_handler_->polling_.IsSignaled() is false and then make sure the rest of the
scheduling code doesn't hit this DCHECK.

I think Alex's suggestion to keep the swap ack associated with flip will be
enough to make sure we don't hit the DCHECK.

[kalyank, 2014/12/11 03:24:26]

We swap, submit page flip requests and wait till the flip requests are handled.
The wait operation has been moved to worker thread now, making sure we don't
block the main thread unless really needed. In ideal case, by the next swap the
flip requests are handled and we issue new ones.How ever this might not be the
case depending on the work load. Issuing new flip requests before old ones are
handled is not well supported (Queuing Flips). This makes sure we handle this
case.

I am probably missing something here. I see scheduler has various criteria as to
when it can start drawing for next frame content. One of them is no of pending
swaps and max pending swaps allowed (capabilities of output surface). I see that
the max pending swaps allowed is one and thus scheduler doesn't start preparing
for next frame till it receives SwapBufferAck. Even though we move the wait
operation to a worker thread, Scheduler is left waiting for SwapBufferAck
request and thus not utilizing this wait time for some productive work.

[kalyank, 2014/12/11 12:55:58]

Now, we don't block on Main thread at all. In GLSurfaceOzone, we track if we are
still handling the submitted page flip events, if so postpone the onSwapBuffer
call till we receive the callback from PageEventHandler. I see that after making
this change, when I open around 6-7 new windows or close and reopen windows
(Around 2-3 times), Page flip IPC call is not received in
CommandBufferProxyImpl, for some reason even though ImageTransportHelper sends
it. I am currently investigating that.

+
   bool success = controller->SchedulePageFlip();
-  controller->WaitForPageFlipEvent();
+  if (!flip_handler_)
+    controller->WaitForPageFlipEvent();
+  else
+    flip_handler_->GetPageFlipCompleted(controller, callback_);
 
   return success;
 }
 
 scoped_ptr<gfx::VSyncProvider> GbmSurfaceless::CreateVSyncProvider() {
   return scoped_ptr<gfx::VSyncProvider>(new DriVSyncProvider(window_delegate_));
 }
 
+void GbmSurfaceless::SetPageFlipCompletionCallback(
+    const PageFlipCompletionCallback& callback) {
+  callback_ = callback;
+}
+
 }  // namespace ui