C++
GL_APICALL GLsync GL_APIENTRY glFenceSync(GLenum condition, GLbitfield flags)
GL_APICALL void GL_APIENTRY glDeleteSync(GLsync sync)
GL_APICALL GLenum GL_APIENTRY glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)

C++
GL_APICALL GLsync GL_APIENTRY glFenceSync(GLenum condition, GLbitfield flags)

{
        TRACE("(GLenum condition = 0x%X, GLbitfield flags = %X)", condition, flags);

es2::Context *context = es2::getContext();

if(context)
        {
                return context->createFenceSync(condition, flags);
        }

return nullptr;
}

C++
GLsync Context::createFenceSync(GLenum condition, GLbitfield flags)
{
        GLuint handle = mResourceManager->createFenceSync(condition, flags);

return reinterpret_cast<GLsync>(static_cast<uintptr_t>(handle));
}
    GLuint ResourceManager::createFenceSync(GLenum condition, GLbitfield flags)
    {
            GLuint name = mFenceSyncNameSpace.allocate();
   
            FenceSync *fenceSync = new FenceSync(name, condition, flags);
            fenceSync->addRef();
   
            mFenceSyncNameSpace.insert(name, fenceSync);
   
            return name;
    }

C++
GL_APICALL GLenum GL_APIENTRY glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
{
        TRACE("(GLsync sync = %p, GLbitfield flags = %X, GLuint64 timeout = %llu)", sync, flags, timeout);

if((flags & ~(GL_SYNC_FLUSH_COMMANDS_BIT)) != 0)
        {
                error(GL_INVALID_VALUE);
        }

es2::Context *context = es2::getContext();

if(context)
        {
                es2::FenceSync *fenceSyncObject = context->getFenceSync(sync);

if(fenceSyncObject)
                {
                        return fenceSyncObject->clientWait(flags, timeout);
                }
                else
                {
                        return error(GL_INVALID_VALUE, GL_FALSE);
                }
        }

return GL_FALSE;
}

C++
GLenum FenceSync::clientWait(GLbitfield flags, GLuint64 timeout)
{
        // The current assumtion is that no matter where the fence is placed, it is
        // done by the time it is tested, which is similar to Context::flush(), since
        // we don't queue anything without processing it as fast as possible.
        return GL_ALREADY_SIGNALED;
}

C++
GL_APICALL void GL_APIENTRY glDeleteSync(GLsync sync)
{
        TRACE("(GLsync sync = %p)", sync);

es2::Context *context = es2::getContext();

if(context)
        {
                context->deleteFenceSync(sync);
        }
}
    void Context::deleteFenceSync(GLsync fenceSync)
    {
            // The spec specifies the underlying Fence object is not deleted until all current
            // wait commands finish. However, since the name becomes invalid, we cannot query the fence,
            // and since our API is currently designed for being called from a single thread, we can delete
            // the fence immediately.
            mResourceManager->deleteFenceSync(static_cast<GLuint>(reinterpret_cast<uintptr_t>(fenceSync)));
    }
        void ResourceManager::deleteFenceSync(GLuint fenceSync)
        {
                FenceSync *fenceObject = mFenceSyncNameSpace.remove(fenceSync);
       
                if(fenceObject)
                {
                        fenceObject->release();
                }
        }
            void Object::release()
            {
                    if(dereference() == 0)
                    {
                            delete this;
                    }
            }