--- a/gfx/webrender_bindings/RendererOGL.cpp
+++ b/gfx/webrender_bindings/RendererOGL.cpp
@@ -45,20 +45,16 @@ WrExternalImage LockExternalImage(void* 
 void UnlockExternalImage(void* aObj, WrExternalImageId aId)
 {
   RendererOGL* renderer = reinterpret_cast<RendererOGL*>(aObj);
   RenderTextureHost* texture = renderer->GetRenderTexture(aId);
   MOZ_ASSERT(texture);
   texture->Unlock();
 }
 
-void ReleaseExternalImage(void* aObj, WrExternalImageId aId)
-{
-}
-
 RendererOGL::RendererOGL(RefPtr<RenderThread>&& aThread,
                          RefPtr<gl::GLContext>&& aGL,
                          RefPtr<widget::CompositorWidget>&& aWidget,
                          wr::WindowId aWindowId,
                          WrRenderer* aWrRenderer,
                          layers::CompositorBridgeParentBase* aBridge)
   : mThread(aThread)
   , mGL(aGL)
@@ -83,17 +79,16 @@ RendererOGL::~RendererOGL()
 
 WrExternalImageHandler
 RendererOGL::GetExternalImageHandler()
 {
   return WrExternalImageHandler {
     this,
     LockExternalImage,
     UnlockExternalImage,
-    ReleaseExternalImage,
   };
 }
 
 void
 RendererOGL::Update()
 {
   wr_renderer_update(mWrRenderer);
 }

--- a/gfx/webrender_bindings/RendererOGL.h
+++ b/gfx/webrender_bindings/RendererOGL.h
@@ -37,17 +37,16 @@ class RenderTextureHost;
 ///
 /// There is one renderer per window, all owned by the render thread.
 /// This class is a similar abstraction to CompositorOGL except that it is used
 /// on the render thread instead of the compositor thread.
 class RendererOGL
 {
   friend WrExternalImage LockExternalImage(void* aObj, WrExternalImageId aId);
   friend void UnlockExternalImage(void* aObj, WrExternalImageId aId);
-  friend void ReleaseExternalImage(void* aObj, WrExternalImageId aId);
 
 public:
   WrExternalImageHandler GetExternalImageHandler();
 
   /// This can be called on the render thread only.
   void Update();
 
   /// This can be called on the render thread only.

--- a/gfx/webrender_bindings/src/bindings.rs
+++ b/gfx/webrender_bindings/src/bindings.rs
@@ -534,24 +534,22 @@ struct WrExternalImage {
 
     // external image buffer
     buff: *const u8,
     size: usize,
 }
 
 type LockExternalImageCallback = fn(*mut c_void, WrExternalImageId) -> WrExternalImage;
 type UnlockExternalImageCallback = fn(*mut c_void, WrExternalImageId);
-type ReleaseExternalImageCallback = fn(*mut c_void, WrExternalImageId);
 
 #[repr(C)]
 pub struct WrExternalImageHandler {
     external_image_obj: *mut c_void,
     lock_func: LockExternalImageCallback,
     unlock_func: UnlockExternalImageCallback,
-    release_func: ReleaseExternalImageCallback,
 }
 
 impl ExternalImageHandler for WrExternalImageHandler {
     fn lock(&mut self,
             id: ExternalImageId)
             -> ExternalImage {
         let image = (self.lock_func)(self.external_image_obj, id.into());
 
@@ -576,21 +574,16 @@ impl ExternalImageHandler for WrExternal
             },
         }
     }
 
     fn unlock(&mut self,
               id: ExternalImageId) {
         (self.unlock_func)(self.external_image_obj, id.into());
     }
-
-    fn release(&mut self,
-               id: ExternalImageId) {
-        (self.release_func)(self.external_image_obj, id.into());
-    }
 }
 
 /// cbindgen:field-names=[mHandle]
 /// cbindgen:struct-gen-op-lt=true
 /// cbindgen:struct-gen-op-lte=true
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub struct WrWindowId(u64);
@@ -734,17 +727,16 @@ pub extern "C" fn wr_renderer_set_extern
                                                          external_image_handler: *mut WrExternalImageHandler) {
     if !external_image_handler.is_null() {
         renderer.set_external_image_handler(Box::new(unsafe {
                                                          WrExternalImageHandler {
                                                              external_image_obj:
                                                                  (*external_image_handler).external_image_obj,
                                                              lock_func: (*external_image_handler).lock_func,
                                                              unlock_func: (*external_image_handler).unlock_func,
-                                                             release_func: (*external_image_handler).release_func,
                                                          }
                                                      }));
     }
 }
 
 #[no_mangle]
 pub extern "C" fn wr_renderer_update(renderer: &mut WrRenderer) {
     renderer.update();

--- a/gfx/webrender_bindings/webrender_ffi_generated.h
+++ b/gfx/webrender_bindings/webrender_ffi_generated.h
@@ -477,29 +477,25 @@ struct WrExternalImage {
       size == aOther.size;
   }
 };
 
 typedef WrExternalImage (*LockExternalImageCallback)(void*, WrExternalImageId);
 
 typedef void (*UnlockExternalImageCallback)(void*, WrExternalImageId);
 
-typedef void (*ReleaseExternalImageCallback)(void*, WrExternalImageId);
-
 struct WrExternalImageHandler {
   void* external_image_obj;
   LockExternalImageCallback lock_func;
   UnlockExternalImageCallback unlock_func;
-  ReleaseExternalImageCallback release_func;
 
   bool operator==(const WrExternalImageHandler& aOther) const {
     return external_image_obj == aOther.external_image_obj &&
       lock_func == aOther.lock_func &&
-      unlock_func == aOther.unlock_func &&
-      release_func == aOther.release_func;
+      unlock_func == aOther.unlock_func;
   }
 };
 
 struct WrWindowId {
   uint64_t mHandle;
 
   bool operator==(const WrWindowId& aOther) const {
     return mHandle == aOther.mHandle;