Ozone: Avoid blocking in Swapbuffer Call.

content/browser/compositor/buffer_queue.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 "content/browser/compositor/buffer_queue.h"
 
 #include "content/browser/compositor/image_transport_factory.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "gpu/GLES2/gl2extchromium.h"
@@ skipping 52 matching lines @@
                                  new_damage.y(),
                                  new_damage.width(),
                                  new_damage.height())),
       SkRegion(SkIRect::MakeXYWH(old_damage.x(),
                                  old_damage.y(),
                                  old_damage.width(),
                                  old_damage.height())));
 }
 
 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();
        ++it)
     it->damage.Union(damage);
 }
 
 void BufferQueue::SwapBuffers(const gfx::Rect& damage) {
   if (damage != gfx::Rect(size_)) {
     // We must have a frame available to copy from.
@@ skipping 19 matching lines @@
   // TODO: add stencil buffer when needed.
   gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
   gl->BindFramebuffer(GL_FRAMEBUFFER, fbo_);
   gl->FramebufferTexture2D(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
 
   FreeAllSurfaces();
 }
 
 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();
   }
 }
 
 void BufferQueue::FreeAllSurfaces() {
   FreeSurface(&current_surface_);
   while (!in_flight_surfaces_.empty()) {
     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();
 }
 
 void BufferQueue::FreeSurface(AllocatedSurface* surface) {
   if (surface->texture) {
     gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
     gl->BindTexture(GL_TEXTURE_2D, surface->texture);
     gl->ReleaseTexImage2DCHROMIUM(GL_TEXTURE_2D, surface->image);
@@ skipping 31 matching lines @@
     gl->DeleteTextures(1, &texture);
     return AllocatedSurface();
   }
   allocated_count_++;
   gl->BindTexture(GL_TEXTURE_2D, texture);
   gl->BindTexImage2DCHROMIUM(GL_TEXTURE_2D, id);
   return AllocatedSurface(texture, id, gfx::Rect(size_));
 }
 
 }  // namespace content