Add gl::RenderbufferState shared state helper.

src/libANGLE/Image_unittest.cpp

@@ -54,7 +54,8 @@ TEST(ImageTest, RefCounting)
 
     // Create a renderbuffer and set it as a target of the EGL image
     rx::MockRenderbufferImpl *renderbufferImpl = new rx::MockRenderbufferImpl();
-    gl::Renderbuffer *renderbuffer = new gl::Renderbuffer(renderbufferImpl, 1);
+    EXPECT_CALL(mockGLFactory, createRenderbuffer(_)).WillOnce(Return(renderbufferImpl));
+    gl::Renderbuffer *renderbuffer = new gl::Renderbuffer(&mockGLFactory, 1);
     renderbuffer->addRef();
 
     EXPECT_CALL(*renderbufferImpl, setStorageEGLImageTarget(_, _))

src/libANGLE/Renderbuffer.cpp

@@ -13,21 +13,63 @@
 #include "common/utilities.h"
 #include "libANGLE/FramebufferAttachment.h"
 #include "libANGLE/Image.h"
+#include "libANGLE/Renderbuffer.h"
 #include "libANGLE/Texture.h"
 #include "libANGLE/formatutils.h"
+#include "libANGLE/renderer/GLImplFactory.h"
 #include "libANGLE/renderer/d3d/RenderTargetD3D.h"
 
 namespace gl
 {
-Renderbuffer::Renderbuffer(rx::RenderbufferImpl *impl, GLuint id)
+// RenderbufferState implementation.
+RenderbufferState::RenderbufferState()
+    : mWidth(0), mHeight(0), mFormat(GL_RGBA4), mSamples(0), mInitState(InitState::MayNeedInit)
+{
+}
+
+RenderbufferState::~RenderbufferState()
+{
+}
+
+GLsizei RenderbufferState::getWidth() const
+{
+    return mWidth;
+}
+
+GLsizei RenderbufferState::getHeight() const
+{
+    return mHeight;
+}
+
+const Format &RenderbufferState::getFormat() const
+{
+    return mFormat;
+}
+
+GLsizei RenderbufferState::getSamples() const
+{
+    return mSamples;
+}
+
+void RenderbufferState::update(GLsizei width,
+                               GLsizei height,
+                               const Format &format,
+                               GLsizei samples,
+                               InitState initState)
+{
+    mWidth     = static_cast<GLsizei>(width);
+    mHeight    = static_cast<GLsizei>(height);
+    mFormat    = format;
+    mSamples   = samples;
+    mInitState = InitState::MayNeedInit;
+}
+
+// Renderbuffer implementation.
+Renderbuffer::Renderbuffer(rx::GLImplFactory *implFactory, GLuint id)
     : egl::ImageSibling(id),
-      mRenderbuffer(impl),
-      mLabel(),
-      mWidth(0),
-      mHeight(0),
-      mFormat(GL_RGBA4),
-      mSamples(0),
-      mInitState(InitState::MayNeedInit)
+      mState(),
+      mImplementation(implFactory->createRenderbuffer(mState)),
+      mLabel()
 {
 }
 
@@ -35,9 +77,9 @@ Error Renderbuffer::onDestroy(const Context *context)
 {
     ANGLE_TRY(orphanImages(context));
 
-    if (mRenderbuffer)
+    if (mImplementation)
     {
-        ANGLE_TRY(mRenderbuffer->onDestroy(context));
+        ANGLE_TRY(mImplementation->onDestroy(context));
     }
 
     return NoError();
@@ -45,7 +87,6 @@ Error Renderbuffer::onDestroy(const Context *context)
 
 Renderbuffer::~Renderbuffer()
 {
-    SafeDelete(mRenderbuffer);
 }
 
 void Renderbuffer::setLabel(const std::string &label)
@@ -64,16 +105,11 @@ Error Renderbuffer::setStorage(const Context *context,
                                size_t height)
 {
     ANGLE_TRY(orphanImages(context));
+    ANGLE_TRY(mImplementation->setStorage(context, internalformat, width, height));
 
-    ANGLE_TRY(mRenderbuffer->setStorage(context, internalformat, width, height));
-
-    mWidth          = static_cast<GLsizei>(width);
-    mHeight         = static_cast<GLsizei>(height);
-    mFormat         = Format(internalformat);
-    mSamples = 0;
-
-    mInitState = InitState::MayNeedInit;
-    mDirtyChannel.signal(mInitState);
+    mState.update(static_cast<GLsizei>(width), static_cast<GLsizei>(height), Format(internalformat),
+                  0, InitState::MayNeedInit);
+    mDirtyChannel.signal(mState.mInitState);
 
     return NoError();
 }
@@ -85,17 +121,12 @@ Error Renderbuffer::setStorageMultisample(const Context *context,
                                           size_t height)
 {
     ANGLE_TRY(orphanImages(context));
-
     ANGLE_TRY(
-        mRenderbuffer->setStorageMultisample(context, samples, internalformat, width, height));
-
-    mWidth          = static_cast<GLsizei>(width);
-    mHeight         = static_cast<GLsizei>(height);
-    mFormat         = Format(internalformat);
-    mSamples        = static_cast<GLsizei>(samples);
+        mImplementation->setStorageMultisample(context, samples, internalformat, width, height));
 
-    mInitState = InitState::MayNeedInit;
-    mDirtyChannel.signal(mInitState);
+    mState.update(static_cast<GLsizei>(width), static_cast<GLsizei>(height), Format(internalformat),
+                  static_cast<GLsizei>(samples), InitState::MayNeedInit);
+    mDirtyChannel.signal(mState.mInitState);
 
     return NoError();
 }
@@ -103,76 +134,71 @@ Error Renderbuffer::setStorageMultisample(const Context *context,
 Error Renderbuffer::setStorageEGLImageTarget(const Context *context, egl::Image *image)
 {
     ANGLE_TRY(orphanImages(context));
-
-    ANGLE_TRY(mRenderbuffer->setStorageEGLImageTarget(context, image));
+    ANGLE_TRY(mImplementation->setStorageEGLImageTarget(context, image));
 
     setTargetImage(context, image);
 
-    mWidth          = static_cast<GLsizei>(image->getWidth());
-    mHeight         = static_cast<GLsizei>(image->getHeight());
-    mFormat         = Format(image->getFormat());
-    mSamples        = 0;
-
-    mInitState = image->sourceInitState();
-    mDirtyChannel.signal(mInitState);
+    mState.update(static_cast<GLsizei>(image->getWidth()), static_cast<GLsizei>(image->getHeight()),
+                  Format(image->getFormat()), 0, image->sourceInitState());
+    mDirtyChannel.signal(mState.mInitState);
 
     return NoError();
 }
 
 rx::RenderbufferImpl *Renderbuffer::getImplementation() const
 {
-    ASSERT(mRenderbuffer);
-    return mRenderbuffer;
+    ASSERT(mImplementation);
+    return mImplementation.get();
 }
 
 GLsizei Renderbuffer::getWidth() const
 {
-    return mWidth;
+    return mState.mWidth;
 }
 
 GLsizei Renderbuffer::getHeight() const
 {
-    return mHeight;
+    return mState.mHeight;
 }
 
 const Format &Renderbuffer::getFormat() const
 {
-    return mFormat;
+    return mState.mFormat;
 }
 
 GLsizei Renderbuffer::getSamples() const
 {
-    return mSamples;
+    return mState.mSamples;
 }
 
 GLuint Renderbuffer::getRedSize() const
 {
-    return mFormat.info->redBits;
+    return mState.mFormat.info->redBits;
 }
 
 GLuint Renderbuffer::getGreenSize() const
 {
-    return mFormat.info->greenBits;
+    return mState.mFormat.info->greenBits;
 }
 
 GLuint Renderbuffer::getBlueSize() const
 {
-    return mFormat.info->blueBits;
+    return mState.mFormat.info->blueBits;
 }
 
 GLuint Renderbuffer::getAlphaSize() const
 {
-    return mFormat.info->alphaBits;
+    return mState.mFormat.info->alphaBits;
 }
 
 GLuint Renderbuffer::getDepthSize() const
 {
-    return mFormat.info->depthBits;
+    return mState.mFormat.info->depthBits;
 }
 
 GLuint Renderbuffer::getStencilSize() const
 {
-    return mFormat.info->stencilBits;
+    return mState.mFormat.info->stencilBits;
 }
 
 void Renderbuffer::onAttach(const Context *context)
@@ -192,7 +218,7 @@ GLuint Renderbuffer::getId() const
 
 Extents Renderbuffer::getAttachmentSize(const gl::ImageIndex & /*imageIndex*/) const
 {
-    return Extents(mWidth, mHeight, 1);
+    return Extents(mState.mWidth, mState.mHeight, 1);
 }
 
 const Format &Renderbuffer::getAttachmentFormat(GLenum /*binding*/,
@@ -212,7 +238,7 @@ InitState Renderbuffer::initState(const gl::ImageIndex & /*imageIndex*/) const
         return sourceEGLImageInitState();
     }
 
-    return mInitState;
+    return mState.mInitState;
 }
 
 void Renderbuffer::setInitState(const gl::ImageIndex & /*imageIndex*/, InitState initState)
@@ -223,13 +249,13 @@ void Renderbuffer::setInitState(const gl::ImageIndex & /*imageIndex*/, InitState
     }
     else
     {
-        mInitState = initState;
+        mState.mInitState = initState;
     }
 }
 
 rx::FramebufferAttachmentObjectImpl *Renderbuffer::getAttachmentImpl() const
 {
-    return mRenderbuffer;
+    return mImplementation.get();
 }
 
 }  // namespace gl

src/libANGLE/Renderbuffer.h

@@ -20,6 +20,11 @@
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/RenderbufferImpl.h"
 
+namespace rx
+{
+class GLImplFactory;
+}  // namespace rx
+
 namespace gl
 {
 // A GL renderbuffer object is usually used as a depth or stencil buffer attachment
@@ -27,11 +32,40 @@ namespace gl
 // FramebufferAttachment and Framebuffer for how they are applied to an FBO via an
 // attachment point.
 
+class RenderbufferState final : angle::NonCopyable
+{
+  public:
+    RenderbufferState();
+    ~RenderbufferState();
+
+    GLsizei getWidth() const;
+    GLsizei getHeight() const;
+    const Format &getFormat() const;
+    GLsizei getSamples() const;
+
+  private:
+    friend class Renderbuffer;
+
+    void update(GLsizei width,
+                GLsizei height,
+                const Format &format,
+                GLsizei samples,
+                InitState initState);
+
+    GLsizei mWidth;
+    GLsizei mHeight;
+    Format mFormat;
+    GLsizei mSamples;
+
+    // For robust resource init.
+    InitState mInitState;
+};
+
 class Renderbuffer final : public egl::ImageSibling,
                            public LabeledObject
 {
   public:
-    Renderbuffer(rx::RenderbufferImpl *impl, GLuint id);
+    Renderbuffer(rx::GLImplFactory *implFactory, GLuint id);
     ~Renderbuffer() override;
 
     Error onDestroy(const Context *context) override;
@@ -75,17 +109,10 @@ class Renderbuffer final : public egl::ImageSibling,
   private:
     rx::FramebufferAttachmentObjectImpl *getAttachmentImpl() const override;
 
-    rx::RenderbufferImpl *mRenderbuffer;
+    RenderbufferState mState;
+    std::unique_ptr<rx::RenderbufferImpl> mImplementation;
 
     std::string mLabel;
-
-    GLsizei mWidth;
-    GLsizei mHeight;
-    Format mFormat;
-    GLsizei mSamples;
-
-    // For robust resource init.
-    InitState mInitState;
 };
 
 }  // namespace gl

src/libANGLE/ResourceManager.cpp

@@ -270,7 +270,7 @@ void TextureManager::enableHandleAllocatorLogging()
 // static
 Renderbuffer *RenderbufferManager::AllocateNewObject(rx::GLImplFactory *factory, GLuint handle)
 {
-    Renderbuffer *renderbuffer = new Renderbuffer(factory->createRenderbuffer(), handle);
+    Renderbuffer *renderbuffer = new Renderbuffer(factory, handle);
     renderbuffer->addRef();
     return renderbuffer;
 }

src/libANGLE/ResourceManager_unittest.cpp

@@ -63,7 +63,7 @@ TEST_F(ResourceManagerTest, ReallocateBoundBuffer)
 
 TEST_F(ResourceManagerTest, ReallocateBoundRenderbuffer)
 {
-    EXPECT_CALL(mMockFactory, createRenderbuffer()).Times(1).RetiresOnSaturation();
+    EXPECT_CALL(mMockFactory, createRenderbuffer(_)).Times(1).RetiresOnSaturation();
 
     mRenderbuffermanager->checkRenderbufferAllocation(&mMockFactory, 1);
     GLuint newRenderbuffer = mRenderbuffermanager->createRenderbuffer();

src/libANGLE/renderer/GLImplFactory.h

@@ -62,7 +62,7 @@ class GLImplFactory : angle::NonCopyable
     virtual TextureImpl *createTexture(const gl::TextureState &state) = 0;
 
     // Renderbuffer creation
-    virtual RenderbufferImpl *createRenderbuffer() = 0;
+    virtual RenderbufferImpl *createRenderbuffer(const gl::RenderbufferState &state) = 0;
 
     // Buffer creation
     virtual BufferImpl *createBuffer(const gl::BufferState &state) = 0;

src/libANGLE/renderer/RenderbufferImpl.h

@@ -14,10 +14,15 @@
 #include "libANGLE/Error.h"
 #include "libANGLE/renderer/FramebufferAttachmentObjectImpl.h"
 
+namespace gl
+{
+class RenderbufferState;
+}  // namespace gl
+
 namespace egl
 {
 class Image;
-}
+}  // namespace egl
 
 namespace rx
 {
@@ -25,7 +30,7 @@ namespace rx
 class RenderbufferImpl : public FramebufferAttachmentObjectImpl
 {
   public:
-    RenderbufferImpl() {}
+    RenderbufferImpl(const gl::RenderbufferState &state) : mState(state) {}
     ~RenderbufferImpl() override {}
     virtual gl::Error onDestroy(const gl::Context *context);
 
@@ -39,12 +44,15 @@ class RenderbufferImpl : public FramebufferAttachmentObjectImpl
                                             size_t width,
                                             size_t height) = 0;
     virtual gl::Error setStorageEGLImageTarget(const gl::Context *context, egl::Image *image) = 0;
+
+  protected:
+    const gl::RenderbufferState &mState;
 };
 
 inline gl::Error RenderbufferImpl::onDestroy(const gl::Context *context)
 {
     return gl::NoError();
 }
-}
+}  // namespace rx
 
 #endif   // LIBANGLE_RENDERER_RENDERBUFFERIMPL_H_

src/libANGLE/renderer/RenderbufferImpl_mock.h

@@ -12,6 +12,7 @@
 #include "gmock/gmock.h"
 
 #include "libANGLE/Image.h"
+#include "libANGLE/Renderbuffer.h"
 #include "libANGLE/renderer/RenderbufferImpl.h"
 
 namespace rx
@@ -20,6 +21,7 @@ namespace rx
 class MockRenderbufferImpl : public RenderbufferImpl
 {
   public:
+    MockRenderbufferImpl() : RenderbufferImpl(mMockState) {}
     virtual ~MockRenderbufferImpl() { destructor(); }
     MOCK_METHOD4(setStorage, gl::Error(const gl::Context *, GLenum, size_t, size_t));
     MOCK_METHOD5(setStorageMultisample,
@@ -33,8 +35,11 @@ class MockRenderbufferImpl : public RenderbufferImpl
                            FramebufferAttachmentRenderTarget **));
 
     MOCK_METHOD0(destructor, void());
+
+  protected:
+    gl::RenderbufferState mMockState;
 };
 
-}
+}  // namespace rx
 
 #endif // LIBANGLE_RENDERER_RENDERBUFFERIMPLMOCK_H_

src/libANGLE/renderer/d3d/RenderbufferD3D.cpp

@@ -16,8 +16,8 @@
 
 namespace rx
 {
-RenderbufferD3D::RenderbufferD3D(RendererD3D *renderer)
-    : mRenderer(renderer), mRenderTarget(nullptr), mImage(nullptr)
+RenderbufferD3D::RenderbufferD3D(const gl::RenderbufferState &state, RendererD3D *renderer)
+    : RenderbufferImpl(state), mRenderer(renderer), mRenderTarget(nullptr), mImage(nullptr)
 {
 }
 

src/libANGLE/renderer/d3d/RenderbufferD3D.h

@@ -24,7 +24,7 @@ class SwapChainD3D;
 class RenderbufferD3D : public RenderbufferImpl
 {
   public:
-    RenderbufferD3D(RendererD3D *renderer);
+    RenderbufferD3D(const gl::RenderbufferState &state, RendererD3D *renderer);
     ~RenderbufferD3D() override;
 
     gl::Error onDestroy(const gl::Context *context) override;

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

@@ -95,9 +95,9 @@ TextureImpl *Context11::createTexture(const gl::TextureState &state)
     return nullptr;
 }
 
-RenderbufferImpl *Context11::createRenderbuffer()
+RenderbufferImpl *Context11::createRenderbuffer(const gl::RenderbufferState &state)
 {
-    return new RenderbufferD3D(mRenderer);
+    return new RenderbufferD3D(state, mRenderer);
 }
 
 BufferImpl *Context11::createBuffer(const gl::BufferState &state)

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

@@ -36,7 +36,7 @@ class Context11 : public ContextImpl
     TextureImpl *createTexture(const gl::TextureState &state) override;
 
     // Renderbuffer creation
-    RenderbufferImpl *createRenderbuffer() override;
+    RenderbufferImpl *createRenderbuffer(const gl::RenderbufferState &state) override;
 
     // Buffer creation
     BufferImpl *createBuffer(const gl::BufferState &state) override;

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

@@ -77,9 +77,9 @@ TextureImpl *Context9::createTexture(const gl::TextureState &state)
     return nullptr;
 }
 
-RenderbufferImpl *Context9::createRenderbuffer()
+RenderbufferImpl *Context9::createRenderbuffer(const gl::RenderbufferState &state)
 {
-    return new RenderbufferD3D(mRenderer);
+    return new RenderbufferD3D(state, mRenderer);
 }
 
 BufferImpl *Context9::createBuffer(const gl::BufferState &state)

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

@@ -36,7 +36,7 @@ class Context9 : public ContextImpl
     TextureImpl *createTexture(const gl::TextureState &state) override;
 
     // Renderbuffer creation
-    RenderbufferImpl *createRenderbuffer() override;
+    RenderbufferImpl *createRenderbuffer(const gl::RenderbufferState &state) override;
 
     // Buffer creation
     BufferImpl *createBuffer(const gl::BufferState &state) override;

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

@@ -1181,7 +1181,7 @@ gl::Error Renderer9::getNullColorbuffer(const gl::Context *context,
 
     auto *implFactory = context->getImplementation();
 
-    gl::Renderbuffer *nullRenderbuffer = new gl::Renderbuffer(implFactory->createRenderbuffer(), 0);
+    gl::Renderbuffer *nullRenderbuffer = new gl::Renderbuffer(implFactory, 0);
     gl::Error error = nullRenderbuffer->setStorage(context, GL_NONE, size.width, size.height);
     if (error.isError())
     {

src/libANGLE/renderer/gl/ContextGL.cpp

@@ -75,9 +75,9 @@ TextureImpl *ContextGL::createTexture(const gl::TextureState &state)
                          mRenderer->getBlitter());
 }
 
-RenderbufferImpl *ContextGL::createRenderbuffer()
+RenderbufferImpl *ContextGL::createRenderbuffer(const gl::RenderbufferState &state)
 {
-    return new RenderbufferGL(getFunctions(), getWorkaroundsGL(), getStateManager(),
+    return new RenderbufferGL(state, getFunctions(), getWorkaroundsGL(), getStateManager(),
                               getNativeTextureCaps());
 }
 

src/libANGLE/renderer/gl/ContextGL.h

@@ -44,7 +44,7 @@ class ContextGL : public ContextImpl
     TextureImpl *createTexture(const gl::TextureState &state) override;
 
     // Renderbuffer creation
-    RenderbufferImpl *createRenderbuffer() override;
+    RenderbufferImpl *createRenderbuffer(const gl::RenderbufferState &state) override;
 
     // Buffer creation
     BufferImpl *createBuffer(const gl::BufferState &state) override;

src/libANGLE/renderer/gl/RenderbufferGL.cpp

@@ -18,11 +18,12 @@
 
 namespace rx
 {
-RenderbufferGL::RenderbufferGL(const FunctionsGL *functions,
+RenderbufferGL::RenderbufferGL(const gl::RenderbufferState &state,
+                               const FunctionsGL *functions,
                                const WorkaroundsGL &workarounds,
                                StateManagerGL *stateManager,
                                const gl::TextureCapsMap &textureCaps)
-    : RenderbufferImpl(),
+    : RenderbufferImpl(state),
       mFunctions(functions),
       mWorkarounds(workarounds),
       mStateManager(stateManager),

src/libANGLE/renderer/gl/RenderbufferGL.h

@@ -26,7 +26,8 @@ struct WorkaroundsGL;
 class RenderbufferGL : public RenderbufferImpl
 {
   public:
-    RenderbufferGL(const FunctionsGL *functions,
+    RenderbufferGL(const gl::RenderbufferState &state,
+                   const FunctionsGL *functions,
                    const WorkaroundsGL &workarounds,
                    StateManagerGL *stateManager,
                    const gl::TextureCapsMap &textureCaps);

src/libANGLE/renderer/null/ContextNULL.cpp

@@ -352,9 +352,9 @@ TextureImpl *ContextNULL::createTexture(const gl::TextureState &state)
     return new TextureNULL(state);
 }
 
-RenderbufferImpl *ContextNULL::createRenderbuffer()
+RenderbufferImpl *ContextNULL::createRenderbuffer(const gl::RenderbufferState &state)
 {
-    return new RenderbufferNULL();
+    return new RenderbufferNULL(state);
 }
 
 BufferImpl *ContextNULL::createBuffer(const gl::BufferState &state)

src/libANGLE/renderer/null/ContextNULL.h

@@ -169,7 +169,7 @@ class ContextNULL : public ContextImpl
     TextureImpl *createTexture(const gl::TextureState &state) override;
 
     // Renderbuffer creation
-    RenderbufferImpl *createRenderbuffer() override;
+    RenderbufferImpl *createRenderbuffer(const gl::RenderbufferState &state) override;
 
     // Buffer creation
     BufferImpl *createBuffer(const gl::BufferState &state) override;

src/libANGLE/renderer/null/RenderbufferNULL.cpp

@@ -14,7 +14,7 @@
 namespace rx
 {
 
-RenderbufferNULL::RenderbufferNULL() : RenderbufferImpl()
+RenderbufferNULL::RenderbufferNULL(const gl::RenderbufferState &state) : RenderbufferImpl(state)
 {
 }
 

src/libANGLE/renderer/null/RenderbufferNULL.h

@@ -18,7 +18,7 @@ namespace rx
 class RenderbufferNULL : public RenderbufferImpl
 {
   public:
-    RenderbufferNULL();
+    RenderbufferNULL(const gl::RenderbufferState &state);
     ~RenderbufferNULL() override;
 
     gl::Error setStorage(const gl::Context *context,

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -709,9 +709,9 @@ TextureImpl *ContextVk::createTexture(const gl::TextureState &state)
     return new TextureVk(state);
 }
 
-RenderbufferImpl *ContextVk::createRenderbuffer()
+RenderbufferImpl *ContextVk::createRenderbuffer(const gl::RenderbufferState &state)
 {
-    return new RenderbufferVk();
+    return new RenderbufferVk(state);
 }
 
 BufferImpl *ContextVk::createBuffer(const gl::BufferState &state)

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -115,7 +115,7 @@ class ContextVk : public ContextImpl
     TextureImpl *createTexture(const gl::TextureState &state) override;
 
     // Renderbuffer creation
-    RenderbufferImpl *createRenderbuffer() override;
+    RenderbufferImpl *createRenderbuffer(const gl::RenderbufferState &state) override;
 
     // Buffer creation
     BufferImpl *createBuffer(const gl::BufferState &state) override;

src/libANGLE/renderer/vulkan/RenderbufferVk.cpp

@@ -16,7 +16,8 @@
 namespace rx
 {
 
-RenderbufferVk::RenderbufferVk() : RenderbufferImpl(), mRequiredSize(0)
+RenderbufferVk::RenderbufferVk(const gl::RenderbufferState &state)
+    : RenderbufferImpl(state), mRequiredSize(0)
 {
 }
 

src/libANGLE/renderer/vulkan/RenderbufferVk.h

@@ -20,7 +20,7 @@ namespace rx
 class RenderbufferVk : public RenderbufferImpl, public ResourceVk
 {
   public:
-    RenderbufferVk();
+    RenderbufferVk(const gl::RenderbufferState &state);
     ~RenderbufferVk() override;
 
     gl::Error onDestroy(const gl::Context *context) override;

src/tests/angle_unittests_utils.h

@@ -38,7 +38,10 @@ class NullFactory : public GLImplFactory
     TextureImpl *createTexture(const gl::TextureState &data) override { return nullptr; }
 
     // Renderbuffer creation
-    RenderbufferImpl *createRenderbuffer() override { return nullptr; }
+    RenderbufferImpl *createRenderbuffer(const gl::RenderbufferState &state) override
+    {
+        return nullptr;
+    }
 
     // Buffer creation
     BufferImpl *createBuffer(const gl::BufferState &state) override { return nullptr; }
@@ -86,7 +89,7 @@ class MockGLFactory : public GLImplFactory
     MOCK_METHOD1(createProgramPipeline, ProgramPipelineImpl *(const gl::ProgramPipelineState &));
     MOCK_METHOD1(createFramebuffer, FramebufferImpl *(const gl::FramebufferState &));
     MOCK_METHOD1(createTexture, TextureImpl *(const gl::TextureState &));
-    MOCK_METHOD0(createRenderbuffer, RenderbufferImpl *());
+    MOCK_METHOD1(createRenderbuffer, RenderbufferImpl *(const gl::RenderbufferState &));
     MOCK_METHOD1(createBuffer, BufferImpl *(const gl::BufferState &));
     MOCK_METHOD1(createVertexArray, VertexArrayImpl *(const gl::VertexArrayState &));
     MOCK_METHOD1(createQuery, QueryImpl *(GLenum type));