Use a shared state for egl::Image.

src/libANGLE/Display.cpp

@@ -635,12 +635,10 @@ Error Display::createImage(gl::Context *context,
     }
     ASSERT(sibling != nullptr);
 
-    rx::ImageImpl *imageImpl = mImplementation->createImage(target, sibling, attribs);
-    ASSERT(imageImpl != nullptr);
+    std::unique_ptr<Image> imagePtr(new Image(mImplementation, target, sibling, attribs));
+    ANGLE_TRY(imagePtr->initialize());
 
-    ANGLE_TRY(imageImpl->initialize());
-
-    Image *image = new Image(imageImpl, target, sibling, attribs);
+    Image *image = imagePtr.release();
 
     ASSERT(outImage != nullptr);
     *outImage = image;
@@ -649,7 +647,7 @@ Error Display::createImage(gl::Context *context,
     image->addRef();
     mImageSet.insert(image);
 
-    return egl::Error(EGL_SUCCESS);
+    return egl::NoError();
 }
 
 Error Display::createStream(const AttributeMap &attribs, Stream **outStream)

src/libANGLE/Image.cpp

@@ -14,10 +14,37 @@
 #include "libANGLE/formatutils.h"
 #include "libANGLE/Texture.h"
 #include "libANGLE/Renderbuffer.h"
+#include "libANGLE/renderer/EGLImplFactory.h"
 #include "libANGLE/renderer/ImageImpl.h"
 
 namespace egl
 {
+
+namespace
+{
+gl::ImageIndex GetImageIndex(EGLenum eglTarget, const egl::AttributeMap &attribs)
+{
+    if (eglTarget == EGL_GL_RENDERBUFFER)
+    {
+        return gl::ImageIndex::MakeInvalid();
+    }
+
+    GLenum target = egl_gl::EGLImageTargetToGLTextureTarget(eglTarget);
+    GLint mip     = static_cast<GLint>(attribs.get(EGL_GL_TEXTURE_LEVEL_KHR, 0));
+    GLint layer   = static_cast<GLint>(attribs.get(EGL_GL_TEXTURE_ZOFFSET_KHR, 0));
+
+    if (target == GL_TEXTURE_3D)
+    {
+        return gl::ImageIndex::Make3D(mip, layer);
+    }
+    else
+    {
+        ASSERT(layer == 0);
+        return gl::ImageIndex::MakeGeneric(target, mip);
+    }
+}
+}  // anonymous namespace
+
 ImageSibling::ImageSibling(GLuint id) : RefCountObject(id), mSourcesOf(), mTargetOf()
 {
 }
@@ -44,23 +71,14 @@ gl::Error ImageSibling::orphanImages()
         // Can't be a target and have sources.
         ASSERT(mSourcesOf.empty());
 
-        gl::Error error = mTargetOf->orphanSibling(this);
-        if (error.isError())
-        {
-            return error;
-        }
-
+        ANGLE_TRY(mTargetOf->orphanSibling(this));
         mTargetOf.set(nullptr);
     }
     else
     {
         for (auto &sourceImage : mSourcesOf)
         {
-            gl::Error error = sourceImage->orphanSibling(this);
-            if (error.isError())
-            {
-                return error;
-            }
+            ANGLE_TRY(sourceImage->orphanSibling(this));
         }
         mSourcesOf.clear();
     }
@@ -80,25 +98,32 @@ void ImageSibling::removeImageSource(egl::Image *imageSource)
     mSourcesOf.erase(imageSource);
 }
 
-Image::Image(rx::ImageImpl *impl, EGLenum target, ImageSibling *buffer, const AttributeMap &attribs)
+ImageState::ImageState(EGLenum target, ImageSibling *buffer, const AttributeMap &attribs)
+    : imageIndex(GetImageIndex(target, attribs)), source(), targets()
+{
+    source.set(buffer);
+}
+
+Image::Image(rx::EGLImplFactory *factory,
+             EGLenum target,
+             ImageSibling *buffer,
+             const AttributeMap &attribs)
     : RefCountObject(0),
-      mImplementation(impl),
+      mState(target, buffer, attribs),
+      mImplementation(factory->createImage(mState, target, attribs)),
       mFormat(gl::Format::Invalid()),
       mWidth(0),
       mHeight(0),
-      mSamples(0),
-      mSource(),
-      mTargets()
+      mSamples(0)
 {
     ASSERT(mImplementation != nullptr);
     ASSERT(buffer != nullptr);
 
-    mSource.set(buffer);
-    mSource->addImageSource(this);
+    mState.source->addImageSource(this);
 
     if (IsTextureTarget(target))
     {
-        gl::Texture *texture = rx::GetAs<gl::Texture>(mSource.get());
+        gl::Texture *texture = rx::GetAs<gl::Texture>(mState.source.get());
         GLenum textureTarget = egl_gl::EGLImageTargetToGLTextureTarget(target);
         size_t level         = attribs.get(EGL_GL_TEXTURE_LEVEL_KHR, 0);
         mFormat              = texture->getFormat(textureTarget, level);
@@ -108,7 +133,7 @@ Image::Image(rx::ImageImpl *impl, EGLenum target, ImageSibling *buffer, const At
     }
     else if (IsRenderbufferTarget(target))
     {
-        gl::Renderbuffer *renderbuffer = rx::GetAs<gl::Renderbuffer>(mSource.get());
+        gl::Renderbuffer *renderbuffer = rx::GetAs<gl::Renderbuffer>(mState.source.get());
         mFormat                        = renderbuffer->getFormat();
         mWidth                         = renderbuffer->getWidth();
         mHeight                        = renderbuffer->getHeight();
@@ -126,39 +151,38 @@ Image::~Image()
 
     // All targets should hold a ref to the egl image and it should not be deleted until there are
     // no siblings left.
-    ASSERT(mTargets.empty());
+    ASSERT(mState.targets.empty());
 
     // Tell the source that it is no longer used by this image
-    if (mSource.get() != nullptr)
+    if (mState.source.get() != nullptr)
     {
-        mSource->removeImageSource(this);
-        mSource.set(nullptr);
+        mState.source->removeImageSource(this);
+        mState.source.set(nullptr);
     }
 }
 
 void Image::addTargetSibling(ImageSibling *sibling)
 {
-    mTargets.insert(sibling);
+    mState.targets.insert(sibling);
 }
 
 gl::Error Image::orphanSibling(ImageSibling *sibling)
 {
     // notify impl
-    gl::Error error = mImplementation->orphan(sibling);
+    ANGLE_TRY(mImplementation->orphan(sibling));
 
-    if (mSource.get() == sibling)
+    if (mState.source.get() == sibling)
     {
         // If the sibling is the source, it cannot be a target.
-        ASSERT(mTargets.find(sibling) == mTargets.end());
-
-        mSource.set(nullptr);
+        ASSERT(mState.targets.find(sibling) == mState.targets.end());
+        mState.source.set(nullptr);
     }
     else
     {
-        mTargets.erase(sibling);
+        mState.targets.erase(sibling);
     }
 
-    return error;
+    return gl::NoError();
 }
 
 const gl::Format &Image::getFormat() const
@@ -181,13 +205,14 @@ size_t Image::getSamples() const
     return mSamples;
 }
 
-rx::ImageImpl *Image::getImplementation()
+rx::ImageImpl *Image::getImplementation() const
 {
     return mImplementation;
 }
 
-const rx::ImageImpl *Image::getImplementation() const
+Error Image::initialize()
 {
-    return mImplementation;
+    return mImplementation->initialize();
 }
+
 }  // namespace egl

src/libANGLE/Image.h

@@ -12,6 +12,7 @@
 #include "common/angleutils.h"
 #include "libANGLE/AttributeMap.h"
 #include "libANGLE/Error.h"
+#include "libANGLE/ImageIndex.h"
 #include "libANGLE/RefCountObject.h"
 #include "libANGLE/formatutils.h"
 
@@ -19,6 +20,7 @@
 
 namespace rx
 {
+class EGLImplFactory;
 class ImageImpl;
 }
 
@@ -52,10 +54,22 @@ class ImageSibling : public RefCountObject
     BindingPointer<Image> mTargetOf;
 };
 
+struct ImageState : angle::NonCopyable
+{
+    ImageState(EGLenum target, ImageSibling *buffer, const AttributeMap &attribs);
+
+    gl::ImageIndex imageIndex;
+    BindingPointer<ImageSibling> source;
+    std::set<ImageSibling *> targets;
+};
+
 class Image final : public RefCountObject
 {
   public:
-    Image(rx::ImageImpl *impl, EGLenum target, ImageSibling *buffer, const AttributeMap &attribs);
+    Image(rx::EGLImplFactory *factory,
+          EGLenum target,
+          ImageSibling *buffer,
+          const AttributeMap &attribs);
     ~Image();
 
     const gl::Format &getFormat() const;
@@ -63,8 +77,9 @@ class Image final : public RefCountObject
     size_t getHeight() const;
     size_t getSamples() const;
 
-    rx::ImageImpl *getImplementation();
-    const rx::ImageImpl *getImplementation() const;
+    Error initialize();
+
+    rx::ImageImpl *getImplementation() const;
 
   private:
     friend class ImageSibling;
@@ -77,16 +92,15 @@ class Image final : public RefCountObject
     // been respecified and state tracking should be updated.
     gl::Error orphanSibling(ImageSibling *sibling);
 
+    ImageState mState;
+
     rx::ImageImpl *mImplementation;
 
     gl::Format mFormat;
     size_t mWidth;
     size_t mHeight;
     size_t mSamples;
-
-    BindingPointer<ImageSibling> mSource;
-    std::set<ImageSibling *> mTargets;
 };
-}
+}  // namespace egl
 
 #endif  // LIBANGLE_IMAGE_H_

src/libANGLE/Image_unittest.cpp

@@ -22,24 +22,35 @@ using ::testing::Return;
 
 namespace angle
 {
+ACTION(CreateMockImageImpl)
+{
+    return new rx::MockImageImpl(arg0, arg1, arg2);
+}
+
 // Verify ref counts are maintained between images and their siblings when objects are deleted
 TEST(ImageTest, RefCounting)
 {
-    NiceMock<rx::MockGLFactory> mockFactory;
+    NiceMock<rx::MockGLFactory> mockGLFactory;
+    NiceMock<rx::MockEGLFactory> mockEGLFactory;
+
     // Create a texture and an EGL image that uses the texture as its source
     rx::MockTextureImpl *textureImpl = new rx::MockTextureImpl();
-    EXPECT_CALL(mockFactory, createTexture(_)).WillOnce(Return(textureImpl));
-    gl::Texture *texture = new gl::Texture(&mockFactory, 1, GL_TEXTURE_2D);
+    EXPECT_CALL(mockGLFactory, createTexture(_)).WillOnce(Return(textureImpl));
+    gl::Texture *texture = new gl::Texture(&mockGLFactory, 1, GL_TEXTURE_2D);
     texture->addRef();
 
-    rx::MockImageImpl *imageImpl = new rx::MockImageImpl();
-    egl::Image *image = new egl::Image(imageImpl, EGL_GL_TEXTURE_2D, texture, egl::AttributeMap());
+    EXPECT_CALL(mockEGLFactory, createImage(_, _, _))
+        .WillOnce(CreateMockImageImpl())
+        .RetiresOnSaturation();
+
+    egl::Image *image =
+        new egl::Image(&mockEGLFactory, EGL_GL_TEXTURE_2D, texture, egl::AttributeMap());
     image->addRef();
 
     // Verify that the image added a ref to the texture and the texture has not added a ref to the
     // image
-    EXPECT_EQ(texture->getRefCount(), 2u);
-    EXPECT_EQ(image->getRefCount(), 1u);
+    EXPECT_EQ(2u, texture->getRefCount());
+    EXPECT_EQ(1u, image->getRefCount());
 
     // Create a renderbuffer and set it as a target of the EGL image
     rx::MockRenderbufferImpl *renderbufferImpl = new rx::MockRenderbufferImpl();
@@ -53,25 +64,26 @@ TEST(ImageTest, RefCounting)
 
     // Verify that the renderbuffer added a ref to the image and the image did not add a ref to
     // the renderbuffer
-    EXPECT_EQ(texture->getRefCount(), 2u);
-    EXPECT_EQ(image->getRefCount(), 2u);
-    EXPECT_EQ(renderbuffer->getRefCount(), 1u);
+    EXPECT_EQ(2u, texture->getRefCount());
+    EXPECT_EQ(2u, image->getRefCount());
+    EXPECT_EQ(1u, renderbuffer->getRefCount());
 
     // Simulate deletion of the texture and verify that it still exists because the image holds a
     // ref
     texture->release();
-    EXPECT_EQ(texture->getRefCount(), 1u);
-    EXPECT_EQ(image->getRefCount(), 2u);
-    EXPECT_EQ(renderbuffer->getRefCount(), 1u);
+    EXPECT_EQ(1u, texture->getRefCount());
+    EXPECT_EQ(2u, image->getRefCount());
+    EXPECT_EQ(1u, renderbuffer->getRefCount());
 
     // Simulate deletion of the image and verify that it still exists because the renderbuffer holds
     // a ref
     image->release();
-    EXPECT_EQ(texture->getRefCount(), 1u);
-    EXPECT_EQ(image->getRefCount(), 1u);
-    EXPECT_EQ(renderbuffer->getRefCount(), 1u);
+    EXPECT_EQ(1u, texture->getRefCount());
+    EXPECT_EQ(1u, image->getRefCount());
+    EXPECT_EQ(1u, renderbuffer->getRefCount());
 
     // Simulate deletion of the renderbuffer and verify that the deletion cascades to all objects
+    rx::MockImageImpl *imageImpl = static_cast<rx::MockImageImpl *>(image->getImplementation());
     EXPECT_CALL(*imageImpl, destructor()).Times(1).RetiresOnSaturation();
     EXPECT_CALL(*imageImpl, orphan(_)).WillOnce(Return(gl::NoError())).RetiresOnSaturation();
 
@@ -84,11 +96,13 @@ TEST(ImageTest, RefCounting)
 // Verify that respecifiying textures releases references to the Image.
 TEST(ImageTest, RespecificationReleasesReferences)
 {
-    NiceMock<rx::MockGLFactory> mockFactory;
+    NiceMock<rx::MockGLFactory> mockGLFactory;
+    NiceMock<rx::MockEGLFactory> mockEGLFactory;
+
     // Create a texture and an EGL image that uses the texture as its source
     rx::MockTextureImpl *textureImpl = new rx::MockTextureImpl();
-    EXPECT_CALL(mockFactory, createTexture(_)).WillOnce(Return(textureImpl));
-    gl::Texture *texture = new gl::Texture(&mockFactory, 1, GL_TEXTURE_2D);
+    EXPECT_CALL(mockGLFactory, createTexture(_)).WillOnce(Return(textureImpl));
+    gl::Texture *texture = new gl::Texture(&mockGLFactory, 1, GL_TEXTURE_2D);
     texture->addRef();
 
     gl::PixelUnpackState defaultUnpackState;
@@ -99,16 +113,21 @@ TEST(ImageTest, RespecificationReleasesReferences)
     texture->setImage(nullptr, defaultUnpackState, GL_TEXTURE_2D, 0, GL_RGBA8, gl::Extents(1, 1, 1),
                       GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 
-    rx::MockImageImpl *imageImpl = new rx::MockImageImpl();
-    egl::Image *image = new egl::Image(imageImpl, EGL_GL_TEXTURE_2D, texture, egl::AttributeMap());
+    EXPECT_CALL(mockEGLFactory, createImage(_, _, _))
+        .WillOnce(CreateMockImageImpl())
+        .RetiresOnSaturation();
+
+    egl::Image *image =
+        new egl::Image(&mockEGLFactory, EGL_GL_TEXTURE_2D, texture, egl::AttributeMap());
     image->addRef();
 
     // Verify that the image added a ref to the texture and the texture has not added a ref to the
     // image
-    EXPECT_EQ(texture->getRefCount(), 2u);
-    EXPECT_EQ(image->getRefCount(), 1u);
+    EXPECT_EQ(2u, texture->getRefCount());
+    EXPECT_EQ(1u, image->getRefCount());
 
     // Respecify the texture and verify that the image releases its reference
+    rx::MockImageImpl *imageImpl = static_cast<rx::MockImageImpl *>(image->getImplementation());
     EXPECT_CALL(*imageImpl, orphan(_)).WillOnce(Return(gl::NoError())).RetiresOnSaturation();
     EXPECT_CALL(*textureImpl, setImage(_, _, _, _, _, _, _, _, _))
         .WillOnce(Return(gl::NoError()))
@@ -117,17 +136,17 @@ TEST(ImageTest, RespecificationReleasesReferences)
     texture->setImage(nullptr, defaultUnpackState, GL_TEXTURE_2D, 0, GL_RGBA8, gl::Extents(1, 1, 1),
                       GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 
-    EXPECT_EQ(texture->getRefCount(), 1u);
-    EXPECT_EQ(image->getRefCount(), 1u);
+    EXPECT_EQ(1u, texture->getRefCount());
+    EXPECT_EQ(1u, image->getRefCount());
 
     // Delete the texture and verify that the image still exists
     EXPECT_CALL(*textureImpl, destructor()).Times(1).RetiresOnSaturation();
     texture->release();
 
-    EXPECT_EQ(image->getRefCount(), 1u);
+    EXPECT_EQ(1u, image->getRefCount());
 
     // Delete the image
     EXPECT_CALL(*imageImpl, destructor()).Times(1).RetiresOnSaturation();
     image->release();
 }
-}
+}  // namespace angle

src/libANGLE/renderer/EGLImplFactory.h

@@ -17,6 +17,7 @@ namespace egl
 class AttributeMap;
 struct Config;
 class ImageSibling;
+struct ImageState;
 struct SurfaceState;
 }
 
@@ -51,8 +52,8 @@ class EGLImplFactory : angle::NonCopyable
                                              NativePixmapType nativePixmap,
                                              const egl::AttributeMap &attribs) = 0;
 
-    virtual ImageImpl *createImage(EGLenum target,
-                                   egl::ImageSibling *buffer,
+    virtual ImageImpl *createImage(const egl::ImageState &state,
+                                   EGLenum target,
                                    const egl::AttributeMap &attribs) = 0;
 
     virtual ContextImpl *createContext(const gl::ContextState &state) = 0;

src/libANGLE/renderer/ImageImpl.h

@@ -15,6 +15,7 @@
 namespace egl
 {
 class ImageSibling;
+struct ImageState;
 }
 
 namespace rx
@@ -22,11 +23,15 @@ namespace rx
 class ImageImpl : angle::NonCopyable
 {
   public:
+    ImageImpl(const egl::ImageState &state) : mState(state) {}
     virtual ~ImageImpl() {}
     virtual egl::Error initialize() = 0;
 
     virtual gl::Error orphan(egl::ImageSibling *sibling) = 0;
+
+  protected:
+    const egl::ImageState &mState;
 };
-}
+}  // namespace rx
 
 #endif  // LIBANGLE_RENDERER_IMAGEIMPL_H_

src/libANGLE/renderer/ImageImpl_mock.h

@@ -18,11 +18,17 @@ namespace rx
 class MockImageImpl : public ImageImpl
 {
   public:
+    MockImageImpl(const egl::ImageState &state,
+                  EGLenum /*target*/,
+                  const egl::AttributeMap & /*attribs*/)
+        : ImageImpl(state)
+    {
+    }
     virtual ~MockImageImpl() { destructor(); }
     MOCK_METHOD0(initialize, egl::Error(void));
     MOCK_METHOD1(orphan, gl::Error(egl::ImageSibling *));
     MOCK_METHOD0(destructor, void());
 };
-}
+}  // namespace rx
 
 #endif  // LIBANGLE_RENDERER_IMAGEIMPLMOCK_H_

src/libANGLE/renderer/d3d/DisplayD3D.cpp

@@ -187,11 +187,11 @@ SurfaceImpl *DisplayD3D::createPixmapSurface(const egl::SurfaceState &state,
     return nullptr;
 }
 
-ImageImpl *DisplayD3D::createImage(EGLenum target,
-                                   egl::ImageSibling *buffer,
+ImageImpl *DisplayD3D::createImage(const egl::ImageState &state,
+                                   EGLenum target,
                                    const egl::AttributeMap &attribs)
 {
-    return new EGLImageD3D(mRenderer, target, buffer, attribs);
+    return new EGLImageD3D(state, target, attribs, mRenderer);
 }
 
 egl::Error DisplayD3D::getDevice(DeviceImpl **device)

src/libANGLE/renderer/d3d/DisplayD3D.h

@@ -38,8 +38,8 @@ class DisplayD3D : public DisplayImpl
                                      NativePixmapType nativePixmap,
                                      const egl::AttributeMap &attribs) override;
 
-    ImageImpl *createImage(EGLenum target,
-                           egl::ImageSibling *buffer,
+    ImageImpl *createImage(const egl::ImageState &state,
+                           EGLenum target,
                            const egl::AttributeMap &attribs) override;
 
     ContextImpl *createContext(const gl::ContextState &state) override;

src/libANGLE/renderer/d3d/EGLImageD3D.cpp

@@ -22,42 +22,23 @@
 
 namespace rx
 {
-static gl::ImageIndex GetImageIndex(GLenum target, size_t mip, size_t layer)
-{
-    if (target == GL_TEXTURE_3D)
-    {
-        return gl::ImageIndex::Make3D(static_cast<GLint>(mip), static_cast<GLint>(layer));
-    }
-    else
-    {
-        ASSERT(layer == 0);
-        return gl::ImageIndex::MakeGeneric(target, static_cast<GLint>(mip));
-    }
-}
 
-EGLImageD3D::EGLImageD3D(RendererD3D *renderer,
+EGLImageD3D::EGLImageD3D(const egl::ImageState &state,
                          EGLenum target,
-                         egl::ImageSibling *buffer,
-                         const egl::AttributeMap &attribs)
-    : mRenderer(renderer),
-      mBuffer(buffer),
-      mImageIndex(gl::ImageIndex::MakeInvalid()),
-      mAttachmentBuffer(nullptr),
-      mRenderTarget(nullptr)
+                         const egl::AttributeMap &attribs,
+                         RendererD3D *renderer)
+    : ImageImpl(state), mRenderer(renderer), mAttachmentBuffer(nullptr), mRenderTarget(nullptr)
 {
     ASSERT(renderer != nullptr);
-    ASSERT(buffer != nullptr);
 
     if (egl::IsTextureTarget(target))
     {
-        mAttachmentBuffer = GetImplAs<TextureD3D>(GetAs<gl::Texture>(buffer));
-        mImageIndex       = GetImageIndex(egl_gl::EGLImageTargetToGLTextureTarget(target),
-                                    attribs.get(EGL_GL_TEXTURE_LEVEL_KHR, 0),
-                                    attribs.get(EGL_GL_TEXTURE_ZOFFSET_KHR, 0));
+        mAttachmentBuffer = GetImplAs<TextureD3D>(GetAs<gl::Texture>(mState.source.get()));
     }
     else if (egl::IsRenderbufferTarget(target))
     {
-        mAttachmentBuffer = GetImplAs<RenderbufferD3D>(GetAs<gl::Renderbuffer>(buffer));
+        mAttachmentBuffer =
+            GetImplAs<RenderbufferD3D>(GetAs<gl::Renderbuffer>(mState.source.get()));
     }
     else
     {
@@ -77,7 +58,7 @@ egl::Error EGLImageD3D::initialize()
 
 gl::Error EGLImageD3D::orphan(egl::ImageSibling *sibling)
 {
-    if (sibling == mBuffer)
+    if (sibling == mState.source.get())
     {
         ANGLE_TRY(copyToLocalRendertarget());
     }
@@ -90,7 +71,7 @@ gl::Error EGLImageD3D::getRenderTarget(RenderTargetD3D **outRT) const
     if (mAttachmentBuffer)
     {
         FramebufferAttachmentRenderTarget *rt = nullptr;
-        ANGLE_TRY(mAttachmentBuffer->getAttachmentRenderTarget(GL_NONE, mImageIndex, &rt));
+        ANGLE_TRY(mAttachmentBuffer->getAttachmentRenderTarget(GL_NONE, mState.imageIndex, &rt));
         *outRT = static_cast<RenderTargetD3D *>(rt);
         return gl::NoError();
     }
@@ -104,7 +85,7 @@ gl::Error EGLImageD3D::getRenderTarget(RenderTargetD3D **outRT) const
 
 gl::Error EGLImageD3D::copyToLocalRendertarget()
 {
-    ASSERT(mBuffer != nullptr);
+    ASSERT(mState.source.get() != nullptr);
     ASSERT(mAttachmentBuffer != nullptr);
     ASSERT(mRenderTarget == nullptr);
 
@@ -115,7 +96,6 @@ gl::Error EGLImageD3D::copyToLocalRendertarget()
     curRenderTarget->signalDirty();
 
     // Clear the source image buffers
-    mBuffer           = nullptr;
     mAttachmentBuffer = nullptr;
 
     return mRenderer->createRenderTargetCopy(curRenderTarget, &mRenderTarget);

src/libANGLE/renderer/d3d/EGLImageD3D.h

@@ -9,7 +9,6 @@
 #ifndef LIBANGLE_RENDERER_D3D_EGLIMAGED3D_H_
 #define LIBANGLE_RENDERER_D3D_EGLIMAGED3D_H_
 
-#include "libANGLE/FramebufferAttachment.h"
 #include "libANGLE/renderer/ImageImpl.h"
 
 namespace egl
@@ -19,6 +18,7 @@ class AttributeMap;
 
 namespace rx
 {
+class FramebufferAttachmentObjectImpl;
 class TextureD3D;
 class RenderbufferD3D;
 class RendererD3D;
@@ -27,10 +27,10 @@ class RenderTargetD3D;
 class EGLImageD3D final : public ImageImpl
 {
   public:
-    EGLImageD3D(RendererD3D *renderer,
+    EGLImageD3D(const egl::ImageState &state,
                 EGLenum target,
-                egl::ImageSibling *buffer,
-                const egl::AttributeMap &attribs);
+                const egl::AttributeMap &attribs,
+                RendererD3D *renderer);
     ~EGLImageD3D() override;
 
     egl::Error initialize() override;
@@ -44,13 +44,10 @@ class EGLImageD3D final : public ImageImpl
 
     RendererD3D *mRenderer;
 
-    egl::ImageSibling *mBuffer;
-
-    gl::ImageIndex mImageIndex;
     FramebufferAttachmentObjectImpl *mAttachmentBuffer;
 
     RenderTargetD3D *mRenderTarget;
 };
-}
+}  // namespace rx
 
 #endif  // LIBANGLE_RENDERER_D3D_EGLIMAGED3D_H_

src/libANGLE/renderer/gl/DisplayGL.cpp

@@ -49,8 +49,8 @@ void DisplayGL::terminate()
     SafeDelete(mRenderer);
 }
 
-ImageImpl *DisplayGL::createImage(EGLenum target,
-                                  egl::ImageSibling *buffer,
+ImageImpl *DisplayGL::createImage(const egl::ImageState &state,
+                                  EGLenum target,
                                   const egl::AttributeMap &attribs)
 {
     UNIMPLEMENTED();

src/libANGLE/renderer/gl/DisplayGL.h

@@ -31,8 +31,8 @@ class DisplayGL : public DisplayImpl
     egl::Error initialize(egl::Display *display) override;
     void terminate() override;
 
-    ImageImpl *createImage(EGLenum target,
-                           egl::ImageSibling *buffer,
+    ImageImpl *createImage(const egl::ImageState &state,
+                           EGLenum target,
                            const egl::AttributeMap &attribs) override;
 
     ContextImpl *createContext(const gl::ContextState &state) override;

src/libANGLE/renderer/gl/egl/android/DisplayAndroid.cpp

@@ -206,12 +206,12 @@ SurfaceImpl *DisplayAndroid::createPixmapSurface(const egl::SurfaceState &state,
     return nullptr;
 }
 
-ImageImpl *DisplayAndroid::createImage(EGLenum target,
-                                       egl::ImageSibling *buffer,
+ImageImpl *DisplayAndroid::createImage(const egl::ImageState &state,
+                                       EGLenum target,
                                        const egl::AttributeMap &attribs)
 {
     UNIMPLEMENTED();
-    return DisplayGL::createImage(target, buffer, attribs);
+    return DisplayGL::createImage(state, target, attribs);
 }
 
 template <typename T>

src/libANGLE/renderer/gl/egl/android/DisplayAndroid.h

@@ -40,8 +40,8 @@ class DisplayAndroid : public DisplayEGL
                                      NativePixmapType nativePixmap,
                                      const egl::AttributeMap &attribs) override;
 
-    ImageImpl *createImage(EGLenum target,
-                           egl::ImageSibling *buffer,
+    ImageImpl *createImage(const egl::ImageState &state,
+                           EGLenum target,
                            const egl::AttributeMap &attribs) override;
 
     egl::ConfigSet generateConfigs() override;

src/libANGLE/renderer/null/DisplayNULL.cpp

@@ -164,11 +164,11 @@ SurfaceImpl *DisplayNULL::createPixmapSurface(const egl::SurfaceState &state,
     return new SurfaceNULL(state);
 }
 
-ImageImpl *DisplayNULL::createImage(EGLenum target,
-                                    egl::ImageSibling *buffer,
+ImageImpl *DisplayNULL::createImage(const egl::ImageState &state,
+                                    EGLenum target,
                                     const egl::AttributeMap &attribs)
 {
-    return new ImageNULL();
+    return new ImageNULL(state);
 }
 
 ContextImpl *DisplayNULL::createContext(const gl::ContextState &state)

src/libANGLE/renderer/null/DisplayNULL.h

@@ -60,8 +60,8 @@ class DisplayNULL : public DisplayImpl
                                      NativePixmapType nativePixmap,
                                      const egl::AttributeMap &attribs) override;
 
-    ImageImpl *createImage(EGLenum target,
-                           egl::ImageSibling *buffer,
+    ImageImpl *createImage(const egl::ImageState &state,
+                           EGLenum target,
                            const egl::AttributeMap &attribs) override;
 
     ContextImpl *createContext(const gl::ContextState &state) override;

src/libANGLE/renderer/null/ImageNULL.cpp

@@ -14,7 +14,7 @@
 namespace rx
 {
 
-ImageNULL::ImageNULL() : ImageImpl()
+ImageNULL::ImageNULL(const egl::ImageState &state) : ImageImpl(state)
 {
 }
 

src/libANGLE/renderer/null/ImageNULL.h

@@ -18,7 +18,7 @@ namespace rx
 class ImageNULL : public ImageImpl
 {
   public:
-    ImageNULL();
+    ImageNULL(const egl::ImageState &state);
     ~ImageNULL() override;
     egl::Error initialize() override;
 

src/libANGLE/renderer/vulkan/DisplayVk.cpp

@@ -177,8 +177,8 @@ SurfaceImpl *DisplayVk::createPixmapSurface(const egl::SurfaceState &state,
     return static_cast<SurfaceImpl *>(0);
 }
 
-ImageImpl *DisplayVk::createImage(EGLenum target,
-                                  egl::ImageSibling *buffer,
+ImageImpl *DisplayVk::createImage(const egl::ImageState &state,
+                                  EGLenum target,
                                   const egl::AttributeMap &attribs)
 {
     UNIMPLEMENTED();

src/libANGLE/renderer/vulkan/DisplayVk.h

@@ -58,8 +58,8 @@ class DisplayVk : public DisplayImpl
                                      NativePixmapType nativePixmap,
                                      const egl::AttributeMap &attribs) override;
 
-    ImageImpl *createImage(EGLenum target,
-                           egl::ImageSibling *buffer,
+    ImageImpl *createImage(const egl::ImageState &state,
+                           EGLenum target,
                            const egl::AttributeMap &attribs) override;
 
     ContextImpl *createContext(const gl::ContextState &state) override;

src/libANGLE/renderer/vulkan/ImageVk.cpp

@@ -14,7 +14,7 @@
 namespace rx
 {
 
-ImageVk::ImageVk() : ImageImpl()
+ImageVk::ImageVk(const egl::ImageState &state) : ImageImpl(state)
 {
 }
 

src/libANGLE/renderer/vulkan/ImageVk.h

@@ -18,7 +18,7 @@ namespace rx
 class ImageVk : public ImageImpl
 {
   public:
-    ImageVk();
+    ImageVk(const egl::ImageState &state);
     ~ImageVk() override;
     egl::Error initialize() override;
 

src/tests/angle_unittests_utils.h

@@ -109,7 +109,8 @@ class MockEGLFactory : public EGLImplFactory
                  SurfaceImpl *(const egl::SurfaceState &,
                                NativePixmapType,
                                const egl::AttributeMap &));
-    MOCK_METHOD3(createImage, ImageImpl *(EGLenum, egl::ImageSibling *, const egl::AttributeMap &));
+    MOCK_METHOD3(createImage,
+                 ImageImpl *(const egl::ImageState &, EGLenum, const egl::AttributeMap &));
     MOCK_METHOD1(createContext, ContextImpl *(const gl::ContextState &));
     MOCK_METHOD2(createStreamProducerD3DTextureNV12,
                  StreamProducerImpl *(egl::Stream::ConsumerType, const egl::AttributeMap &));