Pass a context pointer to SurfaceImpl::[bind|release]TexImage.

src/libANGLE/Surface.cpp

@@ -130,7 +130,8 @@ Error Surface::destroyImpl(const Display *display)
     {
         if (mImplementation)
         {
-            ANGLE_TRY(mImplementation->releaseTexImage(EGL_BACK_BUFFER));
+            ANGLE_TRY(
+                mImplementation->releaseTexImage(display->getProxyContext(), EGL_BACK_BUFFER));
         }
         auto glErr = mTexture->releaseTexImageFromSurface(display->getProxyContext());
         if (glErr.isError())
@@ -385,7 +386,7 @@ EGLint Surface::getHeight() const
 Error Surface::bindTexImage(const gl::Context *context, gl::Texture *texture, EGLint buffer)
 {
     ASSERT(!mTexture.get());
-    ANGLE_TRY(mImplementation->bindTexImage(texture, buffer));
+    ANGLE_TRY(mImplementation->bindTexImage(context, texture, buffer));
 
     auto glErr = texture->bindTexImageFromSurface(context, this);
     if (glErr.isError())
@@ -401,7 +402,7 @@ Error Surface::releaseTexImage(const gl::Context *context, EGLint buffer)
 {
     ASSERT(context);
 
-    ANGLE_TRY(mImplementation->releaseTexImage(buffer));
+    ANGLE_TRY(mImplementation->releaseTexImage(context, buffer));
 
     ASSERT(mTexture.get());
     auto glErr = mTexture->releaseTexImageFromSurface(context);

src/libANGLE/Surface_unittest.cpp

@@ -35,8 +35,8 @@ class MockSurfaceImpl : public rx::SurfaceImpl
     MOCK_METHOD3(swapWithDamage, egl::Error(const gl::Context *, EGLint *, EGLint));
     MOCK_METHOD5(postSubBuffer, egl::Error(const gl::Context *, EGLint, EGLint, EGLint, EGLint));
     MOCK_METHOD2(querySurfacePointerANGLE, egl::Error(EGLint, void**));
-    MOCK_METHOD2(bindTexImage, egl::Error(gl::Texture*, EGLint));
-    MOCK_METHOD1(releaseTexImage, egl::Error(EGLint));
+    MOCK_METHOD3(bindTexImage, egl::Error(const gl::Context *context, gl::Texture *, EGLint));
+    MOCK_METHOD2(releaseTexImage, egl::Error(const gl::Context *context, EGLint));
     MOCK_METHOD3(getSyncValues, egl::Error(EGLuint64KHR *, EGLuint64KHR *, EGLuint64KHR *));
     MOCK_METHOD1(setSwapInterval, void(EGLint));
     MOCK_CONST_METHOD0(getWidth, EGLint());

src/libANGLE/renderer/SurfaceImpl.h

@@ -56,8 +56,10 @@ class SurfaceImpl : public FramebufferAttachmentObjectImpl
                                      EGLint width,
                                      EGLint height) = 0;
     virtual egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) = 0;
-    virtual egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) = 0;
-    virtual egl::Error releaseTexImage(EGLint buffer) = 0;
+    virtual egl::Error bindTexImage(const gl::Context *context,
+                                    gl::Texture *texture,
+                                    EGLint buffer)                                            = 0;
+    virtual egl::Error releaseTexImage(const gl::Context *context, EGLint buffer)             = 0;
     virtual egl::Error getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc) = 0;
     virtual void setSwapInterval(EGLint interval) = 0;
 

src/libANGLE/renderer/d3d/SurfaceD3D.cpp

@@ -137,12 +137,12 @@ FramebufferImpl *SurfaceD3D::createDefaultFramebuffer(const gl::FramebufferState
     return mRenderer->createDefaultFramebuffer(data);
 }
 
-egl::Error SurfaceD3D::bindTexImage(gl::Texture *, EGLint)
+egl::Error SurfaceD3D::bindTexImage(const gl::Context *, gl::Texture *, EGLint)
 {
     return egl::NoError();
 }
 
-egl::Error SurfaceD3D::releaseTexImage(EGLint)
+egl::Error SurfaceD3D::releaseTexImage(const gl::Context *, EGLint)
 {
     return egl::NoError();
 }

src/libANGLE/renderer/d3d/SurfaceD3D.h

@@ -38,8 +38,10 @@ class SurfaceD3D : public SurfaceImpl
                              EGLint width,
                              EGLint height) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
-    egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) override;
-    egl::Error releaseTexImage(EGLint buffer) override;
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
     egl::Error getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc) override;
     void setSwapInterval(EGLint interval) override;
 

src/libANGLE/renderer/gl/cgl/IOSurfaceSurfaceCGL.h

@@ -47,8 +47,10 @@ class IOSurfaceSurfaceCGL : public SurfaceGL
                              EGLint width,
                              EGLint height) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
-    egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) override;
-    egl::Error releaseTexImage(EGLint buffer) override;
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
     void setSwapInterval(EGLint interval) override;
 
     EGLint getWidth() const override;

src/libANGLE/renderer/gl/cgl/IOSurfaceSurfaceCGL.mm

@@ -136,7 +136,9 @@ egl::Error IOSurfaceSurfaceCGL::querySurfacePointerANGLE(EGLint attribute, void
     return egl::NoError();
 }
 
-egl::Error IOSurfaceSurfaceCGL::bindTexImage(gl::Texture *texture, EGLint buffer)
+egl::Error IOSurfaceSurfaceCGL::bindTexImage(const gl::Context *context,
+                                             gl::Texture *texture,
+                                             EGLint buffer)
 {
     const TextureGL *textureGL = GetImplAs<TextureGL>(texture);
     GLuint textureID           = textureGL->getTextureID();
@@ -155,7 +157,7 @@ egl::Error IOSurfaceSurfaceCGL::bindTexImage(gl::Texture *texture, EGLint buffer
     return egl::NoError();
 }
 
-egl::Error IOSurfaceSurfaceCGL::releaseTexImage(EGLint buffer)
+egl::Error IOSurfaceSurfaceCGL::releaseTexImage(const gl::Context *context, EGLint buffer)
 {
     gl::Error error = mRenderer->flush();
     if (error.isError())

src/libANGLE/renderer/gl/cgl/PbufferSurfaceCGL.h

@@ -39,8 +39,10 @@ class PbufferSurfaceCGL : public SurfaceGL
                              EGLint width,
                              EGLint height) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
-    egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) override;
-    egl::Error releaseTexImage(EGLint buffer) override;
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
     void setSwapInterval(EGLint interval) override;
 
     EGLint getWidth() const override;

src/libANGLE/renderer/gl/cgl/PbufferSurfaceCGL.mm

@@ -100,13 +100,15 @@ egl::Error PbufferSurfaceCGL::querySurfacePointerANGLE(EGLint attribute, void **
     return egl::NoError();
 }
 
-egl::Error PbufferSurfaceCGL::bindTexImage(gl::Texture *texture, EGLint buffer)
+egl::Error PbufferSurfaceCGL::bindTexImage(const gl::Context *context,
+                                           gl::Texture *texture,
+                                           EGLint buffer)
 {
     UNIMPLEMENTED();
     return egl::NoError();
 }
 
-egl::Error PbufferSurfaceCGL::releaseTexImage(EGLint buffer)
+egl::Error PbufferSurfaceCGL::releaseTexImage(const gl::Context *context, EGLint buffer)
 {
     UNIMPLEMENTED();
     return egl::NoError();

src/libANGLE/renderer/gl/cgl/WindowSurfaceCGL.h

@@ -71,8 +71,10 @@ class WindowSurfaceCGL : public SurfaceGL
                              EGLint width,
                              EGLint height) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
-    egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) override;
-    egl::Error releaseTexImage(EGLint buffer) override;
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
     void setSwapInterval(EGLint interval) override;
 
     EGLint getWidth() const override;

src/libANGLE/renderer/gl/cgl/WindowSurfaceCGL.mm

@@ -288,13 +288,15 @@ egl::Error WindowSurfaceCGL::querySurfacePointerANGLE(EGLint attribute, void **v
     return egl::Error(EGL_SUCCESS);
 }
 
-egl::Error WindowSurfaceCGL::bindTexImage(gl::Texture *texture, EGLint buffer)
+egl::Error WindowSurfaceCGL::bindTexImage(const gl::Context *context,
+                                          gl::Texture *texture,
+                                          EGLint buffer)
 {
     UNIMPLEMENTED();
     return egl::Error(EGL_SUCCESS);
 }
 
-egl::Error WindowSurfaceCGL::releaseTexImage(EGLint buffer)
+egl::Error WindowSurfaceCGL::releaseTexImage(const gl::Context *context, EGLint buffer)
 {
     UNIMPLEMENTED();
     return egl::Error(EGL_SUCCESS);

src/libANGLE/renderer/gl/egl/SurfaceEGL.cpp

@@ -65,7 +65,7 @@ egl::Error SurfaceEGL::querySurfacePointerANGLE(EGLint attribute, void **value)
     return egl::EglBadSurface();
 }
 
-egl::Error SurfaceEGL::bindTexImage(gl::Texture *texture, EGLint buffer)
+egl::Error SurfaceEGL::bindTexImage(const gl::Context *context, gl::Texture *texture, EGLint buffer)
 {
     EGLBoolean success = mEGL->bindTexImage(mSurface, buffer);
     if (success == EGL_FALSE)
@@ -75,7 +75,7 @@ egl::Error SurfaceEGL::bindTexImage(gl::Texture *texture, EGLint buffer)
     return egl::NoError();
 }
 
-egl::Error SurfaceEGL::releaseTexImage(EGLint buffer)
+egl::Error SurfaceEGL::releaseTexImage(const gl::Context *context, EGLint buffer)
 {
     EGLBoolean success = mEGL->releaseTexImage(mSurface, buffer);
     if (success == EGL_FALSE)

src/libANGLE/renderer/gl/egl/SurfaceEGL.h

@@ -34,8 +34,10 @@ class SurfaceEGL : public SurfaceGL
                              EGLint width,
                              EGLint height) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
-    egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) override;
-    egl::Error releaseTexImage(EGLint buffer) override;
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
     void setSwapInterval(EGLint interval) override;
     EGLint getWidth() const override;
     EGLint getHeight() const override;

src/libANGLE/renderer/gl/egl/ozone/SurfaceOzone.cpp

@@ -63,13 +63,15 @@ egl::Error SurfaceOzone::querySurfacePointerANGLE(EGLint attribute, void **value
     return egl::NoError();
 }
 
-egl::Error SurfaceOzone::bindTexImage(gl::Texture *texture, EGLint buffer)
+egl::Error SurfaceOzone::bindTexImage(const gl::Context *context,
+                                      gl::Texture *texture,
+                                      EGLint buffer)
 {
     mBuffer->bindTexImage();
     return egl::NoError();
 }
 
-egl::Error SurfaceOzone::releaseTexImage(EGLint buffer)
+egl::Error SurfaceOzone::releaseTexImage(const gl::Context *context, EGLint buffer)
 {
     return egl::NoError();
 }

src/libANGLE/renderer/gl/egl/ozone/SurfaceOzone.h

@@ -35,8 +35,10 @@ class SurfaceOzone : public SurfaceGL
                              EGLint width,
                              EGLint height) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
-    egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) override;
-    egl::Error releaseTexImage(EGLint buffer) override;
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
     void setSwapInterval(EGLint interval) override;
 
     EGLint getWidth() const override;

src/libANGLE/renderer/gl/glx/PbufferSurfaceGLX.cpp

@@ -96,13 +96,15 @@ egl::Error PbufferSurfaceGLX::querySurfacePointerANGLE(EGLint attribute, void **
     return egl::NoError();
 }
 
-egl::Error PbufferSurfaceGLX::bindTexImage(gl::Texture *texture, EGLint buffer)
+egl::Error PbufferSurfaceGLX::bindTexImage(const gl::Context *context,
+                                           gl::Texture *texture,
+                                           EGLint buffer)
 {
     UNIMPLEMENTED();
     return egl::NoError();
 }
 
-egl::Error PbufferSurfaceGLX::releaseTexImage(EGLint buffer)
+egl::Error PbufferSurfaceGLX::releaseTexImage(const gl::Context *context, EGLint buffer)
 {
     UNIMPLEMENTED();
     return egl::NoError();

src/libANGLE/renderer/gl/glx/PbufferSurfaceGLX.h

@@ -39,8 +39,10 @@ class PbufferSurfaceGLX : public SurfaceGLX
                              EGLint width,
                              EGLint height) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
-    egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) override;
-    egl::Error releaseTexImage(EGLint buffer) override;
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
     void setSwapInterval(EGLint interval) override;
 
     EGLint getWidth() const override;

src/libANGLE/renderer/gl/glx/WindowSurfaceGLX.cpp

@@ -166,13 +166,15 @@ egl::Error WindowSurfaceGLX::querySurfacePointerANGLE(EGLint attribute, void **v
     return egl::NoError();
 }
 
-egl::Error WindowSurfaceGLX::bindTexImage(gl::Texture *texture, EGLint buffer)
+egl::Error WindowSurfaceGLX::bindTexImage(const gl::Context *context,
+                                          gl::Texture *texture,
+                                          EGLint buffer)
 {
     UNIMPLEMENTED();
     return egl::NoError();
 }
 
-egl::Error WindowSurfaceGLX::releaseTexImage(EGLint buffer)
+egl::Error WindowSurfaceGLX::releaseTexImage(const gl::Context *context, EGLint buffer)
 {
     UNIMPLEMENTED();
     return egl::NoError();

src/libANGLE/renderer/gl/glx/WindowSurfaceGLX.h

@@ -41,8 +41,10 @@ class WindowSurfaceGLX : public SurfaceGLX
                              EGLint width,
                              EGLint height) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
-    egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) override;
-    egl::Error releaseTexImage(EGLint buffer) override;
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
     void setSwapInterval(EGLint interval) override;
 
     EGLint getWidth() const override;

src/libANGLE/renderer/gl/wgl/D3DTextureSurfaceWGL.cpp

@@ -426,7 +426,9 @@ egl::Error D3DTextureSurfaceWGL::querySurfacePointerANGLE(EGLint attribute, void
     return egl::NoError();
 }
 
-egl::Error D3DTextureSurfaceWGL::bindTexImage(gl::Texture *texture, EGLint buffer)
+egl::Error D3DTextureSurfaceWGL::bindTexImage(const gl::Context *context,
+                                              gl::Texture *texture,
+                                              EGLint buffer)
 {
     ASSERT(mBoundObjectTextureHandle == nullptr);
 
@@ -451,7 +453,7 @@ egl::Error D3DTextureSurfaceWGL::bindTexImage(gl::Texture *texture, EGLint buffe
     return egl::NoError();
 }
 
-egl::Error D3DTextureSurfaceWGL::releaseTexImage(EGLint buffer)
+egl::Error D3DTextureSurfaceWGL::releaseTexImage(const gl::Context *context, EGLint buffer)
 {
     ASSERT(mBoundObjectTextureHandle != nullptr);
     if (!mFunctionsWGL->dxUnlockObjectsNV(mDeviceHandle, 1, &mBoundObjectTextureHandle))

src/libANGLE/renderer/gl/wgl/D3DTextureSurfaceWGL.h

@@ -51,8 +51,10 @@ class D3DTextureSurfaceWGL : public SurfaceWGL
                              EGLint width,
                              EGLint height) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
-    egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) override;
-    egl::Error releaseTexImage(EGLint buffer) override;
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
     void setSwapInterval(EGLint interval) override;
 
     EGLint getWidth() const override;

src/libANGLE/renderer/gl/wgl/DXGISwapChainWindowSurfaceWGL.cpp

@@ -181,7 +181,9 @@ egl::Error DXGISwapChainWindowSurfaceWGL::querySurfacePointerANGLE(EGLint attrib
     return egl::NoError();
 }
 
-egl::Error DXGISwapChainWindowSurfaceWGL::bindTexImage(gl::Texture *texture, EGLint buffer)
+egl::Error DXGISwapChainWindowSurfaceWGL::bindTexImage(const gl::Context *context,
+                                                       gl::Texture *texture,
+                                                       EGLint buffer)
 {
     ASSERT(mTextureHandle == nullptr);
 
@@ -220,7 +222,7 @@ egl::Error DXGISwapChainWindowSurfaceWGL::bindTexImage(gl::Texture *texture, EGL
     return egl::NoError();
 }
 
-egl::Error DXGISwapChainWindowSurfaceWGL::releaseTexImage(EGLint buffer)
+egl::Error DXGISwapChainWindowSurfaceWGL::releaseTexImage(const gl::Context *context, EGLint buffer)
 {
     ASSERT(mTextureHandle != nullptr);
 

src/libANGLE/renderer/gl/wgl/DXGISwapChainWindowSurfaceWGL.h

@@ -47,8 +47,10 @@ class DXGISwapChainWindowSurfaceWGL : public SurfaceWGL
                              EGLint width,
                              EGLint height) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
-    egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) override;
-    egl::Error releaseTexImage(EGLint buffer) override;
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
     void setSwapInterval(EGLint interval) override;
 
     EGLint getWidth() const override;

src/libANGLE/renderer/gl/wgl/PbufferSurfaceWGL.cpp

@@ -146,7 +146,9 @@ static int GetWGLBufferBindTarget(EGLint buffer)
     }
 }
 
-egl::Error PbufferSurfaceWGL::bindTexImage(gl::Texture *texture, EGLint buffer)
+egl::Error PbufferSurfaceWGL::bindTexImage(const gl::Context *context,
+                                           gl::Texture *texture,
+                                           EGLint buffer)
 {
     if (!mFunctionsWGL->bindTexImageARB(mPbuffer, GetWGLBufferBindTarget(buffer)))
     {
@@ -158,7 +160,7 @@ egl::Error PbufferSurfaceWGL::bindTexImage(gl::Texture *texture, EGLint buffer)
     return egl::NoError();
 }
 
-egl::Error PbufferSurfaceWGL::releaseTexImage(EGLint buffer)
+egl::Error PbufferSurfaceWGL::releaseTexImage(const gl::Context *context, EGLint buffer)
 {
     if (!mFunctionsWGL->releaseTexImageARB(mPbuffer, GetWGLBufferBindTarget(buffer)))
     {

src/libANGLE/renderer/gl/wgl/PbufferSurfaceWGL.h

@@ -43,8 +43,10 @@ class PbufferSurfaceWGL : public SurfaceWGL
                              EGLint width,
                              EGLint height) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
-    egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) override;
-    egl::Error releaseTexImage(EGLint buffer) override;
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
     void setSwapInterval(EGLint interval) override;
 
     EGLint getWidth() const override;

src/libANGLE/renderer/gl/wgl/WindowSurfaceWGL.cpp

@@ -123,13 +123,15 @@ egl::Error WindowSurfaceWGL::querySurfacePointerANGLE(EGLint attribute, void **v
     return egl::NoError();
 }
 
-egl::Error WindowSurfaceWGL::bindTexImage(gl::Texture *texture, EGLint buffer)
+egl::Error WindowSurfaceWGL::bindTexImage(const gl::Context *context,
+                                          gl::Texture *texture,
+                                          EGLint buffer)
 {
     UNIMPLEMENTED();
     return egl::NoError();
 }
 
-egl::Error WindowSurfaceWGL::releaseTexImage(EGLint buffer)
+egl::Error WindowSurfaceWGL::releaseTexImage(const gl::Context *context, EGLint buffer)
 {
     UNIMPLEMENTED();
     return egl::NoError();

src/libANGLE/renderer/gl/wgl/WindowSurfaceWGL.h

@@ -39,8 +39,10 @@ class WindowSurfaceWGL : public SurfaceWGL
                              EGLint width,
                              EGLint height) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
-    egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) override;
-    egl::Error releaseTexImage(EGLint buffer) override;
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
     void setSwapInterval(EGLint interval) override;
 
     EGLint getWidth() const override;

src/libANGLE/renderer/null/SurfaceNULL.cpp

@@ -54,12 +54,14 @@ egl::Error SurfaceNULL::querySurfacePointerANGLE(EGLint attribute, void **value)
     return egl::NoError();
 }
 
-egl::Error SurfaceNULL::bindTexImage(gl::Texture *texture, EGLint buffer)
+egl::Error SurfaceNULL::bindTexImage(const gl::Context *context,
+                                     gl::Texture *texture,
+                                     EGLint buffer)
 {
     return egl::NoError();
 }
 
-egl::Error SurfaceNULL::releaseTexImage(EGLint buffer)
+egl::Error SurfaceNULL::releaseTexImage(const gl::Context *context, EGLint buffer)
 {
     return egl::NoError();
 }

src/libANGLE/renderer/null/SurfaceNULL.h

@@ -30,8 +30,10 @@ class SurfaceNULL : public SurfaceImpl
                              EGLint width,
                              EGLint height) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
-    egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) override;
-    egl::Error releaseTexImage(EGLint buffer) override;
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
     egl::Error getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc) override;
     void setSwapInterval(EGLint interval) override;
 

src/libANGLE/renderer/vulkan/SurfaceVk.cpp

@@ -92,12 +92,14 @@ egl::Error OffscreenSurfaceVk::querySurfacePointerANGLE(EGLint /*attribute*/, vo
     return egl::EglBadCurrentSurface();
 }
 
-egl::Error OffscreenSurfaceVk::bindTexImage(gl::Texture * /*texture*/, EGLint /*buffer*/)
+egl::Error OffscreenSurfaceVk::bindTexImage(const gl::Context * /*context*/,
+                                            gl::Texture * /*texture*/,
+                                            EGLint /*buffer*/)
 {
     return egl::NoError();
 }
 
-egl::Error OffscreenSurfaceVk::releaseTexImage(EGLint /*buffer*/)
+egl::Error OffscreenSurfaceVk::releaseTexImage(const gl::Context * /*context*/, EGLint /*buffer*/)
 {
     return egl::NoError();
 }
@@ -521,12 +523,14 @@ egl::Error WindowSurfaceVk::querySurfacePointerANGLE(EGLint attribute, void **va
     return egl::EglBadCurrentSurface();
 }
 
-egl::Error WindowSurfaceVk::bindTexImage(gl::Texture *texture, EGLint buffer)
+egl::Error WindowSurfaceVk::bindTexImage(const gl::Context *context,
+                                         gl::Texture *texture,
+                                         EGLint buffer)
 {
     return egl::NoError();
 }
 
-egl::Error WindowSurfaceVk::releaseTexImage(EGLint buffer)
+egl::Error WindowSurfaceVk::releaseTexImage(const gl::Context *context, EGLint buffer)
 {
     return egl::NoError();
 }

src/libANGLE/renderer/vulkan/SurfaceVk.h

@@ -35,8 +35,10 @@ class OffscreenSurfaceVk : public SurfaceImpl
                              EGLint width,
                              EGLint height) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
-    egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) override;
-    egl::Error releaseTexImage(EGLint buffer) override;
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
     egl::Error getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc) override;
     void setSwapInterval(EGLint interval) override;
 
@@ -80,8 +82,10 @@ class WindowSurfaceVk : public SurfaceImpl, public vk::CommandGraphResource
                              EGLint width,
                              EGLint height) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
-    egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) override;
-    egl::Error releaseTexImage(EGLint buffer) override;
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
     egl::Error getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc) override;
     void setSwapInterval(EGLint interval) override;