Pass Context to Fence Impl methods.

src/libANGLE/Context.cpp

@@ -4987,7 +4987,7 @@ void Context::renderbufferStorageMultisample(GLenum target,
 void Context::getSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
     const Sync *syncObject = getSync(sync);
-    handleError(QuerySynciv(syncObject, pname, bufSize, length, values));
+    handleError(QuerySynciv(this, syncObject, pname, bufSize, length, values));
 }
 
 void Context::getFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
@@ -6119,7 +6119,7 @@ GLsync Context::fenceSync(GLenum condition, GLbitfield flags)
     GLsync syncHandle = reinterpret_cast<GLsync>(static_cast<uintptr_t>(handle));
 
     Sync *syncObject = getSync(syncHandle);
-    Error error      = syncObject->set(condition, flags);
+    Error error      = syncObject->set(this, condition, flags);
     if (error.isError())
     {
         deleteSync(syncHandle);
@@ -6140,14 +6140,14 @@ GLenum Context::clientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
     Sync *syncObject = getSync(sync);
 
     GLenum result = GL_WAIT_FAILED;
-    handleError(syncObject->clientWait(flags, timeout, &result));
+    handleError(syncObject->clientWait(this, flags, timeout, &result));
     return result;
 }
 
 void Context::waitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
     Sync *syncObject = getSync(sync);
-    handleError(syncObject->serverWait(flags, timeout));
+    handleError(syncObject->serverWait(this, flags, timeout));
 }
 
 void Context::getInteger64v(GLenum pname, GLint64 *params)
@@ -6550,7 +6550,7 @@ void Context::finishFenceNV(GLuint fence)
     FenceNV *fenceObject = getFenceNV(fence);
 
     ASSERT(fenceObject && fenceObject->isSet());
-    handleError(fenceObject->finish());
+    handleError(fenceObject->finish(this));
 }
 
 void Context::getFenceivNV(GLuint fence, GLenum pname, GLint *params)
@@ -6570,7 +6570,7 @@ void Context::getFenceivNV(GLuint fence, GLenum pname, GLint *params)
             GLboolean status = GL_TRUE;
             if (fenceObject->getStatus() != GL_TRUE)
             {
-                ANGLE_CONTEXT_TRY(fenceObject->test(&status));
+                ANGLE_CONTEXT_TRY(fenceObject->test(this, &status));
             }
             *params = status;
             break;
@@ -6673,7 +6673,7 @@ void Context::setFenceNV(GLuint fence, GLenum condition)
 
     FenceNV *fenceObject = getFenceNV(fence);
     ASSERT(fenceObject != nullptr);
-    handleError(fenceObject->set(condition));
+    handleError(fenceObject->set(this, condition));
 }
 
 GLboolean Context::testFenceNV(GLuint fence)
@@ -6684,7 +6684,7 @@ GLboolean Context::testFenceNV(GLuint fence)
     ASSERT(fenceObject->isSet() == GL_TRUE);
 
     GLboolean result = GL_TRUE;
-    Error error      = fenceObject->test(&result);
+    Error error      = fenceObject->test(this, &result);
     if (error.isError())
     {
         handleError(error);

src/libANGLE/Fence.cpp

@@ -31,13 +31,9 @@ FenceNV::~FenceNV()
     SafeDelete(mFence);
 }
 
-Error FenceNV::set(GLenum condition)
+Error FenceNV::set(const Context *context, GLenum condition)
 {
-    Error error = mFence->set(condition);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(mFence->set(context, condition));
 
     mCondition = condition;
     mStatus = GL_FALSE;
@@ -46,28 +42,20 @@ Error FenceNV::set(GLenum condition)
     return NoError();
 }
 
-Error FenceNV::test(GLboolean *outResult)
+Error FenceNV::test(const Context *context, GLboolean *outResult)
 {
     // Flush the command buffer by default
-    Error error = mFence->test(&mStatus);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(mFence->test(context, &mStatus));
 
     *outResult = mStatus;
     return NoError();
 }
 
-Error FenceNV::finish()
+Error FenceNV::finish(const Context *context)
 {
     ASSERT(mIsSet);
 
-    gl::Error error = mFence->finish();
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(mFence->finish(context));
 
     mStatus = GL_TRUE;
 
@@ -103,33 +91,32 @@ const std::string &Sync::getLabel() const
     return mLabel;
 }
 
-Error Sync::set(GLenum condition, GLbitfield flags)
+Error Sync::set(const Context *context, GLenum condition, GLbitfield flags)
 {
-    Error error = mFence->set(condition, flags);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(mFence->set(context, condition, flags));
 
     mCondition = condition;
     mFlags = flags;
     return NoError();
 }
 
-Error Sync::clientWait(GLbitfield flags, GLuint64 timeout, GLenum *outResult)
+Error Sync::clientWait(const Context *context,
+                       GLbitfield flags,
+                       GLuint64 timeout,
+                       GLenum *outResult)
 {
     ASSERT(mCondition != GL_NONE);
-    return mFence->clientWait(flags, timeout, outResult);
+    return mFence->clientWait(context, flags, timeout, outResult);
 }
 
-Error Sync::serverWait(GLbitfield flags, GLuint64 timeout)
+Error Sync::serverWait(const Context *context, GLbitfield flags, GLuint64 timeout)
 {
-    return mFence->serverWait(flags, timeout);
+    return mFence->serverWait(context, flags, timeout);
 }
 
-Error Sync::getStatus(GLint *outResult) const
+Error Sync::getStatus(const Context *context, GLint *outResult) const
 {
-    return mFence->getStatus(outResult);
+    return mFence->getStatus(context, outResult);
 }
 
 }  // namespace gl

src/libANGLE/Fence.h

@@ -31,9 +31,9 @@ class FenceNV final : angle::NonCopyable
     explicit FenceNV(rx::FenceNVImpl *impl);
     virtual ~FenceNV();
 
-    Error set(GLenum condition);
-    Error test(GLboolean *outResult);
-    Error finish();
+    Error set(const Context *context, GLenum condition);
+    Error test(const Context *context, GLboolean *outResult);
+    Error finish(const Context *context);
 
     bool isSet() const { return mIsSet; }
     GLboolean getStatus() const { return mStatus; }
@@ -59,10 +59,10 @@ class Sync final : public RefCountObject, public LabeledObject
     void setLabel(const std::string &label) override;
     const std::string &getLabel() const override;
 
-    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;
+    Error set(const Context *context, GLenum condition, GLbitfield flags);
+    Error clientWait(const Context *context, GLbitfield flags, GLuint64 timeout, GLenum *outResult);
+    Error serverWait(const Context *context, GLbitfield flags, GLuint64 timeout);
+    Error getStatus(const Context *context, GLint *outResult) const;
 
     GLenum getCondition() const { return mCondition; }
     GLbitfield getFlags() const { return mFlags; }

src/libANGLE/Fence_unittest.cpp

@@ -25,9 +25,9 @@ class MockFenceNVImpl : public rx::FenceNVImpl
   public:
     virtual ~MockFenceNVImpl() { destroy(); }
 
-    MOCK_METHOD1(set, gl::Error(GLenum));
-    MOCK_METHOD1(test, gl::Error(GLboolean *));
-    MOCK_METHOD0(finish, gl::Error());
+    MOCK_METHOD2(set, gl::Error(const gl::Context *, GLenum));
+    MOCK_METHOD2(test, gl::Error(const gl::Context *, GLboolean *));
+    MOCK_METHOD1(finish, gl::Error(const gl::Context *));
 
     MOCK_METHOD0(destroy, void());
 };
@@ -67,19 +67,19 @@ TEST_F(FenceNVTest, DestructionDeletesImpl)
 
 TEST_F(FenceNVTest, SetAndTestBehavior)
 {
-    EXPECT_CALL(*mImpl, set(_)).WillOnce(Return(gl::NoError())).RetiresOnSaturation();
+    EXPECT_CALL(*mImpl, set(_, _)).WillOnce(Return(gl::NoError())).RetiresOnSaturation();
     EXPECT_FALSE(mFence->isSet());
-    EXPECT_FALSE(mFence->set(GL_ALL_COMPLETED_NV).isError());
+    EXPECT_FALSE(mFence->set(nullptr, GL_ALL_COMPLETED_NV).isError());
     EXPECT_TRUE(mFence->isSet());
     // Fake the behavior of testing the fence before and after it's passed.
-    EXPECT_CALL(*mImpl, test(_))
-        .WillOnce(DoAll(SetArgumentPointee<0>(GL_FALSE), Return(gl::NoError())))
-        .WillOnce(DoAll(SetArgumentPointee<0>(GL_TRUE), Return(gl::NoError())))
+    EXPECT_CALL(*mImpl, test(_, _))
+        .WillOnce(DoAll(SetArgumentPointee<1>(GL_FALSE), Return(gl::NoError())))
+        .WillOnce(DoAll(SetArgumentPointee<1>(GL_TRUE), Return(gl::NoError())))
         .RetiresOnSaturation();
     GLboolean out;
-    EXPECT_FALSE(mFence->test(&out).isError());
+    EXPECT_FALSE(mFence->test(nullptr, &out).isError());
     EXPECT_EQ(GL_FALSE, out);
-    EXPECT_FALSE(mFence->test(&out).isError());
+    EXPECT_FALSE(mFence->test(nullptr, &out).isError());
     EXPECT_EQ(GL_TRUE, out);
 }
 
@@ -92,10 +92,10 @@ class MockSyncImpl : public rx::SyncImpl
   public:
     virtual ~MockSyncImpl() { destroy(); }
 
-    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 *));
+    MOCK_METHOD3(set, gl::Error(const gl::Context *, GLenum, GLbitfield));
+    MOCK_METHOD4(clientWait, gl::Error(const gl::Context *, GLbitfield, GLuint64, GLenum *));
+    MOCK_METHOD3(serverWait, gl::Error(const gl::Context *, GLbitfield, GLuint64));
+    MOCK_METHOD2(getStatus, gl::Error(const gl::Context *, GLint *));
 
     MOCK_METHOD0(destroy, void());
 };
@@ -134,18 +134,18 @@ TEST_F(FenceSyncTest, DestructionDeletesImpl)
 
 TEST_F(FenceSyncTest, SetAndGetStatusBehavior)
 {
-    EXPECT_CALL(*mImpl, set(_, _)).WillOnce(Return(gl::NoError())).RetiresOnSaturation();
-    EXPECT_FALSE(mFence->set(GL_SYNC_GPU_COMMANDS_COMPLETE, 0).isError());
+    EXPECT_CALL(*mImpl, set(_, _, _)).WillOnce(Return(gl::NoError())).RetiresOnSaturation();
+    EXPECT_FALSE(mFence->set(nullptr, GL_SYNC_GPU_COMMANDS_COMPLETE, 0).isError());
     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(_))
-        .WillOnce(DoAll(SetArgumentPointee<0>(GL_UNSIGNALED), Return(gl::NoError())))
-        .WillOnce(DoAll(SetArgumentPointee<0>(GL_SIGNALED), Return(gl::NoError())))
+    EXPECT_CALL(*mImpl, getStatus(_, _))
+        .WillOnce(DoAll(SetArgumentPointee<1>(GL_UNSIGNALED), Return(gl::NoError())))
+        .WillOnce(DoAll(SetArgumentPointee<1>(GL_SIGNALED), Return(gl::NoError())))
         .RetiresOnSaturation();
     GLint out;
-    EXPECT_FALSE(mFence->getStatus(&out).isError());
+    EXPECT_FALSE(mFence->getStatus(nullptr, &out).isError());
     EXPECT_EQ(GL_UNSIGNALED, out);
-    EXPECT_FALSE(mFence->getStatus(&out).isError());
+    EXPECT_FALSE(mFence->getStatus(nullptr, &out).isError());
     EXPECT_EQ(GL_SIGNALED, out);
 }
 

src/libANGLE/queryutils.cpp

@@ -1330,7 +1330,12 @@ void QueryFramebufferParameteriv(const Framebuffer *framebuffer, GLenum pname, G
     }
 }
 
-Error QuerySynciv(const Sync *sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
+Error QuerySynciv(const Context *context,
+                  const Sync *sync,
+                  GLenum pname,
+                  GLsizei bufSize,
+                  GLsizei *length,
+                  GLint *values)
 {
     ASSERT(sync);
 
@@ -1356,7 +1361,7 @@ Error QuerySynciv(const Sync *sync, GLenum pname, GLsizei bufSize, GLsizei *leng
             *values = clampCast<GLint>(sync->getFlags());
             break;
         case GL_SYNC_STATUS:
-            ANGLE_TRY(sync->getStatus(values));
+            ANGLE_TRY(sync->getStatus(context, values));
             break;
 
         default:

src/libANGLE/queryutils.h

@@ -100,7 +100,12 @@ void QueryInternalFormativ(const TextureCaps &format, GLenum pname, GLsizei bufS
 
 void QueryFramebufferParameteriv(const Framebuffer *framebuffer, GLenum pname, GLint *params);
 
-Error QuerySynciv(const Sync *sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
+Error QuerySynciv(const Context *context,
+                  const Sync *sync,
+                  GLenum pname,
+                  GLsizei bufSize,
+                  GLsizei *length,
+                  GLint *values);
 
 void SetTexParameterf(Context *context, Texture *texture, GLenum pname, GLfloat param);
 void SetTexParameterfv(Context *context, Texture *texture, GLenum pname, const GLfloat *params);

src/libANGLE/renderer/FenceNVImpl.h

@@ -15,20 +15,23 @@
 
 #include "angle_gl.h"
 
-namespace rx
+namespace gl
 {
+class Context;
+}  // namespace gl
 
+namespace rx
+{
 class FenceNVImpl : angle::NonCopyable
 {
   public:
     FenceNVImpl() { };
     virtual ~FenceNVImpl() { };
 
-    virtual gl::Error set(GLenum condition) = 0;
-    virtual gl::Error test(GLboolean *outFinished) = 0;
-    virtual gl::Error finish() = 0;
+    virtual gl::Error set(const gl::Context *context, GLenum condition)        = 0;
+    virtual gl::Error test(const gl::Context *context, GLboolean *outFinished) = 0;
+    virtual gl::Error finish(const gl::Context *context)                       = 0;
 };
-
-}
+}  // namespace rx
 
 #endif // LIBANGLE_RENDERER_FENCENVIMPL_H_

src/libANGLE/renderer/SyncImpl.h

@@ -15,20 +15,29 @@
 
 #include "angle_gl.h"
 
-namespace rx
+namespace gl
 {
+class Context;
+}  // namespace gl
 
+namespace rx
+{
 class SyncImpl : angle::NonCopyable
 {
   public:
     SyncImpl(){};
     virtual ~SyncImpl(){};
 
-    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;
+    virtual gl::Error set(const gl::Context *context, GLenum condition, GLbitfield flags) = 0;
+    virtual gl::Error clientWait(const gl::Context *context,
+                                 GLbitfield flags,
+                                 GLuint64 timeout,
+                                 GLenum *outResult)                                       = 0;
+    virtual gl::Error serverWait(const gl::Context *context,
+                                 GLbitfield flags,
+                                 GLuint64 timeout)                                        = 0;
+    virtual gl::Error getStatus(const gl::Context *context, GLint *outResult)             = 0;
 };
-}
+}  // namespace rx
 
 #endif  // LIBANGLE_RENDERER_FENCESYNCIMPL_H_

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

@@ -71,17 +71,17 @@ FenceNV11::~FenceNV11()
     SafeRelease(mQuery);
 }
 
-gl::Error FenceNV11::set(GLenum condition)
+gl::Error FenceNV11::set(const gl::Context *context, GLenum condition)
 {
     return FenceSetHelper(this);
 }
 
-gl::Error FenceNV11::test(GLboolean *outFinished)
+gl::Error FenceNV11::test(const gl::Context *context, GLboolean *outFinished)
 {
     return FenceTestHelper(this, true, outFinished);
 }
 
-gl::Error FenceNV11::finish()
+gl::Error FenceNV11::finish(const gl::Context *context)
 {
     GLboolean finished = GL_FALSE;
 
@@ -132,13 +132,16 @@ Sync11::~Sync11()
     SafeRelease(mQuery);
 }
 
-gl::Error Sync11::set(GLenum condition, GLbitfield flags)
+gl::Error Sync11::set(const gl::Context *context, GLenum condition, GLbitfield flags)
 {
     ASSERT(condition == GL_SYNC_GPU_COMMANDS_COMPLETE && flags == 0);
     return FenceSetHelper(this);
 }
 
-gl::Error Sync11::clientWait(GLbitfield flags, GLuint64 timeout, GLenum *outResult)
+gl::Error Sync11::clientWait(const gl::Context *context,
+                             GLbitfield flags,
+                             GLuint64 timeout,
+                             GLenum *outResult)
 {
     ASSERT(outResult);
 
@@ -212,7 +215,7 @@ gl::Error Sync11::clientWait(GLbitfield flags, GLuint64 timeout, GLenum *outResu
     return gl::NoError();
 }
 
-gl::Error Sync11::serverWait(GLbitfield flags, GLuint64 timeout)
+gl::Error Sync11::serverWait(const gl::Context *context, GLbitfield flags, GLuint64 timeout)
 {
     // Because our API is currently designed to be called from a single thread, we don't need to do
     // extra work for a server-side fence. GPU commands issued after the fence is created will
@@ -220,7 +223,7 @@ gl::Error Sync11::serverWait(GLbitfield flags, GLuint64 timeout)
     return gl::NoError();
 }
 
-gl::Error Sync11::getStatus(GLint *outResult)
+gl::Error Sync11::getStatus(const gl::Context *context, GLint *outResult)
 {
     GLboolean result = GL_FALSE;
     gl::Error error  = FenceTestHelper(this, false, &result);

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

@@ -23,9 +23,9 @@ class FenceNV11 : public FenceNVImpl
     explicit FenceNV11(Renderer11 *renderer);
     ~FenceNV11() override;
 
-    gl::Error set(GLenum condition) override;
-    gl::Error test(GLboolean *outFinished) override;
-    gl::Error finish() override;
+    gl::Error set(const gl::Context *context, GLenum condition) override;
+    gl::Error test(const gl::Context *context, GLboolean *outFinished) override;
+    gl::Error finish(const gl::Context *context) override;
 
   private:
     template<class T> friend gl::Error FenceSetHelper(T *fence);
@@ -41,10 +41,13 @@ class Sync11 : public SyncImpl
     explicit Sync11(Renderer11 *renderer);
     ~Sync11() 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;
+    gl::Error set(const gl::Context *context, GLenum condition, GLbitfield flags) override;
+    gl::Error clientWait(const gl::Context *context,
+                         GLbitfield flags,
+                         GLuint64 timeout,
+                         GLenum *outResult) override;
+    gl::Error serverWait(const gl::Context *context, GLbitfield flags, GLuint64 timeout) override;
+    gl::Error getStatus(const gl::Context *context, GLint *outResult) override;
 
   private:
     template<class T> friend gl::Error FenceSetHelper(T *fence);

src/libANGLE/renderer/d3d/d3d9/Fence9.cpp

@@ -22,7 +22,7 @@ FenceNV9::~FenceNV9()
     SafeRelease(mQuery);
 }
 
-gl::Error FenceNV9::set(GLenum condition)
+gl::Error FenceNV9::set(const gl::Context *context, GLenum condition)
 {
     if (!mQuery)
     {
@@ -44,12 +44,12 @@ gl::Error FenceNV9::set(GLenum condition)
     return gl::NoError();
 }
 
-gl::Error FenceNV9::test(GLboolean *outFinished)
+gl::Error FenceNV9::test(const gl::Context *context, GLboolean *outFinished)
 {
     return testHelper(true, outFinished);
 }
 
-gl::Error FenceNV9::finish()
+gl::Error FenceNV9::finish(const gl::Context *context)
 {
     GLboolean finished = GL_FALSE;
     while (finished != GL_TRUE)
@@ -88,4 +88,4 @@ gl::Error FenceNV9::testHelper(bool flushCommandBuffer, GLboolean *outFinished)
     return gl::NoError();
 }
 
-}
+}  // namespace rx

src/libANGLE/renderer/d3d/d3d9/Fence9.h

@@ -22,9 +22,9 @@ class FenceNV9 : public FenceNVImpl
     explicit FenceNV9(Renderer9 *renderer);
     ~FenceNV9() override;
 
-    gl::Error set(GLenum condition) override;
-    gl::Error test(GLboolean *outFinished) override;
-    gl::Error finish() override;
+    gl::Error set(const gl::Context *context, GLenum condition) override;
+    gl::Error test(const gl::Context *context, GLboolean *outFinished) override;
+    gl::Error finish(const gl::Context *context) override;
 
   private:
     gl::Error testHelper(bool flushCommandBuffer, GLboolean *outFinished);
@@ -32,7 +32,6 @@ class FenceNV9 : public FenceNVImpl
     Renderer9 *mRenderer;
     IDirect3DQuery9 *mQuery;
 };
-
-}
+}  // namespace rx
 
 #endif // LIBANGLE_RENDERER_D3D_D3D9_FENCE9_H_

src/libANGLE/renderer/gl/FenceNVGL.cpp

@@ -28,21 +28,21 @@ FenceNVGL::~FenceNVGL()
     mFence = 0;
 }
 
-gl::Error FenceNVGL::set(GLenum condition)
+gl::Error FenceNVGL::set(const gl::Context *context, GLenum condition)
 {
     ASSERT(condition == GL_ALL_COMPLETED_NV);
     mFunctions->setFenceNV(mFence, condition);
     return gl::NoError();
 }
 
-gl::Error FenceNVGL::test(GLboolean *outFinished)
+gl::Error FenceNVGL::test(const gl::Context *context, GLboolean *outFinished)
 {
     ASSERT(outFinished);
     *outFinished = mFunctions->testFenceNV(mFence);
     return gl::NoError();
 }
 
-gl::Error FenceNVGL::finish()
+gl::Error FenceNVGL::finish(const gl::Context *context)
 {
     mFunctions->finishFenceNV(mFence);
     return gl::NoError();

src/libANGLE/renderer/gl/FenceNVGL.h

@@ -21,9 +21,9 @@ class FenceNVGL : public FenceNVImpl
     explicit FenceNVGL(const FunctionsGL *functions);
     ~FenceNVGL() override;
 
-    gl::Error set(GLenum condition) override;
-    gl::Error test(GLboolean *outFinished) override;
-    gl::Error finish() override;
+    gl::Error set(const gl::Context *context, GLenum condition) override;
+    gl::Error test(const gl::Context *context, GLboolean *outFinished) override;
+    gl::Error finish(const gl::Context *context) override;
 
   private:
     GLuint mFence;

src/libANGLE/renderer/gl/SyncGL.cpp

@@ -27,7 +27,7 @@ SyncGL::~SyncGL()
     }
 }
 
-gl::Error SyncGL::set(GLenum condition, GLbitfield flags)
+gl::Error SyncGL::set(const gl::Context *context, GLenum condition, GLbitfield flags)
 {
     ASSERT(condition == GL_SYNC_GPU_COMMANDS_COMPLETE && flags == 0);
     mSyncObject = mFunctions->fenceSync(condition, flags);
@@ -40,21 +40,24 @@ gl::Error SyncGL::set(GLenum condition, GLbitfield flags)
     return gl::NoError();
 }
 
-gl::Error SyncGL::clientWait(GLbitfield flags, GLuint64 timeout, GLenum *outResult)
+gl::Error SyncGL::clientWait(const gl::Context *context,
+                             GLbitfield flags,
+                             GLuint64 timeout,
+                             GLenum *outResult)
 {
     ASSERT(mSyncObject != 0);
     *outResult = mFunctions->clientWaitSync(mSyncObject, flags, timeout);
     return gl::NoError();
 }
 
-gl::Error SyncGL::serverWait(GLbitfield flags, GLuint64 timeout)
+gl::Error SyncGL::serverWait(const gl::Context *context, GLbitfield flags, GLuint64 timeout)
 {
     ASSERT(mSyncObject != 0);
     mFunctions->waitSync(mSyncObject, flags, timeout);
     return gl::NoError();
 }
 
-gl::Error SyncGL::getStatus(GLint *outResult)
+gl::Error SyncGL::getStatus(const gl::Context *context, GLint *outResult)
 {
     ASSERT(mSyncObject != 0);
     mFunctions->getSynciv(mSyncObject, GL_SYNC_STATUS, 1, nullptr, outResult);

src/libANGLE/renderer/gl/SyncGL.h

@@ -21,10 +21,13 @@ class SyncGL : public SyncImpl
     explicit SyncGL(const FunctionsGL *functions);
     ~SyncGL() 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;
+    gl::Error set(const gl::Context *context, GLenum condition, GLbitfield flags) override;
+    gl::Error clientWait(const gl::Context *context,
+                         GLbitfield flags,
+                         GLuint64 timeout,
+                         GLenum *outResult) override;
+    gl::Error serverWait(const gl::Context *context, GLbitfield flags, GLuint64 timeout) override;
+    gl::Error getStatus(const gl::Context *context, GLint *outResult) override;
 
   private:
     const FunctionsGL *mFunctions;

src/libANGLE/renderer/null/FenceNVNULL.cpp

@@ -22,18 +22,18 @@ FenceNVNULL::~FenceNVNULL()
 {
 }
 
-gl::Error FenceNVNULL::set(GLenum condition)
+gl::Error FenceNVNULL::set(const gl::Context *context, GLenum condition)
 {
     return gl::NoError();
 }
 
-gl::Error FenceNVNULL::test(GLboolean *outFinished)
+gl::Error FenceNVNULL::test(const gl::Context *context, GLboolean *outFinished)
 {
     *outFinished = GL_TRUE;
     return gl::NoError();
 }
 
-gl::Error FenceNVNULL::finish()
+gl::Error FenceNVNULL::finish(const gl::Context *context)
 {
     return gl::NoError();
 }

src/libANGLE/renderer/null/FenceNVNULL.h

@@ -14,18 +14,16 @@
 
 namespace rx
 {
-
 class FenceNVNULL : public FenceNVImpl
 {
   public:
     FenceNVNULL();
     ~FenceNVNULL() override;
 
-    gl::Error set(GLenum condition) override;
-    gl::Error test(GLboolean *outFinished) override;
-    gl::Error finish() override;
+    gl::Error set(const gl::Context *context, GLenum condition) override;
+    gl::Error test(const gl::Context *context, GLboolean *outFinished) override;
+    gl::Error finish(const gl::Context *context) override;
 };
-
 }  // namespace rx
 
 #endif  // LIBANGLE_RENDERER_NULL_FENCENVNULL_H_

src/libANGLE/renderer/null/SyncNULL.cpp

@@ -22,23 +22,26 @@ SyncNULL::~SyncNULL()
 {
 }
 
-gl::Error SyncNULL::set(GLenum condition, GLbitfield flags)
+gl::Error SyncNULL::set(const gl::Context *context, GLenum condition, GLbitfield flags)
 {
     return gl::NoError();
 }
 
-gl::Error SyncNULL::clientWait(GLbitfield flags, GLuint64 timeout, GLenum *outResult)
+gl::Error SyncNULL::clientWait(const gl::Context *context,
+                               GLbitfield flags,
+                               GLuint64 timeout,
+                               GLenum *outResult)
 {
     *outResult = GL_ALREADY_SIGNALED;
     return gl::NoError();
 }
 
-gl::Error SyncNULL::serverWait(GLbitfield flags, GLuint64 timeout)
+gl::Error SyncNULL::serverWait(const gl::Context *context, GLbitfield flags, GLuint64 timeout)
 {
     return gl::NoError();
 }
 
-gl::Error SyncNULL::getStatus(GLint *outResult)
+gl::Error SyncNULL::getStatus(const gl::Context *context, GLint *outResult)
 {
     *outResult = GL_SIGNALED;
     return gl::NoError();

src/libANGLE/renderer/null/SyncNULL.h

@@ -14,19 +14,20 @@
 
 namespace rx
 {
-
 class SyncNULL : public SyncImpl
 {
   public:
     SyncNULL();
     ~SyncNULL() 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;
+    gl::Error set(const gl::Context *context, GLenum condition, GLbitfield flags) override;
+    gl::Error clientWait(const gl::Context *context,
+                         GLbitfield flags,
+                         GLuint64 timeout,
+                         GLenum *outResult) override;
+    gl::Error serverWait(const gl::Context *context, GLbitfield flags, GLuint64 timeout) override;
+    gl::Error getStatus(const gl::Context *context, GLint *outResult) override;
 };
-
 }  // namespace rx
 
 #endif  // LIBANGLE_RENDERER_NULL_FENCESYNCNULL_H_

src/libANGLE/renderer/vulkan/FenceNVVk.cpp

@@ -22,19 +22,19 @@ FenceNVVk::~FenceNVVk()
 {
 }
 
-gl::Error FenceNVVk::set(GLenum condition)
+gl::Error FenceNVVk::set(const gl::Context *context, GLenum condition)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }
 
-gl::Error FenceNVVk::test(GLboolean *outFinished)
+gl::Error FenceNVVk::test(const gl::Context *context, GLboolean *outFinished)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }
 
-gl::Error FenceNVVk::finish()
+gl::Error FenceNVVk::finish(const gl::Context *context)
 {
     UNIMPLEMENTED();
     return gl::InternalError();

src/libANGLE/renderer/vulkan/FenceNVVk.h

@@ -14,18 +14,16 @@
 
 namespace rx
 {
-
 class FenceNVVk : public FenceNVImpl
 {
   public:
     FenceNVVk();
     ~FenceNVVk() override;
 
-    gl::Error set(GLenum condition) override;
-    gl::Error test(GLboolean *outFinished) override;
-    gl::Error finish() override;
+    gl::Error set(const gl::Context *context, GLenum condition) override;
+    gl::Error test(const gl::Context *context, GLboolean *outFinished) override;
+    gl::Error finish(const gl::Context *context) override;
 };
-
 }  // namespace rx
 
 #endif  // LIBANGLE_RENDERER_VULKAN_FENCENVVK_H_

src/libANGLE/renderer/vulkan/SyncVk.cpp

@@ -22,25 +22,28 @@ SyncVk::~SyncVk()
 {
 }
 
-gl::Error SyncVk::set(GLenum condition, GLbitfield flags)
+gl::Error SyncVk::set(const gl::Context *context, GLenum condition, GLbitfield flags)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }
 
-gl::Error SyncVk::clientWait(GLbitfield flags, GLuint64 timeout, GLenum *outResult)
+gl::Error SyncVk::clientWait(const gl::Context *context,
+                             GLbitfield flags,
+                             GLuint64 timeout,
+                             GLenum *outResult)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }
 
-gl::Error SyncVk::serverWait(GLbitfield flags, GLuint64 timeout)
+gl::Error SyncVk::serverWait(const gl::Context *context, GLbitfield flags, GLuint64 timeout)
 {
     UNIMPLEMENTED();
     return gl::InternalError();
 }
 
-gl::Error SyncVk::getStatus(GLint *outResult)
+gl::Error SyncVk::getStatus(const gl::Context *context, GLint *outResult)
 {
     UNIMPLEMENTED();
     return gl::InternalError();

src/libANGLE/renderer/vulkan/SyncVk.h

@@ -14,19 +14,20 @@
 
 namespace rx
 {
-
 class SyncVk : public SyncImpl
 {
   public:
     SyncVk();
     ~SyncVk() 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;
+    gl::Error set(const gl::Context *context, GLenum condition, GLbitfield flags) override;
+    gl::Error clientWait(const gl::Context *context,
+                         GLbitfield flags,
+                         GLuint64 timeout,
+                         GLenum *outResult) override;
+    gl::Error serverWait(const gl::Context *context, GLbitfield flags, GLuint64 timeout) override;
+    gl::Error getStatus(const gl::Context *context, GLint *outResult) override;
 };
-
 }  // namespace rx
 
 #endif  // LIBANGLE_RENDERER_VULKAN_FENCESYNCVK_H_