Implement FenceSyncGL.

src/libANGLE/Fence.cpp

@@ -77,7 +77,8 @@ Error FenceNV::finishFence()
 FenceSync::FenceSync(rx::FenceSyncImpl *impl, GLuint id)
     : RefCountObject(id),
       mFence(impl),
-      mCondition(GL_NONE)
+      mCondition(GL_NONE),
+      mFlags(0)
 {
 }
 
@@ -86,15 +87,16 @@ FenceSync::~FenceSync()
     SafeDelete(mFence);
 }
 
-Error FenceSync::set(GLenum condition)
+Error FenceSync::set(GLenum condition, GLbitfield flags)
 {
-    Error error = mFence->set();
+    Error error = mFence->set(condition, flags);
     if (error.isError())
     {
         return error;
     }
 
     mCondition = condition;
+    mFlags = flags;
     return Error(GL_NO_ERROR);
 }
 

src/libANGLE/Fence.h

@@ -53,17 +53,19 @@ class FenceSync final : public RefCountObject
     explicit FenceSync(rx::FenceSyncImpl *impl, GLuint id);
     virtual ~FenceSync();
 
-    Error set(GLenum condition);
+    Error set(GLenum condition, GLbitfield flags);
     Error clientWait(GLbitfield flags, GLuint64 timeout, GLenum *outResult);
     Error serverWait(GLbitfield flags, GLuint64 timeout);
     Error getStatus(GLint *outResult) const;
 
     GLenum getCondition() const { return mCondition; }
+    GLbitfield getFlags() const { return mFlags; }
 
   private:
     rx::FenceSyncImpl *mFence;
 
     GLenum mCondition;
+    GLbitfield mFlags;
 };
 
 }

src/libANGLE/Fence_unittest.cpp

@@ -96,7 +96,7 @@ class MockFenceSyncImpl : public rx::FenceSyncImpl
   public:
     virtual ~MockFenceSyncImpl() { destroy(); }
 
-    MOCK_METHOD0(set, gl::Error());
+    MOCK_METHOD2(set, gl::Error(GLenum, GLbitfield));
     MOCK_METHOD3(clientWait, gl::Error(GLbitfield, GLuint64, GLenum *));
     MOCK_METHOD2(serverWait, gl::Error(GLbitfield, GLuint64));
     MOCK_METHOD1(getStatus, gl::Error(GLint *));
@@ -141,10 +141,10 @@ TEST_F(FenceSyncTest, DestructionDeletesImpl)
 
 TEST_F(FenceSyncTest, SetAndGetStatusBehavior)
 {
-    EXPECT_CALL(*mImpl, set())
+    EXPECT_CALL(*mImpl, set(_, _))
         .WillOnce(Return(gl::Error(GL_NO_ERROR)))
         .RetiresOnSaturation();
-    mFence->set(GL_SYNC_GPU_COMMANDS_COMPLETE);
+    mFence->set(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
     EXPECT_EQ(static_cast<GLenum>(GL_SYNC_GPU_COMMANDS_COMPLETE), mFence->getCondition());
     // Fake the behavior of testing the fence before and after it's passed.
     EXPECT_CALL(*mImpl, getStatus(_))

src/libANGLE/renderer/FenceSyncImpl.h

@@ -24,7 +24,7 @@ class FenceSyncImpl : angle::NonCopyable
     FenceSyncImpl() { };
     virtual ~FenceSyncImpl() { };
 
-    virtual gl::Error set() = 0;
+    virtual gl::Error set(GLenum condition, GLbitfield flags) = 0;
     virtual gl::Error clientWait(GLbitfield flags, GLuint64 timeout, GLenum *outResult) = 0;
     virtual gl::Error serverWait(GLbitfield flags, GLuint64 timeout) = 0;
     virtual gl::Error getStatus(GLint *outResult) = 0;

src/libANGLE/renderer/d3d/d3d11/Fence11.cpp

@@ -137,8 +137,9 @@ FenceSync11::~FenceSync11()
     SafeRelease(mQuery);
 }
 
-gl::Error FenceSync11::set()
+gl::Error FenceSync11::set(GLenum condition, GLbitfield flags)
 {
+    ASSERT(condition == GL_SYNC_GPU_COMMANDS_COMPLETE && flags == 0);
     return FenceSetHelper(this);
 }
 

src/libANGLE/renderer/d3d/d3d11/Fence11.h

@@ -38,12 +38,12 @@ class FenceSync11 : public FenceSyncImpl
 {
   public:
     explicit FenceSync11(Renderer11 *renderer);
-    virtual ~FenceSync11();
+    ~FenceSync11() override;
 
-    gl::Error set();
-    gl::Error clientWait(GLbitfield flags, GLuint64 timeout, GLenum *outResult);
-    gl::Error serverWait(GLbitfield flags, GLuint64 timeout);
-    gl::Error getStatus(GLint *outResult);
+    gl::Error set(GLenum condition, GLbitfield flags) override;
+    gl::Error clientWait(GLbitfield flags, GLuint64 timeout, GLenum *outResult) override;
+    gl::Error serverWait(GLbitfield flags, GLuint64 timeout) override;
+    gl::Error getStatus(GLint *outResult) override;
 
   private:
     template<class T> friend gl::Error FenceSetHelper(T *fence);

src/libANGLE/renderer/gl/FenceSyncGL.cpp

@@ -9,39 +9,59 @@
 #include "libANGLE/renderer/gl/FenceSyncGL.h"
 
 #include "common/debug.h"
+#include "libANGLE/renderer/gl/FunctionsGL.h"
 
 namespace rx
 {
 
-FenceSyncGL::FenceSyncGL()
-    : FenceSyncImpl()
-{}
+FenceSyncGL::FenceSyncGL(const FunctionsGL *functions)
+    : FenceSyncImpl(),
+      mFunctions(functions),
+      mSyncObject(0)
+{
+    ASSERT(mFunctions);
+}
 
 FenceSyncGL::~FenceSyncGL()
-{}
+{
+    if (mSyncObject != 0)
+    {
+        mFunctions->deleteSync(mSyncObject);
+    }
+}
 
-gl::Error FenceSyncGL::set()
+gl::Error FenceSyncGL::set(GLenum condition, GLbitfield flags)
 {
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    ASSERT(condition == GL_SYNC_GPU_COMMANDS_COMPLETE && flags == 0);
+    mSyncObject = mFunctions->fenceSync(condition, flags);
+    if (mSyncObject == 0)
+    {
+        // if glFenceSync fails, it returns 0.
+        return gl::Error(GL_OUT_OF_MEMORY, "glFenceSync failed to create a GLsync object.");
+    }
+
+    return gl::Error(GL_NO_ERROR);
 }
 
 gl::Error FenceSyncGL::clientWait(GLbitfield flags, GLuint64 timeout, GLenum *outResult)
 {
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    ASSERT(mSyncObject != 0);
+    *outResult = mFunctions->clientWaitSync(mSyncObject, flags, timeout);
+    return gl::Error(GL_NO_ERROR);
 }
 
 gl::Error FenceSyncGL::serverWait(GLbitfield flags, GLuint64 timeout)
 {
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    ASSERT(mSyncObject != 0);
+    mFunctions->waitSync(mSyncObject, flags, timeout);
+    return gl::Error(GL_NO_ERROR);
 }
 
 gl::Error FenceSyncGL::getStatus(GLint *outResult)
 {
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    ASSERT(mSyncObject != 0);
+    mFunctions->getSynciv(mSyncObject, GL_SYNC_STATUS, 1, nullptr, outResult);
+    return gl::Error(GL_NO_ERROR);
 }
 
 }

src/libANGLE/renderer/gl/FenceSyncGL.h

@@ -13,17 +13,22 @@
 
 namespace rx
 {
+class FunctionsGL;
 
 class FenceSyncGL : public FenceSyncImpl
 {
   public:
-    FenceSyncGL();
+    explicit FenceSyncGL(const FunctionsGL *functions);
     ~FenceSyncGL() override;
 
-    gl::Error set() override;
+    gl::Error set(GLenum condition, GLbitfield flags) override;
     gl::Error clientWait(GLbitfield flags, GLuint64 timeout, GLenum *outResult) override;
     gl::Error serverWait(GLbitfield flags, GLuint64 timeout) override;
     gl::Error getStatus(GLint *outResult) override;
+
+  private:
+    const FunctionsGL *mFunctions;
+    GLsync mSyncObject;
 };
 
 }

src/libANGLE/renderer/gl/FunctionsGL.cpp

@@ -1131,6 +1131,16 @@ void FunctionsGL::initialize()
         AssignGLEntryPoint(loadProcAddress("glPrimitiveRestartIndex"), &primitiveRestartIndex);
         AssignGLEntryPoint(loadProcAddress("glTexBuffer"), &texBuffer);
         AssignGLEntryPoint(loadProcAddress("glUniformBlockBinding"), &uniformBlockBinding);
+
+        // Extensions
+        AssignGLExtensionEntryPoint(extensions, "GL_ARB_sync", loadProcAddress("glClientWaitSync"), &clientWaitSync);
+        AssignGLExtensionEntryPoint(extensions, "GL_ARB_sync", loadProcAddress("glDeleteSync"), &deleteSync);
+        AssignGLExtensionEntryPoint(extensions, "GL_ARB_sync", loadProcAddress("glFenceSync"), &fenceSync);
+        AssignGLExtensionEntryPoint(extensions, "GL_ARB_sync", loadProcAddress("glGetInteger64i_v"), &getInteger64i_v);
+        AssignGLExtensionEntryPoint(extensions, "GL_ARB_sync", loadProcAddress("glGetInteger64v"), &getInteger64v);
+        AssignGLExtensionEntryPoint(extensions, "GL_ARB_sync", loadProcAddress("glGetSynciv"), &getSynciv);
+        AssignGLExtensionEntryPoint(extensions, "GL_ARB_sync", loadProcAddress("glIsSync"), &isSync);
+        AssignGLExtensionEntryPoint(extensions, "GL_ARB_sync", loadProcAddress("glWaitSync"), &waitSync);
     }
 
     // 3.2

src/libANGLE/renderer/gl/RendererGL.cpp

@@ -149,7 +149,7 @@ FenceNVImpl *RendererGL::createFenceNV()
 
 FenceSyncImpl *RendererGL::createFenceSync()
 {
-    return new FenceSyncGL();
+    return new FenceSyncGL(mFunctions);
 }
 
 TransformFeedbackImpl *RendererGL::createTransformFeedback()

src/libGLESv2/entry_points_gles_3_0.cpp

@@ -2371,7 +2371,7 @@ GLsync GL_APIENTRY FenceSync_(GLenum condition, GLbitfield flags)
         GLsync fenceSync = context->createFenceSync();
 
         FenceSync *fenceSyncObject = context->getFenceSync(fenceSync);
-        Error error = fenceSyncObject->set(condition);
+        Error error = fenceSyncObject->set(condition, flags);
         if (error.isError())
         {
             context->deleteFenceSync(fenceSync);
@@ -2575,7 +2575,7 @@ void GL_APIENTRY GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei*
         {
           case GL_OBJECT_TYPE:     values[0] = static_cast<GLint>(GL_SYNC_FENCE);              break;
           case GL_SYNC_CONDITION:  values[0] = static_cast<GLint>(fenceSync->getCondition());  break;
-          case GL_SYNC_FLAGS:      values[0] = 0;                                              break;
+          case GL_SYNC_FLAGS:      values[0] = static_cast<GLint>(fenceSync->getFlags());      break;
 
           case GL_SYNC_STATUS:
             {

src/tests/end2end_tests/FenceSyncTests.cpp

@@ -2,7 +2,7 @@
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
 ANGLE_TYPED_TEST_CASE(FenceNVTest, ES2_D3D9, ES2_D3D11, ES3_D3D11, ES2_OPENGL, ES3_OPENGL);
-ANGLE_TYPED_TEST_CASE(FenceSyncTest, ES3_D3D11);
+ANGLE_TYPED_TEST_CASE(FenceSyncTest, ES3_D3D11, ES3_OPENGL);
 
 template<typename T>
 class FenceNVTest : public ANGLETest