--- a/gfx/webrender_bindings/RenderThread.cpp
+++ b/gfx/webrender_bindings/RenderThread.cpp
@@ -236,21 +236,21 @@ void
 RenderThread::UnregisterExternalImage(uint64_t aExternalImageId)
 {
   MutexAutoLock lock(mRenderTextureMapLock);
   MOZ_ASSERT(mRenderTextures.Get(aExternalImageId).get());
   mRenderTextures.Remove(aExternalImageId);
 }
 
 RenderTextureHost*
-RenderThread::GetRenderTexture(uint64_t aExternalImageId)
+RenderThread::GetRenderTexture(WrExternalImageId aExternalImageId)
 {
   MutexAutoLock lock(mRenderTextureMapLock);
-  MOZ_ASSERT(mRenderTextures.Get(aExternalImageId).get());
-  return mRenderTextures.Get(aExternalImageId).get();
+  MOZ_ASSERT(mRenderTextures.Get(aExternalImageId.mHandle).get());
+  return mRenderTextures.Get(aExternalImageId.mHandle).get();
 }
 
 } // namespace wr
 } // namespace mozilla
 
 extern "C" {
 
 void wr_notifier_new_frame_ready(WrWindowId aWindowId)

--- a/gfx/webrender_bindings/RenderThread.h
+++ b/gfx/webrender_bindings/RenderThread.h
@@ -104,17 +104,17 @@ public:
 
   void Pause(wr::WindowId aWindowId);
   bool Resume(wr::WindowId aWindowId);
 
   void RegisterExternalImage(uint64_t aExternalImageId, RenderTextureHost* aTexture);
 
   void UnregisterExternalImage(uint64_t aExternalImageId);
 
-  RenderTextureHost* GetRenderTexture(uint64_t aExternalImageId);
+  RenderTextureHost* GetRenderTexture(WrExternalImageId aExternalImageId);
 
 private:
   explicit RenderThread(base::Thread* aThread);
 
   ~RenderThread();
 
 
   base::Thread* const mThread;

--- a/gfx/webrender_bindings/RendererOGL.cpp
+++ b/gfx/webrender_bindings/RendererOGL.cpp
@@ -169,15 +169,15 @@ RendererOGL::SetProfilerEnabled(bool aEn
 
 WrRenderedEpochs*
 RendererOGL::FlushRenderedEpochs()
 {
   return wr_renderer_flush_rendered_epochs(mWrRenderer);
 }
 
 RenderTextureHost*
-RendererOGL::GetRenderTexture(uint64_t aExternalImageId)
+RendererOGL::GetRenderTexture(WrExternalImageId aExternalImageId)
 {
   return mThread->GetRenderTexture(aExternalImageId);
 }
 
 } // namespace wr
 } // namespace mozilla

--- a/gfx/webrender_bindings/RendererOGL.h
+++ b/gfx/webrender_bindings/RendererOGL.h
@@ -75,17 +75,17 @@ public:
 
   /// This can be called on the render thread only.
   bool Resume();
 
   layers::CompositorBridgeParentBase* GetCompositorBridge() { return mBridge; }
 
   WrRenderedEpochs* FlushRenderedEpochs();
 
-  RenderTextureHost* GetRenderTexture(uint64_t aExternalImageId);
+  RenderTextureHost* GetRenderTexture(WrExternalImageId aExternalImageId);
 
   WrRenderer* GetWrRenderer() { return mWrRenderer; }
 
 protected:
 
   RefPtr<RenderThread> mThread;
   RefPtr<gl::GLContext> mGL;
   RefPtr<widget::CompositorWidget> mWidget;

--- a/gfx/webrender_bindings/WebRenderTypes.h
+++ b/gfx/webrender_bindings/WebRenderTypes.h
@@ -360,17 +360,19 @@ static inline WrComplexClipRegion ToWrCo
   WrComplexClipRegion complex_clip;
   complex_clip.rect = wr::ToWrRect(rect);
   complex_clip.radii = wr::ToWrUniformBorderRadius(size);
   return complex_clip;
 }
 
 static inline WrExternalImageId ToWrExternalImageId(uint64_t aID)
 {
-  return aID;
+  WrExternalImageId Id;
+  Id.mHandle = aID;
+  return Id;
 }
 
 static inline WrExternalImage RawDataToWrExternalImage(const uint8_t* aBuff,
                                                        size_t size)
 {
   return WrExternalImage {
     WrExternalImageType::RawData,
     0, 0.0f, 0.0f, 0.0f, 0.0f,

--- a/gfx/webrender_bindings/src/bindings.rs
+++ b/gfx/webrender_bindings/src/bindings.rs
@@ -16,17 +16,16 @@ use euclid::{TypedPoint2D, TypedSize2D, 
 extern crate webrender_traits;
 
 type WrAPI = RenderApi;
 type WrAuxiliaryListsDescriptor = AuxiliaryListsDescriptor;
 type WrBorderStyle = BorderStyle;
 type WrBoxShadowClipMode = BoxShadowClipMode;
 type WrBuiltDisplayListDescriptor = BuiltDisplayListDescriptor;
 type WrEpoch = Epoch;
-type WrExternalImageId = ExternalImageId;
 type WrFontKey = FontKey;
 type WrIdNamespace = IdNamespace;
 type WrImageFormat = ImageFormat;
 type WrImageRendering = ImageRendering;
 type WrImageKey = ImageKey;
 type WrMixBlendMode = MixBlendMode;
 type WrPipelineId = PipelineId;
 type WrRenderer = Renderer;
@@ -35,16 +34,31 @@ type WrSideOffsets2Df32 = WrSideOffsets2
 
 // Enables binary recording that can be used with `wrench replay`
 // Outputs a wr-record-*.bin file for each window that is shown
 // Note: wrench will panic if external images are used, they can
 // be disabled in WebRenderBridgeParent::ProcessWebRenderCommands
 // by commenting out the path that adds an external image ID
 static ENABLE_RECORDING: bool = false;
 
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct WrExternalImageId(pub u64);
+
+impl Into<ExternalImageId> for WrExternalImageId {
+    fn into(self) -> ExternalImageId {
+        ExternalImageId(self.0)
+    }
+}
+impl Into<WrExternalImageId> for ExternalImageId {
+    fn into(self) -> WrExternalImageId {
+        WrExternalImageId(self.0)
+    }
+}
+
 // This macro adds some checks to make sure we notice when the memory representation of
 // types change.
 macro_rules! check_ffi_type {
     ($check_sizes_match:ident struct $TypeName:ident as ($T1:ident, $T2:ident)) => (
         fn $check_sizes_match() {
             #[repr(C)] struct TestType($T1, $T2);
             let _ = mem::transmute::<$TypeName, TestType>;
         }
@@ -514,18 +528,18 @@ type ReleaseExternalImageCallback = fn(*
 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: WrExternalImageId) -> ExternalImage {
-        let image = (self.lock_func)(self.external_image_obj, id);
+    fn lock(&mut self, id: ExternalImageId) -> ExternalImage {
+        let image = (self.lock_func)(self.external_image_obj, id.into());
 
         match image.image_type {
             WrExternalImageType::NativeTexture => {
                 ExternalImage {
                     u0: image.u0,
                     v0: image.v0,
                     u1: image.u1,
                     v1: image.v1,
@@ -542,22 +556,22 @@ impl ExternalImageHandler for WrExternal
                                                              slice::from_raw_parts(image.buff,
                                                                                    image.size)
                                                          }),
                 }
             }
         }
     }
 
-    fn unlock(&mut self, id: WrExternalImageId) {
-        (self.unlock_func)(self.external_image_obj, id);
+    fn unlock(&mut self, id: ExternalImageId) {
+        (self.unlock_func)(self.external_image_obj, id.into());
     }
 
-    fn release(&mut self, id: WrExternalImageId) {
-        (self.release_func)(self.external_image_obj, id);
+    fn release(&mut self, id: ExternalImageId) {
+        (self.release_func)(self.external_image_obj, id.into());
     }
 }
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub struct WrWindowId(u64);
 
 #[repr(C)]

--- a/gfx/webrender_bindings/webrender_ffi.h
+++ b/gfx/webrender_bindings/webrender_ffi.h
@@ -49,16 +49,17 @@ struct WrType {                         
 extern "C" {
 
 // If you modify any of the declarations below, make sure to update the
 // serialization code in WebRenderMessageUtils.h and the rust bindings.
 
 WR_DECL_FFI_1(WrEpoch, uint32_t)
 WR_DECL_FFI_1(WrIdNamespace, uint32_t)
 WR_DECL_FFI_1(WrWindowId, uint64_t)
+WR_DECL_FFI_1(WrExternalImageId, uint64_t)
 
 WR_DECL_FFI_2(WrPipelineId, uint32_t, uint32_t)
 WR_DECL_FFI_2(WrImageKey, uint32_t, uint32_t)
 WR_DECL_FFI_2(WrFontKey, uint32_t, uint32_t)
 
 #undef WR_DECL_FFI_1
 #undef WR_DECL_FFI_2
 
@@ -68,22 +69,16 @@ WR_DECL_FFI_2(WrFontKey, uint32_t, uint3
 
 bool is_in_compositor_thread();
 bool is_in_main_thread();
 bool is_in_render_thread();
 bool is_glcontext_egl(void* glcontext_ptr);
 void gfx_critical_note(const char* msg);
 void* get_proc_address_from_glcontext(void* glcontext_ptr, const char* procname);
 
-// -----
-// Typedefs for struct fields and function signatures below.
-// -----
-
-typedef uint64_t WrExternalImageId;
-
 // Some useful defines to stub out webrender binding functions for when we
 // build gecko without webrender. We try to tell the compiler these functions
 // are unreachable in that case, but VC++ emits a warning if it finds any
 // unreachable functions invoked from destructors. That warning gets turned into
 // an error and causes the build to fail. So for wr_* functions called by
 // destructors in C++ classes, use WR_DESTRUCTOR_SAFE_FUNC instead, which omits
 // the unreachable annotation.
 #ifdef MOZ_BUILD_WEBRENDER