Use angle::Result in front-end (Part 7)

src/libANGLE/Fence.cpp

@@ -31,7 +31,7 @@ FenceNV::~FenceNV()
     SafeDelete(mFence);
 }
 
-Error FenceNV::set(const Context *context, GLenum condition)
+angle::Result FenceNV::set(const Context *context, GLenum condition)
 {
     ANGLE_TRY(mFence->set(context, condition));
 
@@ -39,19 +39,19 @@ Error FenceNV::set(const Context *context, GLenum condition)
     mStatus = GL_FALSE;
     mIsSet = true;
 
-    return NoError();
+    return angle::Result::Continue();
 }
 
-Error FenceNV::test(const Context *context, GLboolean *outResult)
+angle::Result FenceNV::test(const Context *context, GLboolean *outResult)
 {
     // Flush the command buffer by default
     ANGLE_TRY(mFence->test(context, &mStatus));
 
     *outResult = mStatus;
-    return NoError();
+    return angle::Result::Continue();
 }
 
-Error FenceNV::finish(const Context *context)
+angle::Result FenceNV::finish(const Context *context)
 {
     ASSERT(mIsSet);
 
@@ -59,7 +59,7 @@ Error FenceNV::finish(const Context *context)
 
     mStatus = GL_TRUE;
 
-    return NoError();
+    return angle::Result::Continue();
 }
 
 Sync::Sync(rx::SyncImpl *impl, GLuint id)
@@ -90,30 +90,30 @@ const std::string &Sync::getLabel() const
     return mLabel;
 }
 
-Error Sync::set(const Context *context, GLenum condition, GLbitfield flags)
+angle::Result Sync::set(const Context *context, GLenum condition, GLbitfield flags)
 {
     ANGLE_TRY(mFence->set(context, condition, flags));
 
     mCondition = condition;
     mFlags = flags;
-    return NoError();
+    return angle::Result::Continue();
 }
 
-Error Sync::clientWait(const Context *context,
-                       GLbitfield flags,
-                       GLuint64 timeout,
-                       GLenum *outResult)
+angle::Result Sync::clientWait(const Context *context,
+                               GLbitfield flags,
+                               GLuint64 timeout,
+                               GLenum *outResult)
 {
     ASSERT(mCondition != GL_NONE);
     return mFence->clientWait(context, flags, timeout, outResult);
 }
 
-Error Sync::serverWait(const Context *context, GLbitfield flags, GLuint64 timeout)
+angle::Result Sync::serverWait(const Context *context, GLbitfield flags, GLuint64 timeout)
 {
     return mFence->serverWait(context, flags, timeout);
 }
 
-Error Sync::getStatus(const Context *context, GLint *outResult) const
+angle::Result Sync::getStatus(const Context *context, GLint *outResult) const
 {
     return mFence->getStatus(context, outResult);
 }

src/libANGLE/Fence.h

@@ -31,9 +31,9 @@ class FenceNV final : angle::NonCopyable
     explicit FenceNV(rx::FenceNVImpl *impl);
     virtual ~FenceNV();
 
-    Error set(const Context *context, GLenum condition);
-    Error test(const Context *context, GLboolean *outResult);
-    Error finish(const Context *context);
+    angle::Result set(const Context *context, GLenum condition);
+    angle::Result test(const Context *context, GLboolean *outResult);
+    angle::Result finish(const Context *context);
 
     bool isSet() const { return mIsSet; }
     GLboolean getStatus() const { return mStatus; }
@@ -59,10 +59,13 @@ class Sync final : public RefCountObject, public LabeledObject
     void setLabel(const std::string &label) override;
     const std::string &getLabel() const override;
 
-    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;
+    angle::Result set(const Context *context, GLenum condition, GLbitfield flags);
+    angle::Result clientWait(const Context *context,
+                             GLbitfield flags,
+                             GLuint64 timeout,
+                             GLenum *outResult);
+    angle::Result serverWait(const Context *context, GLbitfield flags, GLuint64 timeout);
+    angle::Result 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_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_METHOD2(set, angle::Result(const gl::Context *, GLenum));
+    MOCK_METHOD2(test, angle::Result(const gl::Context *, GLboolean *));
+    MOCK_METHOD1(finish, angle::Result(const gl::Context *));
 
     MOCK_METHOD0(destroy, void());
 };
@@ -67,14 +67,16 @@ TEST_F(FenceNVTest, DestructionDeletesImpl)
 
 TEST_F(FenceNVTest, SetAndTestBehavior)
 {
-    EXPECT_CALL(*mImpl, set(_, _)).WillOnce(Return(gl::NoError())).RetiresOnSaturation();
+    EXPECT_CALL(*mImpl, set(_, _))
+        .WillOnce(Return(angle::Result::Continue()))
+        .RetiresOnSaturation();
     EXPECT_FALSE(mFence->isSet());
     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<1>(GL_FALSE), Return(gl::NoError())))
-        .WillOnce(DoAll(SetArgumentPointee<1>(GL_TRUE), Return(gl::NoError())))
+        .WillOnce(DoAll(SetArgumentPointee<1>(GL_FALSE), Return(angle::Result::Continue())))
+        .WillOnce(DoAll(SetArgumentPointee<1>(GL_TRUE), Return(angle::Result::Continue())))
         .RetiresOnSaturation();
     GLboolean out;
     EXPECT_FALSE(mFence->test(nullptr, &out).isError());
@@ -92,10 +94,10 @@ class MockSyncImpl : public rx::SyncImpl
   public:
     virtual ~MockSyncImpl() { destroy(); }
 
-    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_METHOD3(set, angle::Result(const gl::Context *, GLenum, GLbitfield));
+    MOCK_METHOD4(clientWait, angle::Result(const gl::Context *, GLbitfield, GLuint64, GLenum *));
+    MOCK_METHOD3(serverWait, angle::Result(const gl::Context *, GLbitfield, GLuint64));
+    MOCK_METHOD2(getStatus, angle::Result(const gl::Context *, GLint *));
 
     MOCK_METHOD0(destroy, void());
 };
@@ -134,13 +136,15 @@ TEST_F(FenceSyncTest, DestructionDeletesImpl)
 
 TEST_F(FenceSyncTest, SetAndGetStatusBehavior)
 {
-    EXPECT_CALL(*mImpl, set(_, _, _)).WillOnce(Return(gl::NoError())).RetiresOnSaturation();
+    EXPECT_CALL(*mImpl, set(_, _, _))
+        .WillOnce(Return(angle::Result::Continue()))
+        .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<1>(GL_UNSIGNALED), Return(gl::NoError())))
-        .WillOnce(DoAll(SetArgumentPointee<1>(GL_SIGNALED), Return(gl::NoError())))
+        .WillOnce(DoAll(SetArgumentPointee<1>(GL_UNSIGNALED), Return(angle::Result::Continue())))
+        .WillOnce(DoAll(SetArgumentPointee<1>(GL_SIGNALED), Return(angle::Result::Continue())))
         .RetiresOnSaturation();
     GLint out;
     EXPECT_FALSE(mFence->getStatus(nullptr, &out).isError());

src/libANGLE/renderer/FenceNVImpl.h

@@ -28,9 +28,9 @@ class FenceNVImpl : angle::NonCopyable
     FenceNVImpl() { };
     virtual ~FenceNVImpl() { };
 
-    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;
+    virtual angle::Result set(const gl::Context *context, GLenum condition)        = 0;
+    virtual angle::Result test(const gl::Context *context, GLboolean *outFinished) = 0;
+    virtual angle::Result finish(const gl::Context *context)                       = 0;
 };
 }  // namespace rx
 

src/libANGLE/renderer/SyncImpl.h

@@ -28,15 +28,15 @@ class SyncImpl : angle::NonCopyable
     SyncImpl(){};
     virtual ~SyncImpl(){};
 
-    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;
+    virtual angle::Result set(const gl::Context *context, GLenum condition, GLbitfield flags) = 0;
+    virtual angle::Result clientWait(const gl::Context *context,
+                                     GLbitfield flags,
+                                     GLuint64 timeout,
+                                     GLenum *outResult)                                       = 0;
+    virtual angle::Result serverWait(const gl::Context *context,
+                                     GLbitfield flags,
+                                     GLuint64 timeout)                                        = 0;
+    virtual angle::Result getStatus(const gl::Context *context, GLint *outResult)             = 0;
 };
 }  // namespace rx
 

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

@@ -72,17 +72,17 @@ FenceNV11::~FenceNV11()
     SafeRelease(mQuery);
 }
 
-gl::Error FenceNV11::set(const gl::Context *context, GLenum condition)
+angle::Result FenceNV11::set(const gl::Context *context, GLenum condition)
 {
     return FenceSetHelper(context, this);
 }
 
-gl::Error FenceNV11::test(const gl::Context *context, GLboolean *outFinished)
+angle::Result FenceNV11::test(const gl::Context *context, GLboolean *outFinished)
 {
     return FenceTestHelper(context, this, true, outFinished);
 }
 
-gl::Error FenceNV11::finish(const gl::Context *context)
+angle::Result FenceNV11::finish(const gl::Context *context)
 {
     GLboolean finished = GL_FALSE;
 
@@ -95,13 +95,14 @@ gl::Error FenceNV11::finish(const gl::Context *context)
         bool checkDeviceLost = (loopCount % kPollingD3DDeviceLostCheckFrequency) == 0;
         if (checkDeviceLost && mRenderer->testDeviceLost())
         {
-            return gl::OutOfMemory() << "Device was lost while querying result of an event query.";
+            ANGLE_TRY_HR(GetImplAs<Context11>(context), DXGI_ERROR_DRIVER_INTERNAL_ERROR,
+                         "Device was lost while querying result of an event query.");
         }
 
         ScheduleYield();
     }
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 //
@@ -133,39 +134,36 @@ Sync11::~Sync11()
     SafeRelease(mQuery);
 }
 
-gl::Error Sync11::set(const gl::Context *context, GLenum condition, GLbitfield flags)
+angle::Result Sync11::set(const gl::Context *context, GLenum condition, GLbitfield flags)
 {
     ASSERT(condition == GL_SYNC_GPU_COMMANDS_COMPLETE && flags == 0);
     return FenceSetHelper(context, this);
 }
 
-gl::Error Sync11::clientWait(const gl::Context *context,
-                             GLbitfield flags,
-                             GLuint64 timeout,
-                             GLenum *outResult)
+angle::Result Sync11::clientWait(const gl::Context *context,
+                                 GLbitfield flags,
+                                 GLuint64 timeout,
+                                 GLenum *outResult)
 {
     ASSERT(outResult);
 
     bool flushCommandBuffer = ((flags & GL_SYNC_FLUSH_COMMANDS_BIT) != 0);
 
+    *outResult = GL_WAIT_FAILED;
+
     GLboolean result = GL_FALSE;
-    gl::Error error  = FenceTestHelper(context, this, flushCommandBuffer, &result);
-    if (error.isError())
-    {
-        *outResult = GL_WAIT_FAILED;
-        return error;
-    }
+    ANGLE_TRY(FenceTestHelper(context, this, flushCommandBuffer, &result));
 
     if (result == GL_TRUE)
     {
         *outResult = GL_ALREADY_SIGNALED;
-        return gl::NoError();
+        return angle::Result::Continue();
     }
 
     if (timeout == 0)
     {
         *outResult = GL_TIMEOUT_EXPIRED;
-        return gl::NoError();
+        return angle::Result::Continue();
     }
 
     LARGE_INTEGER currentCounter = {};
@@ -189,18 +187,16 @@ gl::Error Sync11::clientWait(const gl::Context *context,
         success = QueryPerformanceCounter(&currentCounter);
         ASSERT(success);
 
-        error = FenceTestHelper(context, this, flushCommandBuffer, &result);
-        if (error.isError())
-        {
-            *outResult = GL_WAIT_FAILED;
-            return error;
-        }
+        *outResult = GL_WAIT_FAILED;
+
+        ANGLE_TRY(FenceTestHelper(context, this, flushCommandBuffer, &result));
 
         bool checkDeviceLost = (loopCount % kPollingD3DDeviceLostCheckFrequency) == 0;
         if (checkDeviceLost && mRenderer->testDeviceLost())
         {
             *outResult = GL_WAIT_FAILED;
-            return gl::OutOfMemory() << "Device was lost while querying result of an event query.";
+            ANGLE_TRY_HR(GetImplAs<Context11>(context), DXGI_ERROR_DRIVER_INTERNAL_ERROR,
+                         "Device was lost while querying result of an event query.");
         }
     }
 
@@ -213,32 +209,28 @@ gl::Error Sync11::clientWait(const gl::Context *context,
         *outResult = GL_CONDITION_SATISFIED;
     }
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error Sync11::serverWait(const gl::Context *context, GLbitfield flags, GLuint64 timeout)
+angle::Result 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
     // always be processed after the fence is signaled.
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error Sync11::getStatus(const gl::Context *context, GLint *outResult)
+angle::Result Sync11::getStatus(const gl::Context *context, GLint *outResult)
 {
     GLboolean result = GL_FALSE;
-    angle::Result error = FenceTestHelper(context, this, false, &result);
-    if (error == angle::Result::Stop())
-    {
-        // The spec does not specify any way to report errors during the status test (e.g. device
-        // lost) so we report the fence is unblocked in case of error or signaled.
-        *outResult = GL_SIGNALED;
 
-        return error;
-    }
+    // The spec does not specify any way to report errors during the status test (e.g. device
+    // lost) so we report the fence is unblocked in case of error or signaled.
+    *outResult = GL_SIGNALED;
+    ANGLE_TRY(FenceTestHelper(context, this, false, &result));
 
     *outResult = (result ? GL_SIGNALED : GL_UNSIGNALED);
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 }  // namespace rx

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

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

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

@@ -25,7 +25,7 @@ FenceNV9::~FenceNV9()
     SafeRelease(mQuery);
 }
 
-gl::Error FenceNV9::set(const gl::Context *context, GLenum condition)
+angle::Result FenceNV9::set(const gl::Context *context, GLenum condition)
 {
     if (!mQuery)
     {
@@ -35,20 +35,18 @@ gl::Error FenceNV9::set(const gl::Context *context, GLenum condition)
     HRESULT result = mQuery->Issue(D3DISSUE_END);
     if (FAILED(result))
     {
-        ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
         SafeRelease(mQuery);
-        return gl::OutOfMemory() << "Failed to end event query, " << gl::FmtHR(result);
     }
-
-    return gl::NoError();
+    ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to end event query");
+    return angle::Result::Continue();
 }
 
-gl::Error FenceNV9::test(const gl::Context *context, GLboolean *outFinished)
+angle::Result FenceNV9::test(const gl::Context *context, GLboolean *outFinished)
 {
     return testHelper(GetImplAs<Context9>(context), true, outFinished);
 }
 
-gl::Error FenceNV9::finish(const gl::Context *context)
+angle::Result FenceNV9::finish(const gl::Context *context)
 {
     GLboolean finished = GL_FALSE;
     while (finished != GL_TRUE)
@@ -57,7 +55,7 @@ gl::Error FenceNV9::finish(const gl::Context *context)
         Sleep(0);
     }
 
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 angle::Result FenceNV9::testHelper(Context9 *context9,

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

@@ -23,9 +23,9 @@ class FenceNV9 : public FenceNVImpl
     explicit FenceNV9(Renderer9 *renderer);
     ~FenceNV9() 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;
+    angle::Result set(const gl::Context *context, GLenum condition) override;
+    angle::Result test(const gl::Context *context, GLboolean *outFinished) override;
+    angle::Result finish(const gl::Context *context) override;
 
   private:
     angle::Result testHelper(Context9 *context9, bool flushCommandBuffer, GLboolean *outFinished);

src/libANGLE/renderer/gl/FenceNVGL.cpp

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

src/libANGLE/renderer/gl/FenceNVGL.h

@@ -21,9 +21,9 @@ class FenceNVGL : public FenceNVImpl
     explicit FenceNVGL(const FunctionsGL *functions);
     ~FenceNVGL() 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;
+    angle::Result set(const gl::Context *context, GLenum condition) override;
+    angle::Result test(const gl::Context *context, GLboolean *outFinished) override;
+    angle::Result finish(const gl::Context *context) override;
 
   private:
     GLuint mFence;

src/libANGLE/renderer/gl/SyncGL.cpp

@@ -9,6 +9,8 @@
 #include "libANGLE/renderer/gl/SyncGL.h"
 
 #include "common/debug.h"
+#include "libANGLE/Context.h"
+#include "libANGLE/renderer/gl/ContextGL.h"
 #include "libANGLE/renderer/gl/FunctionsGL.h"
 
 namespace rx
@@ -27,40 +29,36 @@ SyncGL::~SyncGL()
     }
 }
 
-gl::Error SyncGL::set(const gl::Context *context, GLenum condition, GLbitfield flags)
+angle::Result SyncGL::set(const gl::Context *context, GLenum condition, GLbitfield flags)
 {
     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::OutOfMemory() << "glFenceSync failed to create a GLsync object.";
-    }
-
-    return gl::NoError();
+    ANGLE_CHECK(GetImplAs<ContextGL>(context), mSyncObject != 0,
+                "glFenceSync failed to create a GLsync object.", GL_OUT_OF_MEMORY);
+    return angle::Result::Continue();
 }
 
-gl::Error SyncGL::clientWait(const gl::Context *context,
-                             GLbitfield flags,
-                             GLuint64 timeout,
-                             GLenum *outResult)
+angle::Result SyncGL::clientWait(const gl::Context *context,
+                                 GLbitfield flags,
+                                 GLuint64 timeout,
+                                 GLenum *outResult)
 {
     ASSERT(mSyncObject != 0);
     *outResult = mFunctions->clientWaitSync(mSyncObject, flags, timeout);
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error SyncGL::serverWait(const gl::Context *context, GLbitfield flags, GLuint64 timeout)
+angle::Result SyncGL::serverWait(const gl::Context *context, GLbitfield flags, GLuint64 timeout)
 {
     ASSERT(mSyncObject != 0);
     mFunctions->waitSync(mSyncObject, flags, timeout);
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error SyncGL::getStatus(const gl::Context *context, GLint *outResult)
+angle::Result SyncGL::getStatus(const gl::Context *context, GLint *outResult)
 {
     ASSERT(mSyncObject != 0);
     mFunctions->getSynciv(mSyncObject, GL_SYNC_STATUS, 1, nullptr, outResult);
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 }

src/libANGLE/renderer/gl/SyncGL.h

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

src/libANGLE/renderer/null/FenceNVNULL.cpp

@@ -22,20 +22,20 @@ FenceNVNULL::~FenceNVNULL()
 {
 }
 
-gl::Error FenceNVNULL::set(const gl::Context *context, GLenum condition)
+angle::Result FenceNVNULL::set(const gl::Context *context, GLenum condition)
 {
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error FenceNVNULL::test(const gl::Context *context, GLboolean *outFinished)
+angle::Result FenceNVNULL::test(const gl::Context *context, GLboolean *outFinished)
 {
     *outFinished = GL_TRUE;
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
-gl::Error FenceNVNULL::finish(const gl::Context *context)
+angle::Result FenceNVNULL::finish(const gl::Context *context)
 {
-    return gl::NoError();
+    return angle::Result::Continue();
 }
 
 }  // namespace rx

src/libANGLE/renderer/null/FenceNVNULL.h

@@ -20,9 +20,9 @@ class FenceNVNULL : public FenceNVImpl
     FenceNVNULL();
     ~FenceNVNULL() 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;
+    angle::Result set(const gl::Context *context, GLenum condition) override;
+    angle::Result test(const gl::Context *context, GLboolean *outFinished) override;
+    angle::Result finish(const gl::Context *context) override;
 };
 }  // namespace rx
 

src/libANGLE/renderer/null/SyncNULL.cpp

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

src/libANGLE/renderer/null/SyncNULL.h

@@ -20,13 +20,15 @@ class SyncNULL : public SyncImpl
     SyncNULL();
     ~SyncNULL() 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;
+    angle::Result set(const gl::Context *context, GLenum condition, GLbitfield flags) override;
+    angle::Result clientWait(const gl::Context *context,
+                             GLbitfield flags,
+                             GLuint64 timeout,
+                             GLenum *outResult) override;
+    angle::Result serverWait(const gl::Context *context,
+                             GLbitfield flags,
+                             GLuint64 timeout) override;
+    angle::Result getStatus(const gl::Context *context, GLint *outResult) override;
 };
 }  // namespace rx
 

src/libANGLE/renderer/vulkan/FenceNVVk.cpp

@@ -10,6 +10,9 @@
 #include "libANGLE/renderer/vulkan/FenceNVVk.h"
 
 #include "common/debug.h"
+#include "libANGLE/Context.h"
+#include "libANGLE/renderer/vulkan/ContextVk.h"
+#include "libANGLE/renderer/vulkan/vk_utils.h"
 
 namespace rx
 {
@@ -22,22 +25,22 @@ FenceNVVk::~FenceNVVk()
 {
 }
 
-gl::Error FenceNVVk::set(const gl::Context *context, GLenum condition)
+angle::Result FenceNVVk::set(const gl::Context *context, GLenum condition)
 {
-    UNIMPLEMENTED();
-    return gl::InternalError();
+    ANGLE_VK_UNREACHABLE(vk::GetImpl(context));
+    return angle::Result::Stop();
 }
 
-gl::Error FenceNVVk::test(const gl::Context *context, GLboolean *outFinished)
+angle::Result FenceNVVk::test(const gl::Context *context, GLboolean *outFinished)
 {
-    UNIMPLEMENTED();
-    return gl::InternalError();
+    ANGLE_VK_UNREACHABLE(vk::GetImpl(context));
+    return angle::Result::Stop();
 }
 
-gl::Error FenceNVVk::finish(const gl::Context *context)
+angle::Result FenceNVVk::finish(const gl::Context *context)
 {
-    UNIMPLEMENTED();
-    return gl::InternalError();
+    ANGLE_VK_UNREACHABLE(vk::GetImpl(context));
+    return angle::Result::Stop();
 }
 
 }  // namespace rx

src/libANGLE/renderer/vulkan/FenceNVVk.h

@@ -20,9 +20,9 @@ class FenceNVVk : public FenceNVImpl
     FenceNVVk();
     ~FenceNVVk() 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;
+    angle::Result set(const gl::Context *context, GLenum condition) override;
+    angle::Result test(const gl::Context *context, GLboolean *outFinished) override;
+    angle::Result finish(const gl::Context *context) override;
 };
 }  // namespace rx
 

src/libANGLE/renderer/vulkan/SyncVk.cpp

@@ -10,6 +10,9 @@
 #include "libANGLE/renderer/vulkan/SyncVk.h"
 
 #include "common/debug.h"
+#include "libANGLE/Context.h"
+#include "libANGLE/renderer/vulkan/ContextVk.h"
+#include "libANGLE/renderer/vulkan/vk_utils.h"
 
 namespace rx
 {
@@ -22,31 +25,31 @@ SyncVk::~SyncVk()
 {
 }
 
-gl::Error SyncVk::set(const gl::Context *context, GLenum condition, GLbitfield flags)
+angle::Result SyncVk::set(const gl::Context *context, GLenum condition, GLbitfield flags)
 {
-    UNIMPLEMENTED();
-    return gl::InternalError();
+    ANGLE_VK_UNREACHABLE(vk::GetImpl(context));
+    return angle::Result::Stop();
 }
 
-gl::Error SyncVk::clientWait(const gl::Context *context,
-                             GLbitfield flags,
-                             GLuint64 timeout,
-                             GLenum *outResult)
+angle::Result SyncVk::clientWait(const gl::Context *context,
+                                 GLbitfield flags,
+                                 GLuint64 timeout,
+                                 GLenum *outResult)
 {
-    UNIMPLEMENTED();
-    return gl::InternalError();
+    ANGLE_VK_UNREACHABLE(vk::GetImpl(context));
+    return angle::Result::Stop();
 }
 
-gl::Error SyncVk::serverWait(const gl::Context *context, GLbitfield flags, GLuint64 timeout)
+angle::Result SyncVk::serverWait(const gl::Context *context, GLbitfield flags, GLuint64 timeout)
 {
-    UNIMPLEMENTED();
-    return gl::InternalError();
+    ANGLE_VK_UNREACHABLE(vk::GetImpl(context));
+    return angle::Result::Stop();
 }
 
-gl::Error SyncVk::getStatus(const gl::Context *context, GLint *outResult)
+angle::Result SyncVk::getStatus(const gl::Context *context, GLint *outResult)
 {
-    UNIMPLEMENTED();
-    return gl::InternalError();
+    ANGLE_VK_UNREACHABLE(vk::GetImpl(context));
+    return angle::Result::Stop();
 }
 
 }  // namespace rx

src/libANGLE/renderer/vulkan/SyncVk.h

@@ -20,13 +20,15 @@ class SyncVk : public SyncImpl
     SyncVk();
     ~SyncVk() 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;
+    angle::Result set(const gl::Context *context, GLenum condition, GLbitfield flags) override;
+    angle::Result clientWait(const gl::Context *context,
+                             GLbitfield flags,
+                             GLuint64 timeout,
+                             GLenum *outResult) override;
+    angle::Result serverWait(const gl::Context *context,
+                             GLbitfield flags,
+                             GLuint64 timeout) override;
+    angle::Result getStatus(const gl::Context *context, GLint *outResult) override;
 };
 }  // namespace rx