Use wrappers for GL IDs

See https://github.com/servo/webrender_traits/pull/62.

9 files changed, 113 insertions, 57 deletions

diff --git a/components/script/dom/bindings/trace.rs b/components/script/dom/bindings/trace.rs
index cd4a0f5d3ca..1d1433b2693 100644
--- a/components/script/dom/bindings/trace.rs
+++ b/components/script/dom/bindings/trace.rs
@@ -96,7 +96,8 @@ use style::values::specified::Length;
 use url::Origin as UrlOrigin;
 use url::Url;
 use uuid::Uuid;
-use webrender_traits::WebGLError;
+use webrender_traits::{WebGLBufferId, WebGLError, WebGLFramebufferId, WebGLProgramId};
+use webrender_traits::{WebGLRenderbufferId, WebGLShaderId, WebGLTextureId};
 
 /// A trait to allow tracing (only) DOM objects.
 pub trait JSTraceable {
@@ -332,6 +333,13 @@ no_jsmanaged_fields!(SystemTime);
 no_jsmanaged_fields!(SelectedFileId);
 no_jsmanaged_fields!(OpaqueStyleAndLayoutData);
 no_jsmanaged_fields!(CSSErrorReporter);
+no_jsmanaged_fields!(WebGLBufferId);
+no_jsmanaged_fields!(WebGLFramebufferId);
+no_jsmanaged_fields!(WebGLProgramId);
+no_jsmanaged_fields!(WebGLRenderbufferId);
+no_jsmanaged_fields!(WebGLShaderId);
+no_jsmanaged_fields!(WebGLTextureId);
+
 
 impl JSTraceable for Box<ScriptChan + Send> {
     #[inline]
diff --git a/components/script/dom/webglbuffer.rs b/components/script/dom/webglbuffer.rs
index 66b287e347f..3899d417b38 100644
--- a/components/script/dom/webglbuffer.rs
+++ b/components/script/dom/webglbuffer.rs
@@ -11,12 +11,12 @@ use dom::bindings::reflector::reflect_dom_object;
 use dom::webglobject::WebGLObject;
 use ipc_channel::ipc::{self, IpcSender};
 use std::cell::Cell;
-use webrender_traits::{WebGLCommand, WebGLError, WebGLResult};
+use webrender_traits::{WebGLBufferId, WebGLCommand, WebGLError, WebGLResult};
 
 #[dom_struct]
 pub struct WebGLBuffer {
     webgl_object: WebGLObject,
-    id: u32,
+    id: WebGLBufferId,
     /// The target to which this buffer was bound the first time
     target: Cell<Option<u32>>,
     capacity: Cell<usize>,
@@ -26,7 +26,9 @@ pub struct WebGLBuffer {
 }
 
 impl WebGLBuffer {
-    fn new_inherited(renderer: IpcSender<CanvasMsg>, id: u32) -> WebGLBuffer {
+    fn new_inherited(renderer: IpcSender<CanvasMsg>,
+                     id: WebGLBufferId)
+                     -> WebGLBuffer {
         WebGLBuffer {
             webgl_object: WebGLObject::new_inherited(),
             id: id,
@@ -43,17 +45,21 @@ impl WebGLBuffer {
         renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateBuffer(sender))).unwrap();
 
         let result = receiver.recv().unwrap();
-        result.map(|buffer_id| WebGLBuffer::new(global, renderer, *buffer_id))
+        result.map(|buffer_id| WebGLBuffer::new(global, renderer, buffer_id))
     }
 
-    pub fn new(global: GlobalRef, renderer: IpcSender<CanvasMsg>, id: u32) -> Root<WebGLBuffer> {
-        reflect_dom_object(box WebGLBuffer::new_inherited(renderer, id), global, WebGLBufferBinding::Wrap)
+    pub fn new(global: GlobalRef,
+               renderer: IpcSender<CanvasMsg>,
+               id: WebGLBufferId)
+              -> Root<WebGLBuffer> {
+        reflect_dom_object(box WebGLBuffer::new_inherited(renderer, id),
+                           global, WebGLBufferBinding::Wrap)
     }
 }
 
 
 impl WebGLBuffer {
-    pub fn id(&self) -> u32 {
+    pub fn id(&self) -> WebGLBufferId {
         self.id
     }
 
@@ -66,7 +72,8 @@ impl WebGLBuffer {
         } else {
             self.target.set(Some(target));
         }
-        self.renderer.send(CanvasMsg::WebGL(WebGLCommand::BindBuffer(target, self.id))).unwrap();
+        let msg = CanvasMsg::WebGL(WebGLCommand::BindBuffer(target, Some(self.id)));
+        self.renderer.send(msg).unwrap();
 
         Ok(())
     }
diff --git a/components/script/dom/webglframebuffer.rs b/components/script/dom/webglframebuffer.rs
index 06c0095b1c9..6e426fa0969 100644
--- a/components/script/dom/webglframebuffer.rs
+++ b/components/script/dom/webglframebuffer.rs
@@ -11,12 +11,12 @@ use dom::bindings::reflector::reflect_dom_object;
 use dom::webglobject::WebGLObject;
 use ipc_channel::ipc::{self, IpcSender};
 use std::cell::Cell;
-use webrender_traits::{WebGLCommand, WebGLFramebufferBindingRequest};
+use webrender_traits::{WebGLCommand, WebGLFramebufferBindingRequest, WebGLFramebufferId};
 
 #[dom_struct]
 pub struct WebGLFramebuffer {
     webgl_object: WebGLObject,
-    id: u32,
+    id: WebGLFramebufferId,
     /// target can only be gl::FRAMEBUFFER at the moment
     target: Cell<Option<u32>>,
     is_deleted: Cell<bool>,
@@ -25,7 +25,9 @@ pub struct WebGLFramebuffer {
 }
 
 impl WebGLFramebuffer {
-    fn new_inherited(renderer: IpcSender<CanvasMsg>, id: u32) -> WebGLFramebuffer {
+    fn new_inherited(renderer: IpcSender<CanvasMsg>,
+                     id: WebGLFramebufferId)
+                     -> WebGLFramebuffer {
         WebGLFramebuffer {
             webgl_object: WebGLObject::new_inherited(),
             id: id,
@@ -41,18 +43,22 @@ impl WebGLFramebuffer {
         renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateFramebuffer(sender))).unwrap();
 
         let result = receiver.recv().unwrap();
-        result.map(|fb_id| WebGLFramebuffer::new(global, renderer, *fb_id))
+        result.map(|fb_id| WebGLFramebuffer::new(global, renderer, fb_id))
     }
 
-    pub fn new(global: GlobalRef, renderer: IpcSender<CanvasMsg>, id: u32)
+    pub fn new(global: GlobalRef,
+               renderer: IpcSender<CanvasMsg>,
+               id: WebGLFramebufferId)
                -> Root<WebGLFramebuffer> {
-        reflect_dom_object(box WebGLFramebuffer::new_inherited(renderer, id), global, WebGLFramebufferBinding::Wrap)
+        reflect_dom_object(box WebGLFramebuffer::new_inherited(renderer, id),
+                           global,
+                           WebGLFramebufferBinding::Wrap)
     }
 }
 
 
 impl WebGLFramebuffer {
-    pub fn id(&self) -> u32 {
+    pub fn id(&self) -> WebGLFramebufferId {
         self.id
     }
 
diff --git a/components/script/dom/webglprogram.rs b/components/script/dom/webglprogram.rs
index 0c6e9bda11c..543a551ee17 100644
--- a/components/script/dom/webglprogram.rs
+++ b/components/script/dom/webglprogram.rs
@@ -16,12 +16,13 @@ use dom::webglrenderingcontext::MAX_UNIFORM_AND_ATTRIBUTE_LEN;
 use dom::webglshader::WebGLShader;
 use ipc_channel::ipc::{self, IpcSender};
 use std::cell::Cell;
-use webrender_traits::{WebGLCommand, WebGLError, WebGLParameter, WebGLResult};
+use webrender_traits::{WebGLCommand, WebGLError, WebGLParameter};
+use webrender_traits::{WebGLProgramId, WebGLResult};
 
 #[dom_struct]
 pub struct WebGLProgram {
     webgl_object: WebGLObject,
-    id: u32,
+    id: WebGLProgramId,
     is_deleted: Cell<bool>,
     linked: Cell<bool>,
     fragment_shader: MutNullableHeap<JS<WebGLShader>>,
@@ -31,7 +32,9 @@ pub struct WebGLProgram {
 }
 
 impl WebGLProgram {
-    fn new_inherited(renderer: IpcSender<CanvasMsg>, id: u32) -> WebGLProgram {
+    fn new_inherited(renderer: IpcSender<CanvasMsg>,
+                     id: WebGLProgramId)
+                     -> WebGLProgram {
         WebGLProgram {
             webgl_object: WebGLObject::new_inherited(),
             id: id,
@@ -49,17 +52,22 @@ impl WebGLProgram {
         renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateProgram(sender))).unwrap();
 
         let result = receiver.recv().unwrap();
-        result.map(|program_id| WebGLProgram::new(global, renderer, *program_id))
+        result.map(|program_id| WebGLProgram::new(global, renderer, program_id))
     }
 
-    pub fn new(global: GlobalRef, renderer: IpcSender<CanvasMsg>, id: u32) -> Root<WebGLProgram> {
-        reflect_dom_object(box WebGLProgram::new_inherited(renderer, id), global, WebGLProgramBinding::Wrap)
+    pub fn new(global: GlobalRef,
+               renderer: IpcSender<CanvasMsg>,
+               id: WebGLProgramId)
+               -> Root<WebGLProgram> {
+        reflect_dom_object(box WebGLProgram::new_inherited(renderer, id),
+                           global,
+                           WebGLProgramBinding::Wrap)
     }
 }
 
 
 impl WebGLProgram {
-    pub fn id(&self) -> u32 {
+    pub fn id(&self) -> WebGLProgramId {
         self.id
     }
 
diff --git a/components/script/dom/webglrenderbuffer.rs b/components/script/dom/webglrenderbuffer.rs
index dd4ef931661..b7e89f2eb22 100644
--- a/components/script/dom/webglrenderbuffer.rs
+++ b/components/script/dom/webglrenderbuffer.rs
@@ -11,12 +11,12 @@ use dom::bindings::reflector::reflect_dom_object;
 use dom::webglobject::WebGLObject;
 use ipc_channel::ipc::{self, IpcSender};
 use std::cell::Cell;
-use webrender_traits::WebGLCommand;
+use webrender_traits::{WebGLCommand, WebGLRenderbufferId};
 
 #[dom_struct]
 pub struct WebGLRenderbuffer {
     webgl_object: WebGLObject,
-    id: u32,
+    id: WebGLRenderbufferId,
     ever_bound: Cell<bool>,
     is_deleted: Cell<bool>,
     #[ignore_heap_size_of = "Defined in ipc-channel"]
@@ -24,7 +24,9 @@ pub struct WebGLRenderbuffer {
 }
 
 impl WebGLRenderbuffer {
-    fn new_inherited(renderer: IpcSender<CanvasMsg>, id: u32) -> WebGLRenderbuffer {
+    fn new_inherited(renderer: IpcSender<CanvasMsg>,
+                     id: WebGLRenderbufferId)
+                     -> WebGLRenderbuffer {
         WebGLRenderbuffer {
             webgl_object: WebGLObject::new_inherited(),
             id: id,
@@ -40,24 +42,29 @@ impl WebGLRenderbuffer {
         renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateRenderbuffer(sender))).unwrap();
 
         let result = receiver.recv().unwrap();
-        result.map(|renderbuffer_id| WebGLRenderbuffer::new(global, renderer, *renderbuffer_id))
+        result.map(|renderbuffer_id| WebGLRenderbuffer::new(global, renderer, renderbuffer_id))
     }
 
-    pub fn new(global: GlobalRef, renderer: IpcSender<CanvasMsg>, id: u32)
+    pub fn new(global: GlobalRef,
+               renderer: IpcSender<CanvasMsg>,
+               id: WebGLRenderbufferId)
                -> Root<WebGLRenderbuffer> {
-        reflect_dom_object(box WebGLRenderbuffer::new_inherited(renderer, id), global, WebGLRenderbufferBinding::Wrap)
+        reflect_dom_object(box WebGLRenderbuffer::new_inherited(renderer, id),
+                           global,
+                           WebGLRenderbufferBinding::Wrap)
     }
 }
 
 
 impl WebGLRenderbuffer {
-    pub fn id(&self) -> u32 {
+    pub fn id(&self) -> WebGLRenderbufferId {
         self.id
     }
 
     pub fn bind(&self, target: u32) {
         self.ever_bound.set(true);
-        self.renderer.send(CanvasMsg::WebGL(WebGLCommand::BindRenderbuffer(target, self.id))).unwrap();
+        let msg = CanvasMsg::WebGL(WebGLCommand::BindRenderbuffer(target, Some(self.id)));
+        self.renderer.send(msg).unwrap();
     }
 
     pub fn delete(&self) {
diff --git a/components/script/dom/webglrenderingcontext.rs b/components/script/dom/webglrenderingcontext.rs
index 46d562afa05..686bf43178f 100644
--- a/components/script/dom/webglrenderingcontext.rs
+++ b/components/script/dom/webglrenderingcontext.rs
@@ -661,7 +661,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
             slot.set(None);
             // Unbind the current buffer
             self.ipc_renderer
-                .send(CanvasMsg::WebGL(WebGLCommand::BindBuffer(target, 0)))
+                .send(CanvasMsg::WebGL(WebGLCommand::BindBuffer(target, None)))
                 .unwrap()
         }
     }
@@ -692,7 +692,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
         } else {
             // Unbind the currently bound renderbuffer
             self.ipc_renderer
-                .send(CanvasMsg::WebGL(WebGLCommand::BindRenderbuffer(target, 0)))
+                .send(CanvasMsg::WebGL(WebGLCommand::BindRenderbuffer(target, None)))
                 .unwrap()
         }
     }
@@ -713,7 +713,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
         } else {
             // Unbind the currently bound texture
             self.ipc_renderer
-                .send(CanvasMsg::WebGL(WebGLCommand::BindTexture(target, 0)))
+                .send(CanvasMsg::WebGL(WebGLCommand::BindTexture(target, None)))
                 .unwrap()
         }
     }
diff --git a/components/script/dom/webglshader.rs b/components/script/dom/webglshader.rs
index 949cb4550ae..ca2555faa8e 100644
--- a/components/script/dom/webglshader.rs
+++ b/components/script/dom/webglshader.rs
@@ -15,7 +15,7 @@ use dom::webglobject::WebGLObject;
 use ipc_channel::ipc::{self, IpcSender};
 use std::cell::Cell;
 use std::sync::{ONCE_INIT, Once};
-use webrender_traits::{WebGLCommand, WebGLParameter, WebGLResult};
+use webrender_traits::{WebGLCommand, WebGLParameter, WebGLResult, WebGLShaderId};
 
 #[derive(Clone, Copy, PartialEq, Debug, JSTraceable, HeapSizeOf)]
 pub enum ShaderCompilationStatus {
@@ -27,7 +27,7 @@ pub enum ShaderCompilationStatus {
 #[dom_struct]
 pub struct WebGLShader {
     webgl_object: WebGLObject,
-    id: u32,
+    id: WebGLShaderId,
     gl_type: u32,
     source: DOMRefCell<Option<DOMString>>,
     info_log: DOMRefCell<Option<String>>,
@@ -47,7 +47,10 @@ const SHADER_OUTPUT_FORMAT: Output = Output::Essl;
 static GLSLANG_INITIALIZATION: Once = ONCE_INIT;
 
 impl WebGLShader {
-    fn new_inherited(renderer: IpcSender<CanvasMsg>, id: u32, shader_type: u32) -> WebGLShader {
+    fn new_inherited(renderer: IpcSender<CanvasMsg>,
+                     id: WebGLShaderId,
+                     shader_type: u32)
+                     -> WebGLShader {
         GLSLANG_INITIALIZATION.call_once(|| ::angle::hl::initialize().unwrap());
         WebGLShader {
             webgl_object: WebGLObject::new_inherited(),
@@ -69,21 +72,23 @@ impl WebGLShader {
         renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateShader(shader_type, sender))).unwrap();
 
         let result = receiver.recv().unwrap();
-        result.map(|shader_id| WebGLShader::new(global, renderer, *shader_id, shader_type))
+        result.map(|shader_id| WebGLShader::new(global, renderer, shader_id, shader_type))
     }
 
     pub fn new(global: GlobalRef,
                renderer: IpcSender<CanvasMsg>,
-               id: u32,
-               shader_type: u32) -> Root<WebGLShader> {
-        reflect_dom_object(
-            box WebGLShader::new_inherited(renderer, id, shader_type), global, WebGLShaderBinding::Wrap)
+               id: WebGLShaderId,
+               shader_type: u32)
+               -> Root<WebGLShader> {
+        reflect_dom_object(box WebGLShader::new_inherited(renderer, id, shader_type),
+                           global,
+                           WebGLShaderBinding::Wrap)
     }
 }
 
 
 impl WebGLShader {
-    pub fn id(&self) -> u32 {
+    pub fn id(&self) -> WebGLShaderId {
         self.id
     }
 
diff --git a/components/script/dom/webgltexture.rs b/components/script/dom/webgltexture.rs
index 647b36ddfe7..e189835ee9d 100644
--- a/components/script/dom/webgltexture.rs
+++ b/components/script/dom/webgltexture.rs
@@ -15,7 +15,7 @@ use dom::webglobject::WebGLObject;
 use ipc_channel::ipc::{self, IpcSender};
 use std::cell::Cell;
 use std::cmp;
-use webrender_traits::{WebGLCommand, WebGLError, WebGLResult};
+use webrender_traits::{WebGLCommand, WebGLError, WebGLResult, WebGLTextureId};
 
 pub enum TexParameterValue {
     Float(f32),
@@ -30,7 +30,7 @@ no_jsmanaged_fields!([ImageInfo; MAX_LEVEL_COUNT * MAX_FACE_COUNT]);
 #[dom_struct]
 pub struct WebGLTexture {
     webgl_object: WebGLObject,
-    id: u32,
+    id: WebGLTextureId,
     /// The target to which this texture was bound the first time
     target: Cell<Option<u32>>,
     is_deleted: Cell<bool>,
@@ -45,7 +45,9 @@ pub struct WebGLTexture {
 }
 
 impl WebGLTexture {
-    fn new_inherited(renderer: IpcSender<CanvasMsg>, id: u32) -> WebGLTexture {
+    fn new_inherited(renderer: IpcSender<CanvasMsg>,
+                     id: WebGLTextureId)
+                     -> WebGLTexture {
         WebGLTexture {
             webgl_object: WebGLObject::new_inherited(),
             id: id,
@@ -64,17 +66,22 @@ impl WebGLTexture {
         renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateTexture(sender))).unwrap();
 
         let result = receiver.recv().unwrap();
-        result.map(|texture_id| WebGLTexture::new(global, renderer, *texture_id))
+        result.map(|texture_id| WebGLTexture::new(global, renderer, texture_id))
     }
 
-    pub fn new(global: GlobalRef, renderer: IpcSender<CanvasMsg>, id: u32) -> Root<WebGLTexture> {
-        reflect_dom_object(box WebGLTexture::new_inherited(renderer, id), global, WebGLTextureBinding::Wrap)
+    pub fn new(global: GlobalRef,
+               renderer: IpcSender<CanvasMsg>,
+               id: WebGLTextureId)
+               -> Root<WebGLTexture> {
+        reflect_dom_object(box WebGLTexture::new_inherited(renderer, id),
+                           global,
+                           WebGLTextureBinding::Wrap)
     }
 }
 
 
 impl WebGLTexture {
-    pub fn id(&self) -> u32 {
+    pub fn id(&self) -> WebGLTextureId {
         self.id
     }
 
@@ -99,7 +106,8 @@ impl WebGLTexture {
             self.target.set(Some(target));
         }
 
-        self.renderer.send(CanvasMsg::WebGL(WebGLCommand::BindTexture(target, self.id))).unwrap();
+        let msg = CanvasMsg::WebGL(WebGLCommand::BindTexture(target, Some(self.id)));
+        self.renderer.send(msg).unwrap();
 
         Ok(())
     }
diff --git a/components/script/dom/webgluniformlocation.rs b/components/script/dom/webgluniformlocation.rs
index 2f8e3331cd2..f52cb899eb8 100644
--- a/components/script/dom/webgluniformlocation.rs
+++ b/components/script/dom/webgluniformlocation.rs
@@ -7,16 +7,19 @@ use dom::bindings::codegen::Bindings::WebGLUniformLocationBinding;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use webrender_traits::WebGLProgramId;
 
 #[dom_struct]
 pub struct WebGLUniformLocation {
     reflector_: Reflector,
     id: i32,
-    program_id: u32,
+    program_id: WebGLProgramId,
 }
 
 impl WebGLUniformLocation {
-    fn new_inherited(id: i32, program_id: u32) -> WebGLUniformLocation {
+    fn new_inherited(id: i32,
+                     program_id: WebGLProgramId)
+                     -> WebGLUniformLocation {
         WebGLUniformLocation {
             reflector_: Reflector::new(),
             id: id,
@@ -24,16 +27,20 @@ impl WebGLUniformLocation {
         }
     }
 
-    pub fn new(global: GlobalRef, id: i32, program_id: u32) -> Root<WebGLUniformLocation> {
-        reflect_dom_object(
-            box WebGLUniformLocation::new_inherited(id, program_id), global, WebGLUniformLocationBinding::Wrap)
+    pub fn new(global: GlobalRef,
+               id: i32,
+               program_id: WebGLProgramId)
+               -> Root<WebGLUniformLocation> {
+        reflect_dom_object(box WebGLUniformLocation::new_inherited(id, program_id),
+                           global,
+                           WebGLUniformLocationBinding::Wrap)
     }
 
     pub fn id(&self) -> i32 {
         self.id
     }
 
-    pub fn program_id(&self) -> u32 {
+    pub fn program_id(&self) -> WebGLProgramId {
         self.program_id
     }
 }