Add EGL_ARM_implicit_external_sync extension support

ui/gl/gl_surface_ozone.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/gl/gl_surface.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/gl_context.h"
@@ skipping 87 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneEGL);
 };
 
 class GL_EXPORT GLSurfaceOzoneSurfaceless : public SurfacelessEGL {
  public:
   GLSurfaceOzoneSurfaceless(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
                             AcceleratedWidget widget)
       : SurfacelessEGL(gfx::Size()),
         ozone_surface_(ozone_surface.Pass()),
-        widget_(widget) {}
+        widget_(widget),
+        has_implicit_external_sync_(
+            HasEGLExtension("EGL_ARM_implicit_external_sync")) {}
 
   bool Initialize() override {
     if (!SurfacelessEGL::Initialize())
       return false;
     vsync_provider_ = ozone_surface_->CreateVSyncProvider();
     if (!vsync_provider_)
       return false;
     return true;
   }
   bool Resize(const gfx::Size& size) override {
     if (!ozone_surface_->ResizeNativeWindow(size))
       return false;
 
     return SurfacelessEGL::Resize(size);
   }
   bool SwapBuffers() override {
-    // TODO: this should be replaced by a fence when supported by the driver.
-    glFlush();
+    if (!Flush())
+      return false;
     return ozone_surface_->OnSwapBuffers();
   }
   bool ScheduleOverlayPlane(int z_order,
                             OverlayTransform transform,
                             GLImage* image,
                             const Rect& bounds_rect,
                             const RectF& crop_rect) override {
     return image->ScheduleOverlayPlane(
         widget_, z_order, transform, bounds_rect, crop_rect);
   }
   bool IsOffscreen() override { return false; }
   VSyncProvider* GetVSyncProvider() override { return vsync_provider_.get(); }
   bool SupportsPostSubBuffer() override { return true; }
   bool PostSubBuffer(int x, int y, int width, int height) override {
     // The actual sub buffer handling is handled at higher layers.
     SwapBuffers();
     return true;
   }
   bool SwapBuffersAsync(const SwapCompletionCallback& callback) override {
-    // TODO: this should be replaced by a fence when supported by the driver.
-    glFlush();
+    if (!Flush())
+      return false;
     return ozone_surface_->OnSwapBuffersAsync(callback);
   }
   bool PostSubBufferAsync(int x,
                           int y,
                           int width,
                           int height,
                           const SwapCompletionCallback& callback) override {
     return SwapBuffersAsync(callback);
   }
 
  private:
   ~GLSurfaceOzoneSurfaceless() override {
     Destroy();  // EGL surface must be destroyed before SurfaceOzone
   }
 
+  bool Flush() {
+    glFlush();
+    // TODO: the following should be replaced by a per surface flush as it gets
+    // implemented in GL drivers.
+    if (has_implicit_external_sync_) {
+      const EGLint attrib_list[] = {
+          EGL_SYNC_CONDITION_KHR,
+          EGL_SYNC_PRIOR_COMMANDS_IMPLICIT_EXTERNAL_ARM,
+          EGL_NONE};
+      EGLSyncKHR fence =
+          eglCreateSyncKHR(GetDisplay(), EGL_SYNC_FENCE_KHR, attrib_list);
+      if (fence) {
+        eglClientWaitSyncKHR(GetDisplay(), fence,
+                             EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR);

[piman, 2015/02/07 01:13:17]

nit: if we're doing EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, we don't need the glFlush
on l.166. Maybe we can change the logic as 
if (has_implicit_external_sync_) {
  // Do fence logic
} else {
  glFlush();
}

[piman, 2015/02/07 01:13:17]

As a potential optimization, should we delay the ClientWaitSync until we're
about to submit the flip? In case there's already a pending flip we will delay
scheduling this flip, so we could delay the ClientWaitSync for better overlap.
Maybe keep as a TODO / file a bug?

[dnicoara, 2015/02/07 02:03:36]

+1 for TODO and bug. I was talking to Alex about this a few weeks back. We were
discussing optimizing this so we wouldn't block the GPU main thread for this
operation.

+        eglDestroySyncKHR(GetDisplay(), fence);
+      } else {
+        return false;
+      }
+    }
+    return true;
+  }
+
   // The native surface. Deleting this is allowed to free the EGLNativeWindow.
   scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface_;
   AcceleratedWidget widget_;
   scoped_ptr<VSyncProvider> vsync_provider_;
-
+  bool has_implicit_external_sync_;
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneSurfaceless);
 };
 
 }  // namespace
 
 // static
 bool GLSurface::InitializeOneOffInternal() {
   switch (GetGLImplementation()) {
     case kGLImplementationEGLGLES2:
       if (!GLSurfaceEGL::InitializeOneOff()) {
@@ skipping 79 matching lines @@
       NOTREACHED();
       return NULL;
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::SurfaceFactoryOzone::GetInstance()->GetNativeDisplay();
 }
 
 }  // namespace gfx