gpu: Add EGL fence support.

ui/gl/gl_surface_egl.cc

 // Copyright (c) 2012 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/gl/gl_surface_egl.h"
 
 #if defined(OS_ANDROID)
 #include <android/native_window_jni.h>
 #endif
 
+#include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "build/build_config.h"
 #include "ui/gl/egl_util.h"
 #include "ui/gl/gl_context.h"
 
 #if defined(USE_X11)
 extern "C" {
 #include <X11/Xlib.h>
@@ skipping 193 matching lines @@
   return g_egl_create_context_robustness_supported;
 }
 
 GLSurfaceEGL::~GLSurfaceEGL() {}
 
 NativeViewGLSurfaceEGL::NativeViewGLSurfaceEGL(bool software,
                                                gfx::AcceleratedWidget window)
     : window_(window),
       surface_(NULL),
       supports_post_sub_buffer_(false),
-      config_(NULL) {
+      config_(NULL),
+      max_frame_latency_(0) {
   software_ = software;
 #if defined(OS_ANDROID)
   if (window)
     ANativeWindow_acquire(window);
 #endif
 }
 
 bool NativeViewGLSurfaceEGL::Initialize() {
   DCHECK(!surface_);
 
@@ skipping 126 matching lines @@
   }
   return config_;
 #endif
 }
 
 bool NativeViewGLSurfaceEGL::IsOffscreen() {
   return false;
 }
 
 bool NativeViewGLSurfaceEGL::SwapBuffers() {
+  // Create a fence for this frame.
+  if (max_frame_latency_ > 0) {
+    DCHECK_LE(frame_fences_.size(), max_frame_latency_ - 1);
+    EGLSyncKHR fence = eglCreateSyncKHR(GetDisplay(), EGL_SYNC_FENCE_KHR, NULL);

[Sami, 2013/04/24 10:44:18]

I remember one driver where sync object creation was expensive. Might be worth
taking a quick trace to see how long this takes.

[epennerAtGoogle, 2013/04/24 19:33:38]

Will do.

+    frame_fences_.push_back(fence);
+  }
+
   if (!eglSwapBuffers(GetDisplay(), surface_)) {
     DVLOG(1) << "eglSwapBuffers failed with error "
              << GetLastEGLErrorString();
     return false;
   }
 
+  // SwapBuffers above will block above according to the driver's
+  // maximum latency. We now block again according to our own.
+  DCHECK_LE(frame_fences_.size(), max_frame_latency_);
+  if (frame_fences_.size() == max_frame_latency_) {
+    TRACE_EVENT0("cc", "NativeViewGLSurfaceEGL eglClientWaitSyncKHR");
+    // We shouldn't need the flush flag, as SwapBuffers
+    // always triggers a flush.
+    EGLint flags = 0; //EGL_SYNC_FLUSH_COMMANDS_BIT_KHR;
+    EGLTimeKHR time = EGL_FOREVER_KHR;
+    EGLSyncKHR fence = frame_fences_.front();
+    eglClientWaitSyncKHR(GetDisplay(), fence, flags, time);

[Sami, 2013/04/24 10:44:18]

Call eglDestroySyncKHR after waiting here to avoid leaking the fence.

For extra paranoia please also add a DCHECK() for the result of the wait.

[epennerAtGoogle, 2013/04/24 19:33:38]

Oops! Thanks!

+    frame_fences_.pop_front();
+  }
+
   return true;
 }
 
 gfx::Size NativeViewGLSurfaceEGL::GetSize() {
   EGLint width;
   EGLint height;
   if (!eglQuerySurface(GetDisplay(), surface_, EGL_WIDTH, &width) ||
       !eglQuerySurface(GetDisplay(), surface_, EGL_HEIGHT, &height)) {
     NOTREACHED() << "eglQuerySurface failed with error "
                  << GetLastEGLErrorString();
@@ skipping 45 matching lines @@
              << GetLastEGLErrorString();
     return false;
   }
   return true;
 }
 
 VSyncProvider* NativeViewGLSurfaceEGL::GetVSyncProvider() {
   return vsync_provider_.get();
 }
 
+void NativeViewGLSurfaceEGL::SetMaximumFrameLatency(unsigned int frames) {
+  while (frame_fences_.size() > frames) {
+    eglDestroySyncKHR(GetDisplay(), frame_fences_.front());
+    frame_fences_.pop_front();
+  }
+  max_frame_latency_ = frames;
+}
+
 NativeViewGLSurfaceEGL::~NativeViewGLSurfaceEGL() {
+  SetMaximumFrameLatency(0);
+  DCHECK(!frame_fences_.size());
+
   Destroy();
 #if defined(OS_ANDROID)
   if (window_)
     ANativeWindow_release(window_);
 #endif
 }
 
 void NativeViewGLSurfaceEGL::SetHandle(EGLSurface surface) {
   surface_ = surface;
 }
@@ skipping 117 matching lines @@
 
   return handle;
 #endif
 }
 
 PbufferGLSurfaceEGL::~PbufferGLSurfaceEGL() {
   Destroy();
 }
 
 }  // namespace gfx