Refactor ResourceManagers.

src/libANGLE/Context.cpp

@@ -616,7 +616,7 @@ void Context::deleteBuffer(GLuint buffer)
         detachBuffer(buffer);
     }
 
-    mState.mBuffers->deleteBuffer(buffer);
+    mState.mBuffers->deleteObject(buffer);
 }
 
 void Context::deleteShader(GLuint shader)
@@ -636,7 +636,7 @@ void Context::deleteTexture(GLuint texture)
         detachTexture(texture);
     }
 
-    mState.mTextures->deleteTexture(texture);
+    mState.mTextures->deleteObject(texture);
 }
 
 void Context::deleteRenderbuffer(GLuint renderbuffer)
@@ -646,7 +646,7 @@ void Context::deleteRenderbuffer(GLuint renderbuffer)
         detachRenderbuffer(renderbuffer);
     }
 
-    mState.mRenderbuffers->deleteRenderbuffer(renderbuffer);
+    mState.mRenderbuffers->deleteObject(renderbuffer);
 }
 
 void Context::deleteFenceSync(GLsync fenceSync)
@@ -655,8 +655,7 @@ void Context::deleteFenceSync(GLsync fenceSync)
     // 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.
-    mState.mFenceSyncs->deleteFenceSync(
-        static_cast<GLuint>(reinterpret_cast<uintptr_t>(fenceSync)));
+    mState.mFenceSyncs->deleteObject(static_cast<GLuint>(reinterpret_cast<uintptr_t>(fenceSync)));
 }
 
 void Context::deletePaths(GLuint first, GLsizei range)
@@ -773,7 +772,7 @@ void Context::deleteSampler(GLuint sampler)
         detachSampler(sampler);
     }
 
-    mState.mSamplers->deleteSampler(sampler);
+    mState.mSamplers->deleteObject(sampler);
 }
 
 void Context::deleteTransformFeedback(GLuint transformFeedback)
@@ -800,7 +799,7 @@ void Context::deleteFramebuffer(GLuint framebuffer)
         detachFramebuffer(framebuffer);
     }
 
-    mState.mFramebuffers->deleteFramebuffer(framebuffer);
+    mState.mFramebuffers->deleteObject(framebuffer);
 }
 
 void Context::deleteFenceNV(GLuint fence)

src/libANGLE/ResourceManager.cpp

@@ -33,37 +33,6 @@ GLuint AllocateEmptyObject(HandleAllocator *handleAllocator, ResourceMap<Resourc
     return handle;
 }
 
-template <typename ResourceType, typename CreationFunction>
-GLuint InsertObject(HandleAllocator *handleAllocator,
-                    ResourceMap<ResourceType> *objectMap,
-                    const CreationFunction &func)
-{
-    GLuint handle        = handleAllocator->allocate();
-    (*objectMap)[handle] = func(handle);
-    return handle;
-}
-
-template <typename ResourceType, typename DeletionFunction>
-void DeleteObject(HandleAllocator *handleAllocator,
-                  ResourceMap<ResourceType> *objectMap,
-                  GLuint handle,
-                  const DeletionFunction &deletionFunc)
-{
-    auto objectIter = objectMap->find(handle);
-    if (objectIter == objectMap->end())
-    {
-        return;
-    }
-
-    if (objectIter->second != nullptr)
-    {
-        deletionFunc(objectIter->second);
-    }
-
-    handleAllocator->release(objectIter->first);
-    objectMap->erase(objectIter);
-}
-
 template <typename ResourceType>
 ResourceType *GetObject(const ResourceMap<ResourceType> &objectMap, GLuint handle)
 {
@@ -93,8 +62,8 @@ void ResourceManagerBase<HandleAllocatorType>::release()
     }
 }
 
-template <typename ResourceType, typename HandleAllocatorType>
-TypedResourceManager<ResourceType, HandleAllocatorType>::~TypedResourceManager()
+template <typename ResourceType, typename HandleAllocatorType, typename ImplT>
+TypedResourceManager<ResourceType, HandleAllocatorType, ImplT>::~TypedResourceManager()
 {
     while (!mObjectMap.empty())
     {
@@ -102,73 +71,114 @@ TypedResourceManager<ResourceType, HandleAllocatorType>::~TypedResourceManager()
     }
 }
 
-template <typename ResourceType, typename HandleAllocatorType>
-void TypedResourceManager<ResourceType, HandleAllocatorType>::deleteObject(GLuint handle)
+template <typename ResourceType, typename HandleAllocatorType, typename ImplT>
+void TypedResourceManager<ResourceType, HandleAllocatorType, ImplT>::deleteObject(GLuint handle)
 {
-    DeleteObject(&this->mHandleAllocator, &mObjectMap, handle,
-                 [](ResourceType *object) { object->release(); });
-}
-
-// Instantiations of ResourceManager
-template class ResourceManagerBase<HandleAllocator>;
-template class ResourceManagerBase<HandleRangeAllocator>;
-template class TypedResourceManager<Buffer, HandleAllocator>;
-template class TypedResourceManager<Texture, HandleAllocator>;
-template class TypedResourceManager<Renderbuffer, HandleAllocator>;
-template class TypedResourceManager<Sampler, HandleAllocator>;
-template class TypedResourceManager<FenceSync, HandleAllocator>;
-
-GLuint BufferManager::createBuffer()
-{
-    return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
-}
-
-void BufferManager::deleteBuffer(GLuint buffer)
-{
-    deleteObject(buffer);
-}
-
-Buffer *BufferManager::getBuffer(GLuint handle) const
-{
-    return GetObject(mObjectMap, handle);
-}
-
-Buffer *BufferManager::checkBufferAllocation(rx::GLImplFactory *factory, GLuint handle)
-{
-    if (handle == 0)
+    auto objectIter = mObjectMap.find(handle);
+    if (objectIter == mObjectMap.end())
     {
-        return nullptr;
+        return;
     }
 
-    auto objectMapIter   = mObjectMap.find(handle);
-    bool handleAllocated = (objectMapIter != mObjectMap.end());
-
-    if (handleAllocated && objectMapIter->second != nullptr)
+    if (objectIter->second != nullptr)
     {
-        return objectMapIter->second;
+        ImplT::DeleteObject(objectIter->second);
     }
 
-    Buffer *object = new Buffer(factory, handle);
-    object->addRef();
+    // Requires an explicit this-> because of C++ template rules.
+    this->mHandleAllocator.release(objectIter->first);
+    mObjectMap.erase(objectIter);
+}
+
+template <typename ResourceType, typename HandleAllocatorType, typename ImplT>
+template <typename... ArgTypes>
+ResourceType *TypedResourceManager<ResourceType, HandleAllocatorType, ImplT>::allocateObject(
+    typename ResourceMap<ResourceType>::iterator &objectMapIter,
+    rx::GLImplFactory *factory,
+    GLuint handle,
+    ArgTypes... args)
+{
+    ResourceType *object = ImplT::AllocateNewObject(factory, handle, args...);
 
-    if (handleAllocated)
+    if (objectMapIter != mObjectMap.end())
     {
         objectMapIter->second = object;
     }
     else
     {
-        mHandleAllocator.reserve(handle);
+        this->mHandleAllocator.reserve(handle);
         mObjectMap[handle] = object;
     }
 
     return object;
 }
 
+template class ResourceManagerBase<HandleAllocator>;
+template class ResourceManagerBase<HandleRangeAllocator>;
+template class TypedResourceManager<Buffer, HandleAllocator, BufferManager>;
+template Buffer *TypedResourceManager<Buffer, HandleAllocator, BufferManager>::allocateObject(
+    ResourceMap<Buffer>::iterator &,
+    rx::GLImplFactory *,
+    GLuint);
+template class TypedResourceManager<Texture, HandleAllocator, TextureManager>;
+template Texture *TypedResourceManager<Texture, HandleAllocator, TextureManager>::allocateObject(
+    ResourceMap<Texture>::iterator &,
+    rx::GLImplFactory *,
+    GLuint,
+    GLenum);
+template class TypedResourceManager<Renderbuffer, HandleAllocator, RenderbufferManager>;
+template Renderbuffer *
+TypedResourceManager<Renderbuffer, HandleAllocator, RenderbufferManager>::allocateObject(
+    ResourceMap<Renderbuffer>::iterator &,
+    rx::GLImplFactory *,
+    GLuint);
+template class TypedResourceManager<Sampler, HandleAllocator, SamplerManager>;
+template Sampler *TypedResourceManager<Sampler, HandleAllocator, SamplerManager>::allocateObject(
+    ResourceMap<Sampler>::iterator &,
+    rx::GLImplFactory *,
+    GLuint);
+template class TypedResourceManager<FenceSync, HandleAllocator, FenceSyncManager>;
+template class TypedResourceManager<Framebuffer, HandleAllocator, FramebufferManager>;
+template Framebuffer *
+TypedResourceManager<Framebuffer, HandleAllocator, FramebufferManager>::allocateObject(
+    ResourceMap<Framebuffer>::iterator &,
+    rx::GLImplFactory *,
+    GLuint,
+    const Caps &);
+
+// BufferManager Implementation.
+
+// static
+Buffer *BufferManager::AllocateNewObject(rx::GLImplFactory *factory, GLuint handle)
+{
+    Buffer *buffer = new Buffer(factory, handle);
+    buffer->addRef();
+    return buffer;
+}
+
+// static
+void BufferManager::DeleteObject(Buffer *buffer)
+{
+    buffer->release();
+}
+
+GLuint BufferManager::createBuffer()
+{
+    return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
+}
+
+Buffer *BufferManager::getBuffer(GLuint handle) const
+{
+    return GetObject(mObjectMap, handle);
+}
+
 bool BufferManager::isBufferGenerated(GLuint buffer) const
 {
     return buffer == 0 || mObjectMap.find(buffer) != mObjectMap.end();
 }
 
+// ShaderProgramManager Implementation.
+
 ShaderProgramManager::~ShaderProgramManager()
 {
     while (!mPrograms.empty())
@@ -240,14 +250,25 @@ void ShaderProgramManager::deleteObject(ResourceMap<ObjectType> *objectMap, GLui
     }
 }
 
-GLuint TextureManager::createTexture()
+// TextureManager Implementation.
+
+// static
+Texture *TextureManager::AllocateNewObject(rx::GLImplFactory *factory, GLuint handle, GLenum target)
 {
-    return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
+    Texture *texture = new Texture(factory, handle, target);
+    texture->addRef();
+    return texture;
 }
 
-void TextureManager::deleteTexture(GLuint texture)
+// static
+void TextureManager::DeleteObject(Texture *texture)
 {
-    deleteObject(texture);
+    texture->release();
+}
+
+GLuint TextureManager::createTexture()
+{
+    return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
 }
 
 Texture *TextureManager::getTexture(GLuint handle) const
@@ -256,42 +277,25 @@ Texture *TextureManager::getTexture(GLuint handle) const
     return GetObject(mObjectMap, handle);
 }
 
-Texture *TextureManager::checkTextureAllocation(rx::GLImplFactory *factory,
-                                                GLuint handle,
-                                                GLenum type)
+bool TextureManager::isTextureGenerated(GLuint texture) const
 {
-    if (handle == 0)
-    {
-        return nullptr;
-    }
-
-    auto objectMapIter   = mObjectMap.find(handle);
-    bool handleAllocated = (objectMapIter != mObjectMap.end());
-
-    if (handleAllocated && objectMapIter->second != nullptr)
-    {
-        return objectMapIter->second;
-    }
-
-    Texture *object = new Texture(factory, handle, type);
-    object->addRef();
+    return texture == 0 || mObjectMap.find(texture) != mObjectMap.end();
+}
 
-    if (handleAllocated)
-    {
-        objectMapIter->second = object;
-    }
-    else
-    {
-        mHandleAllocator.reserve(handle);
-        mObjectMap[handle] = object;
-    }
+// RenderbufferManager Implementation.
 
-    return object;
+// static
+Renderbuffer *RenderbufferManager::AllocateNewObject(rx::GLImplFactory *factory, GLuint handle)
+{
+    Renderbuffer *renderbuffer = new Renderbuffer(factory->createRenderbuffer(), handle);
+    renderbuffer->addRef();
+    return renderbuffer;
 }
 
-bool TextureManager::isTextureGenerated(GLuint texture) const
+// static
+void RenderbufferManager::DeleteObject(Renderbuffer *renderbuffer)
 {
-    return texture == 0 || mObjectMap.find(texture) != mObjectMap.end();
+    renderbuffer->release();
 }
 
 GLuint RenderbufferManager::createRenderbuffer()
@@ -299,51 +303,30 @@ GLuint RenderbufferManager::createRenderbuffer()
     return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
 }
 
-void RenderbufferManager::deleteRenderbuffer(GLuint renderbuffer)
-{
-    deleteObject(renderbuffer);
-}
-
 Renderbuffer *RenderbufferManager::getRenderbuffer(GLuint handle)
 {
     return GetObject(mObjectMap, handle);
 }
 
-Renderbuffer *RenderbufferManager::checkRenderbufferAllocation(rx::GLImplFactory *factory,
-                                                               GLuint handle)
+bool RenderbufferManager::isRenderbufferGenerated(GLuint renderbuffer) const
 {
-    if (handle == 0)
-    {
-        return nullptr;
-    }
-
-    auto objectMapIter   = mObjectMap.find(handle);
-    bool handleAllocated = (objectMapIter != mObjectMap.end());
-
-    if (handleAllocated && objectMapIter->second != nullptr)
-    {
-        return objectMapIter->second;
-    }
+    return renderbuffer == 0 || mObjectMap.find(renderbuffer) != mObjectMap.end();
+}
 
-    Renderbuffer *object = new Renderbuffer(factory->createRenderbuffer(), handle);
-    object->addRef();
+// SamplerManager Implementation.
 
-    if (handleAllocated)
-    {
-        objectMapIter->second = object;
-    }
-    else
-    {
-        mHandleAllocator.reserve(handle);
-        mObjectMap[handle] = object;
-    }
-
-    return object;
+// static
+Sampler *SamplerManager::AllocateNewObject(rx::GLImplFactory *factory, GLuint handle)
+{
+    Sampler *sampler = new Sampler(factory, handle);
+    sampler->addRef();
+    return sampler;
 }
 
-bool RenderbufferManager::isRenderbufferGenerated(GLuint renderbuffer) const
+// static
+void SamplerManager::DeleteObject(Sampler *sampler)
 {
-    return renderbuffer == 0 || mObjectMap.find(renderbuffer) != mObjectMap.end();
+    sampler->release();
 }
 
 GLuint SamplerManager::createSampler()
@@ -351,74 +334,31 @@ GLuint SamplerManager::createSampler()
     return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
 }
 
-void SamplerManager::deleteSampler(GLuint sampler)
-{
-    deleteObject(sampler);
-}
-
 Sampler *SamplerManager::getSampler(GLuint handle)
 {
     return GetObject(mObjectMap, handle);
 }
 
-Sampler *SamplerManager::checkSamplerAllocation(rx::GLImplFactory *factory, GLuint handle)
+bool SamplerManager::isSampler(GLuint sampler)
 {
-    if (handle == 0)
-    {
-        return nullptr;
-    }
-
-    auto objectMapIter   = mObjectMap.find(handle);
-    bool handleAllocated = (objectMapIter != mObjectMap.end());
-
-    if (handleAllocated && objectMapIter->second != nullptr)
-    {
-        return objectMapIter->second;
-    }
-
-    Sampler *object = new Sampler(factory, handle);
-    object->addRef();
-
-    if (handleAllocated)
-    {
-        objectMapIter->second = object;
-    }
-    else
-    {
-        mHandleAllocator.reserve(handle);
-        mObjectMap[handle] = object;
-    }
-
-    return object;
+    return mObjectMap.find(sampler) != mObjectMap.end();
 }
 
-bool SamplerManager::isSampler(GLuint sampler)
+// FenceSyncManager Implementation.
+
+// static
+void FenceSyncManager::DeleteObject(FenceSync *fenceSync)
 {
-    return mObjectMap.find(sampler) != mObjectMap.end();
+    fenceSync->release();
 }
 
 GLuint FenceSyncManager::createFenceSync(rx::GLImplFactory *factory)
 {
-    struct fenceSyncAllocator
-    {
-        fenceSyncAllocator(rx::GLImplFactory *factory) : factory(factory) {}
-
-        rx::GLImplFactory *factory;
-
-        FenceSync *operator()(GLuint handle) const
-        {
+    GLuint handle        = mHandleAllocator.allocate();
     FenceSync *fenceSync = new FenceSync(factory->createFenceSync(), handle);
     fenceSync->addRef();
-            return fenceSync;
-        }
-    };
-
-    return InsertObject(&mHandleAllocator, &mObjectMap, fenceSyncAllocator(factory));
-}
-
-void FenceSyncManager::deleteFenceSync(GLuint fenceSync)
-{
-    deleteObject(fenceSync);
+    mObjectMap[handle] = fenceSync;
+    return handle;
 }
 
 FenceSync *FenceSyncManager::getFenceSync(GLuint handle)
@@ -426,6 +366,8 @@ FenceSync *FenceSyncManager::getFenceSync(GLuint handle)
     return GetObject(mObjectMap, handle);
 }
 
+// PathManager Implementation.
+
 ErrorOrResult<GLuint> PathManager::createPaths(rx::GLImplFactory *factory, GLsizei range)
 {
     // Allocate client side handles.
@@ -485,70 +427,46 @@ PathManager::~PathManager()
     }
 }
 
-FramebufferManager::~FramebufferManager()
-{
-    for (auto framebuffer : mFramebuffers)
-    {
-        // Default framebuffer are owned by their respective Surface
-        if (framebuffer.second != nullptr && framebuffer.second->id() != 0)
-        {
-            SafeDelete(framebuffer.second);
-        }
-    }
-}
+// FramebufferManager Implementation.
 
-GLuint FramebufferManager::createFramebuffer()
+// static
+Framebuffer *FramebufferManager::AllocateNewObject(rx::GLImplFactory *factory,
+                                                   GLuint handle,
+                                                   const Caps &caps)
 {
-    return AllocateEmptyObject(&mHandleAllocator, &mFramebuffers);
+    return new Framebuffer(caps, factory, handle);
 }
 
-void FramebufferManager::deleteFramebuffer(GLuint framebuffer)
+// static
+void FramebufferManager::DeleteObject(Framebuffer *framebuffer)
 {
-    DeleteObject(&mHandleAllocator, &mFramebuffers, framebuffer, [](Framebuffer *framebuffer) {
-        ASSERT(framebuffer->id() != 0);
+    // Default framebuffer are owned by their respective Surface
+    if (framebuffer->id() != 0)
+    {
         delete framebuffer;
-    });
+    }
 }
 
-Framebuffer *FramebufferManager::checkFramebufferAllocation(rx::GLImplFactory *factory,
-                                                            const Caps &caps,
-                                                            GLuint handle)
+GLuint FramebufferManager::createFramebuffer()
 {
-    // Can be called from Bind without a prior call to Gen.
-    auto framebufferIt = mFramebuffers.find(handle);
-    bool neverCreated  = framebufferIt == mFramebuffers.end();
-    if (neverCreated || framebufferIt->second == nullptr)
-    {
-        ASSERT(handle != 0);
-        Framebuffer *newFBO = new Framebuffer(caps, factory, handle);
-        if (neverCreated)
-        {
-            mHandleAllocator.reserve(handle);
-            mFramebuffers[handle] = newFBO;
-            return newFBO;
-        }
-
-        framebufferIt->second = newFBO;
-    }
-
-    return framebufferIt->second;
+    return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
 }
 
 Framebuffer *FramebufferManager::getFramebuffer(GLuint handle) const
 {
-    return GetObject(mFramebuffers, handle);
+    return GetObject(mObjectMap, handle);
 }
 
 void FramebufferManager::setDefaultFramebuffer(Framebuffer *framebuffer)
 {
     ASSERT(framebuffer == nullptr || framebuffer->id() == 0);
-    mFramebuffers[0] = framebuffer;
+    mObjectMap[0] = framebuffer;
 }
 
 bool FramebufferManager::isFramebufferGenerated(GLuint framebuffer)
 {
-    ASSERT(mFramebuffers.find(0) != mFramebuffers.end());
-    return mFramebuffers.find(framebuffer) != mFramebuffers.end();
+    ASSERT(mObjectMap.find(0) != mObjectMap.end());
+    return mObjectMap.find(framebuffer) != mObjectMap.end();
 }
 
 }  // namespace gl

src/libANGLE/ResourceManager.h

@@ -54,29 +54,61 @@ class ResourceManagerBase : angle::NonCopyable
     size_t mRefCount;
 };
 
-template <typename ResourceType, typename HandleAllocatorType>
+template <typename ResourceType, typename HandleAllocatorType, typename ImplT>
 class TypedResourceManager : public ResourceManagerBase<HandleAllocatorType>
 {
   public:
     TypedResourceManager() {}
 
+    void deleteObject(GLuint handle);
+
   protected:
     ~TypedResourceManager() override;
 
-    void deleteObject(GLuint handle);
+    // Inlined in the header for performance.
+    template <typename... ArgTypes>
+    ResourceType *checkObjectAllocation(rx::GLImplFactory *factory, GLuint handle, ArgTypes... args)
+    {
+        auto objectMapIter = mObjectMap.find(handle);
+
+        if (objectMapIter != mObjectMap.end() && objectMapIter->second != nullptr)
+        {
+            return objectMapIter->second;
+        }
+
+        if (handle == 0)
+        {
+            return nullptr;
+        }
+
+        return allocateObject<ArgTypes...>(objectMapIter, factory, handle, args...);
+    }
+
+    template <typename... ArgTypes>
+    ResourceType *allocateObject(typename ResourceMap<ResourceType>::iterator &objectMapIter,
+                                 rx::GLImplFactory *factory,
+                                 GLuint handle,
+                                 ArgTypes... args);
 
     ResourceMap<ResourceType> mObjectMap;
 };
 
-class BufferManager : public TypedResourceManager<Buffer, HandleAllocator>
+class BufferManager : public TypedResourceManager<Buffer, HandleAllocator, BufferManager>
 {
   public:
     GLuint createBuffer();
-    void deleteBuffer(GLuint buffer);
     Buffer *getBuffer(GLuint handle) const;
-    Buffer *checkBufferAllocation(rx::GLImplFactory *factory, GLuint handle);
     bool isBufferGenerated(GLuint buffer) const;
 
+    Buffer *checkBufferAllocation(rx::GLImplFactory *factory, GLuint handle)
+    {
+        return checkObjectAllocation(factory, handle);
+    }
+
+    // TODO(jmadill): Investigate design which doesn't expose these methods publicly.
+    static Buffer *AllocateNewObject(rx::GLImplFactory *factory, GLuint handle);
+    static void DeleteObject(Buffer *buffer);
+
   protected:
     ~BufferManager() override {}
 };
@@ -105,52 +137,72 @@ class ShaderProgramManager : public ResourceManagerBase<HandleAllocator>
     ResourceMap<Program> mPrograms;
 };
 
-class TextureManager : public TypedResourceManager<Texture, HandleAllocator>
+class TextureManager : public TypedResourceManager<Texture, HandleAllocator, TextureManager>
 {
   public:
     GLuint createTexture();
-    void deleteTexture(GLuint texture);
     Texture *getTexture(GLuint handle) const;
-    Texture *checkTextureAllocation(rx::GLImplFactory *factory, GLuint handle, GLenum type);
     bool isTextureGenerated(GLuint texture) const;
 
+    Texture *checkTextureAllocation(rx::GLImplFactory *factory, GLuint handle, GLenum target)
+    {
+        return checkObjectAllocation(factory, handle, target);
+    }
+
+    static Texture *AllocateNewObject(rx::GLImplFactory *factory, GLuint handle, GLenum target);
+    static void DeleteObject(Texture *texture);
+
   protected:
     ~TextureManager() override {}
 };
 
-class RenderbufferManager : public TypedResourceManager<Renderbuffer, HandleAllocator>
+class RenderbufferManager
+    : public TypedResourceManager<Renderbuffer, HandleAllocator, RenderbufferManager>
 {
   public:
     GLuint createRenderbuffer();
-    void deleteRenderbuffer(GLuint renderbuffer);
     Renderbuffer *getRenderbuffer(GLuint handle);
-    Renderbuffer *checkRenderbufferAllocation(rx::GLImplFactory *factory, GLuint handle);
     bool isRenderbufferGenerated(GLuint renderbuffer) const;
 
+    Renderbuffer *checkRenderbufferAllocation(rx::GLImplFactory *factory, GLuint handle)
+    {
+        return checkObjectAllocation(factory, handle);
+    }
+
+    static Renderbuffer *AllocateNewObject(rx::GLImplFactory *factory, GLuint handle);
+    static void DeleteObject(Renderbuffer *renderbuffer);
+
   protected:
     ~RenderbufferManager() override {}
 };
 
-class SamplerManager : public TypedResourceManager<Sampler, HandleAllocator>
+class SamplerManager : public TypedResourceManager<Sampler, HandleAllocator, SamplerManager>
 {
   public:
     GLuint createSampler();
-    void deleteSampler(GLuint sampler);
     Sampler *getSampler(GLuint handle);
-    Sampler *checkSamplerAllocation(rx::GLImplFactory *factory, GLuint handle);
     bool isSampler(GLuint sampler);
 
+    Sampler *checkSamplerAllocation(rx::GLImplFactory *factory, GLuint handle)
+    {
+        return checkObjectAllocation(factory, handle);
+    }
+
+    static Sampler *AllocateNewObject(rx::GLImplFactory *factory, GLuint handle);
+    static void DeleteObject(Sampler *sampler);
+
   protected:
     ~SamplerManager() override {}
 };
 
-class FenceSyncManager : public TypedResourceManager<FenceSync, HandleAllocator>
+class FenceSyncManager : public TypedResourceManager<FenceSync, HandleAllocator, FenceSyncManager>
 {
   public:
     GLuint createFenceSync(rx::GLImplFactory *factory);
-    void deleteFenceSync(GLuint fenceSync);
     FenceSync *getFenceSync(GLuint handle);
 
+    static void DeleteObject(FenceSync *fenceSync);
+
   protected:
     ~FenceSyncManager() override {}
 };
@@ -170,23 +222,29 @@ class PathManager : public ResourceManagerBase<HandleRangeAllocator>
     ResourceMap<Path> mPaths;
 };
 
-class FramebufferManager : public ResourceManagerBase<HandleAllocator>
+class FramebufferManager
+    : public TypedResourceManager<Framebuffer, HandleAllocator, FramebufferManager>
 {
   public:
     GLuint createFramebuffer();
-    void deleteFramebuffer(GLuint framebuffer);
-    Framebuffer *checkFramebufferAllocation(rx::GLImplFactory *factory,
-                                            const Caps &caps,
-                                            GLuint handle);
     Framebuffer *getFramebuffer(GLuint handle) const;
     void setDefaultFramebuffer(Framebuffer *framebuffer);
     bool isFramebufferGenerated(GLuint framebuffer);
 
-  protected:
-    ~FramebufferManager() override;
+    Framebuffer *checkFramebufferAllocation(rx::GLImplFactory *factory,
+                                            const Caps &caps,
+                                            GLuint handle)
+    {
+        return checkObjectAllocation<const Caps &>(factory, handle, caps);
+    }
 
-  private:
-    ResourceMap<Framebuffer> mFramebuffers;
+    static Framebuffer *AllocateNewObject(rx::GLImplFactory *factory,
+                                          GLuint handle,
+                                          const Caps &caps);
+    static void DeleteObject(Framebuffer *framebuffer);
+
+  protected:
+    ~FramebufferManager() override {}
 };
 
 }  // namespace gl