Ozone: Avoid blocking in Swapbuffer Call.

content/browser/compositor/buffer_queue.cc

Index: content/browser/compositor/buffer_queue.cc
diff --git a/content/browser/compositor/buffer_queue.cc b/content/browser/compositor/buffer_queue.cc
index ebb01658ccba55c0a1401e9fba4b3e4b22d41bb0..b91be5361c45c0d08bb258bd7955841c4e03a3da 100644
--- a/content/browser/compositor/buffer_queue.cc
+++ b/content/browser/compositor/buffer_queue.cc
@@ -70,8 +70,8 @@ void BufferQueue::CopyBufferDamage(int texture,
 }
 
 void BufferQueue::UpdateBufferDamage(const gfx::Rect& damage) {
-  for (size_t i = 0; i < available_surfaces_.size(); i++)
-    available_surfaces_[i].damage.Union(damage);

[achaulk, 2014/12/05 20:12:20]

This would have to stay to handle rare cases

+  for (size_t i = 0; i < display_queue_surfaces_.size(); i++)
+    display_queue_surfaces_[i].damage.Union(damage);
   for (std::deque<AllocatedSurface>::iterator it =
            in_flight_surfaces_.begin();
        it != in_flight_surfaces_.end();
@@ -111,8 +111,16 @@ void BufferQueue::Reshape(const gfx::Size& size, float scale_factor) {
 }
 
 void BufferQueue::PageFlipComplete() {
+  // The surface is already displayed on screen and is available for use.
+  if (display_queue_surfaces_.size() > 0) {
+    available_surfaces_.push_back(display_queue_surfaces_.front());
+    display_queue_surfaces_.pop_front();

[achaulk, 2014/12/05 20:12:19]

I'm not sure what the point of this extra list (of at most one item?) is. It
seems to be the "current" surface - but that is already handled by the > 1 check
below, the last pushed in-flight surface is not available for re-use. This could
be accomplished by changing the check to > 2 to force always triple buffering

OTOH, it seems what you *really* want to accomplish here would be to trigger the
next frame when the current one is submitted and the previous one is flipped.

You would call into GpuBrowserCompositorOutputSurface::OnSwapBuffersComplete
from GpuSurfacelessBrowserCompositorOutputSurface::SwapBuffers IFF
in_flight_surfaces_.size == 1 (ie, one frame pending). If
BufferQueue::PageFlipComplete() reduces the size to 1, then you fire off a frame
too.

So, you would get this behaviour:
BindFramebuffer -> SwapBuffers (call for new frame)
-> PFC (does nothing, repeat)
-> BindFramebuffer (3rd FB bound) -> SwapBuffers (no new frame) -> PFC (for
first frame, call for new frame)

So, it will selectively triple buffer depending on the frame timings -
technically it will do so now anyway, if the compositor decides to draw a new
frame in advance of the PFC event; I'm not sure when of if this actually occurs
though. See CheckTripleBuffering in the unittest file for an example of a triple
buffering path

+  }
+
+  // We have requested page flip for the surface and it's waiting to be
+  // displayed. Let's not put it back to free list yet.
   if (in_flight_surfaces_.size() > 1) {
-    available_surfaces_.push_back(in_flight_surfaces_.front());
+    display_queue_surfaces_.push_back(in_flight_surfaces_.front());
     in_flight_surfaces_.pop_front();
   }
 }
@@ -123,6 +131,10 @@ void BufferQueue::FreeAllSurfaces() {
     FreeSurface(&in_flight_surfaces_.front());
     in_flight_surfaces_.pop_front();
   }
+  while (!display_queue_surfaces_.empty()) {
+    FreeSurface(&display_queue_surfaces_.front());
+    display_queue_surfaces_.pop_front();
+  }
   for (size_t i = 0; i < available_surfaces_.size(); i++)
     FreeSurface(&available_surfaces_[i]);
   available_surfaces_.clear();