b=517717; fix up webGL array compat (rename WebGL*Array->Canvas); r=vlad
authorMark Steele <mwsteele@gmail.com>
Sun, 20 Sep 2009 14:33:40 -0700
changeset 32893 f013c109a003d319cd83dc344dc169b39bde9a02
parent 32892 f9b8b71645d9bf57c63628a0465dd05b6af1c8af
child 32894 7494a97275dc55de9c6c57f0cc32acc4e8f68d46
push idunknown
push userunknown
push dateunknown
reviewersvlad
bugs517717
milestone1.9.3a1pre
b=517717; fix up webGL array compat (rename WebGL*Array->Canvas); r=vlad
content/canvas/src/WebGLContext.cpp
content/canvas/src/WebGLContext.h
content/canvas/src/WebGLContextGL.cpp
dom/base/nsDOMClassInfo.cpp
dom/base/nsDOMClassInfoID.h
dom/interfaces/canvas/nsICanvasRenderingContextWebGL.idl
--- a/content/canvas/src/WebGLContext.cpp
+++ b/content/canvas/src/WebGLContext.cpp
@@ -416,94 +416,94 @@ NS_INTERFACE_MAP_BEGIN(WebGLRenderbuffer
   NS_INTERFACE_MAP_ENTRY(nsISupports)
   NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(WebGLRenderbuffer)
 NS_INTERFACE_MAP_END
 
 NS_IMPL_ADDREF(WebGLFloatArray)
 NS_IMPL_RELEASE(WebGLFloatArray)
 
 NS_INTERFACE_MAP_BEGIN(WebGLFloatArray)
-  NS_INTERFACE_MAP_ENTRY(nsIWebGLArray)
-  NS_INTERFACE_MAP_ENTRY(nsIWebGLFloatArray)
-  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWebGLFloatArray)
+  NS_INTERFACE_MAP_ENTRY(nsICanvasArray)
+  NS_INTERFACE_MAP_ENTRY(nsICanvasFloatArray)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsICanvasFloatArray)
   NS_INTERFACE_MAP_ENTRY(nsIJSNativeInitializer)
-  NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(WebGLFloatArray)
+  NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(CanvasFloatArray)
 NS_INTERFACE_MAP_END
 
 NS_IMPL_ADDREF(WebGLByteArray)
 NS_IMPL_RELEASE(WebGLByteArray)
 
 NS_INTERFACE_MAP_BEGIN(WebGLByteArray)
-  NS_INTERFACE_MAP_ENTRY(nsIWebGLArray)
-  NS_INTERFACE_MAP_ENTRY(nsIWebGLByteArray)
-  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWebGLByteArray)
+  NS_INTERFACE_MAP_ENTRY(nsICanvasArray)
+  NS_INTERFACE_MAP_ENTRY(nsICanvasByteArray)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsICanvasByteArray)
   NS_INTERFACE_MAP_ENTRY(nsIJSNativeInitializer)
-  NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(WebGLByteArray)
+  NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(CanvasByteArray)
 NS_INTERFACE_MAP_END
 
 NS_IMPL_ADDREF(WebGLUnsignedByteArray)
 NS_IMPL_RELEASE(WebGLUnsignedByteArray)
 
 NS_INTERFACE_MAP_BEGIN(WebGLUnsignedByteArray)
-  NS_INTERFACE_MAP_ENTRY(nsIWebGLArray)
-  NS_INTERFACE_MAP_ENTRY(nsIWebGLUnsignedByteArray)
-  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWebGLUnsignedByteArray)
+  NS_INTERFACE_MAP_ENTRY(nsICanvasArray)
+  NS_INTERFACE_MAP_ENTRY(nsICanvasUnsignedByteArray)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsICanvasUnsignedByteArray)
   NS_INTERFACE_MAP_ENTRY(nsIJSNativeInitializer)
-  NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(WebGLUnsignedByteArray)
+  NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(CanvasUnsignedByteArray)
 NS_INTERFACE_MAP_END
 
 NS_IMPL_ADDREF(WebGLShortArray)
 NS_IMPL_RELEASE(WebGLShortArray)
 
 NS_INTERFACE_MAP_BEGIN(WebGLShortArray)
-  NS_INTERFACE_MAP_ENTRY(nsIWebGLArray)
-  NS_INTERFACE_MAP_ENTRY(nsIWebGLShortArray)
-  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWebGLShortArray)
+  NS_INTERFACE_MAP_ENTRY(nsICanvasArray)
+  NS_INTERFACE_MAP_ENTRY(nsICanvasShortArray)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsICanvasShortArray)
   NS_INTERFACE_MAP_ENTRY(nsIJSNativeInitializer)
-  NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(WebGLShortArray)
+  NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(CanvasShortArray)
 NS_INTERFACE_MAP_END
 
 NS_IMPL_ADDREF(WebGLUnsignedShortArray)
 NS_IMPL_RELEASE(WebGLUnsignedShortArray)
 
 NS_INTERFACE_MAP_BEGIN(WebGLUnsignedShortArray)
-  NS_INTERFACE_MAP_ENTRY(nsIWebGLArray)
-  NS_INTERFACE_MAP_ENTRY(nsIWebGLUnsignedShortArray)
-  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWebGLUnsignedShortArray)
+  NS_INTERFACE_MAP_ENTRY(nsICanvasArray)
+  NS_INTERFACE_MAP_ENTRY(nsICanvasUnsignedShortArray)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsICanvasUnsignedShortArray)
   NS_INTERFACE_MAP_ENTRY(nsIJSNativeInitializer)
-  NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(WebGLUnsignedShortArray)
+  NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(CanvasUnsignedShortArray)
 NS_INTERFACE_MAP_END
 
 NS_IMPL_ADDREF(WebGLIntArray)
 NS_IMPL_RELEASE(WebGLIntArray)
 
 NS_INTERFACE_MAP_BEGIN(WebGLIntArray)
-  NS_INTERFACE_MAP_ENTRY(nsIWebGLArray)
-  NS_INTERFACE_MAP_ENTRY(nsIWebGLIntArray)
-  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWebGLIntArray)
+  NS_INTERFACE_MAP_ENTRY(nsICanvasArray)
+  NS_INTERFACE_MAP_ENTRY(nsICanvasIntArray)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsICanvasIntArray)
   NS_INTERFACE_MAP_ENTRY(nsIJSNativeInitializer)
-  NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(WebGLIntArray)
+  NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(CanvasIntArray)
 NS_INTERFACE_MAP_END
 
 NS_IMPL_ADDREF(WebGLUnsignedIntArray)
 NS_IMPL_RELEASE(WebGLUnsignedIntArray)
 
 NS_INTERFACE_MAP_BEGIN(WebGLUnsignedIntArray)
-  NS_INTERFACE_MAP_ENTRY(nsIWebGLArray)
-  NS_INTERFACE_MAP_ENTRY(nsIWebGLUnsignedIntArray)
-  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWebGLUnsignedIntArray)
+  NS_INTERFACE_MAP_ENTRY(nsICanvasArray)
+  NS_INTERFACE_MAP_ENTRY(nsICanvasUnsignedIntArray)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsICanvasUnsignedIntArray)
   NS_INTERFACE_MAP_ENTRY(nsIJSNativeInitializer)
-  NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(WebGLUnsignedIntArray)
+  NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(CanvasUnsignedIntArray)
 NS_INTERFACE_MAP_END
 
 
 nsresult
 NS_NewCanvasFloatArray(nsISupports **aResult)
 {
-    nsIWebGLFloatArray *wgfa = new WebGLFloatArray();
+    nsICanvasFloatArray *wgfa = new WebGLFloatArray();
     if (!wgfa)
         return NS_ERROR_OUT_OF_MEMORY;
 
     NS_ADDREF(*aResult = wgfa);
     return NS_OK;
 }
 
 WebGLFloatArray::WebGLFloatArray()
@@ -576,17 +576,17 @@ NS_IMETHODIMP_(PRUint32) WebGLFloatArray
 NS_IMETHODIMP_(PRUint32) WebGLFloatArray::NativeCount()
 {
     return mBuffer.length;
 }
 
 nsresult
 NS_NewCanvasByteArray(nsISupports **aResult)
 {
-    nsIWebGLByteArray *wgba = new WebGLByteArray();
+    nsICanvasByteArray *wgba = new WebGLByteArray();
     if (!wgba)
         return NS_ERROR_OUT_OF_MEMORY;
 
     NS_ADDREF(*aResult = wgba);
     return NS_OK;
 }
 
 WebGLByteArray::WebGLByteArray() { }
@@ -657,17 +657,17 @@ NS_IMETHODIMP_(PRUint32) WebGLByteArray:
 NS_IMETHODIMP_(PRUint32) WebGLByteArray::NativeCount()
 {
     return mBuffer.length;
 }
 
 nsresult
 NS_NewCanvasUnsignedByteArray(nsISupports **aResult)
 {
-    nsIWebGLUnsignedByteArray *wguba = new WebGLUnsignedByteArray();
+    nsICanvasUnsignedByteArray *wguba = new WebGLUnsignedByteArray();
     if (!wguba)
         return NS_ERROR_OUT_OF_MEMORY;
 
     NS_ADDREF(*aResult = wguba);
     return NS_OK;
 }
 
 WebGLUnsignedByteArray::WebGLUnsignedByteArray() { }
@@ -738,17 +738,17 @@ NS_IMETHODIMP_(PRUint32) WebGLUnsignedBy
 NS_IMETHODIMP_(PRUint32) WebGLUnsignedByteArray::NativeCount()
 {
     return mBuffer.length;
 }
 
 nsresult
 NS_NewCanvasShortArray(nsISupports **aResult)
 {
-    nsIWebGLShortArray *wgsa = new WebGLShortArray();
+    nsICanvasShortArray *wgsa = new WebGLShortArray();
     if (!wgsa)
         return NS_ERROR_OUT_OF_MEMORY;
 
     NS_ADDREF(*aResult = wgsa);
     return NS_OK;
 }
 
 WebGLShortArray::WebGLShortArray() { }
@@ -820,17 +820,17 @@ NS_IMETHODIMP_(PRUint32) WebGLShortArray
 {
     return mBuffer.length;
 }
 
 
 nsresult
 NS_NewCanvasUnsignedShortArray(nsISupports **aResult)
 {
-    nsIWebGLUnsignedShortArray *wgusa = new WebGLUnsignedShortArray();
+    nsICanvasUnsignedShortArray *wgusa = new WebGLUnsignedShortArray();
     if (!wgusa)
         return NS_ERROR_OUT_OF_MEMORY;
 
     NS_ADDREF(*aResult = wgusa);
     return NS_OK;
 }
 
 WebGLUnsignedShortArray::WebGLUnsignedShortArray() { }
@@ -901,17 +901,17 @@ NS_IMETHODIMP_(PRUint32) WebGLUnsignedSh
 NS_IMETHODIMP_(PRUint32) WebGLUnsignedShortArray::NativeCount()
 {
     return mBuffer.length;
 }
 
 nsresult
 NS_NewCanvasIntArray(nsISupports **aResult)
 {
-    nsIWebGLIntArray *wgia = new WebGLIntArray();
+    nsICanvasIntArray *wgia = new WebGLIntArray();
     if (!wgia)
         return NS_ERROR_OUT_OF_MEMORY;
 
     NS_ADDREF(*aResult = wgia);
     return NS_OK;
 }
 
 WebGLIntArray::WebGLIntArray() { }
@@ -983,17 +983,17 @@ NS_IMETHODIMP_(PRUint32) WebGLIntArray::
 NS_IMETHODIMP_(PRUint32) WebGLIntArray::NativeCount()
 {
     return mBuffer.length;
 }
 
 nsresult
 NS_NewCanvasUnsignedIntArray(nsISupports **aResult)
 {
-    nsIWebGLUnsignedIntArray *wguia = new WebGLUnsignedIntArray();
+    nsICanvasUnsignedIntArray *wguia = new WebGLUnsignedIntArray();
     if (!wguia)
         return NS_ERROR_OUT_OF_MEMORY;
 
     NS_ADDREF(*aResult = wguia);
     return NS_OK;
 }
 
 WebGLUnsignedIntArray::WebGLUnsignedIntArray() { }
--- a/content/canvas/src/WebGLContext.h
+++ b/content/canvas/src/WebGLContext.h
@@ -345,17 +345,17 @@ public:
         if (mDeleted)
             return;
         ZeroOwners();
         mDeleted = PR_TRUE;
     }
     PRBool Deleted() { return mDeleted; }
     GLuint GLName() { return mName; }
 
-    void Set(nsIWebGLArray *na) {
+    void Set(nsICanvasArray *na) {
         mGLType = na->NativeType();
         mElementSize = na->NativeElementSize();
         mCount = na->NativeCount();
     }
 
     GLenum GLType() { return mGLType; }
     PRUint32 ByteCount() { return mElementSize * mCount; }
     PRUint32 Count() { return mCount; }
@@ -493,26 +493,26 @@ protected:
     PRBool mDeleted;
 };
 
 //
 // array wrapper classes
 //
 
 class WebGLFloatArray :
-    public nsIWebGLFloatArray,
+    public nsICanvasFloatArray,
     public nsIJSNativeInitializer
 {
 public:
     WebGLFloatArray();
     WebGLFloatArray(JSContext *cx, JSObject *arrayObj, jsuint arrayLen);
 
     NS_DECL_ISUPPORTS
-    NS_DECL_NSIWEBGLARRAY
-    NS_DECL_NSIWEBGLFLOATARRAY
+    NS_DECL_NSICANVASARRAY
+    NS_DECL_NSICANVASFLOATARRAY
 
     static nsresult NewCanvasFloatArray(nsISupports **aNewObject);
 
     NS_IMETHOD Initialize(nsISupports* aOwner,
                           JSContext* aCx,
                           JSObject* aObj,
                           PRUint32 aArgc,
                           jsval* aArgv);
@@ -521,151 +521,151 @@ protected:
     SimpleBuffer mBuffer;
     PRUint32 mLength;
     PRUint32 mSize;
     PRUint32 mElementSize;
     PRUint32 mCount;
 };
 
 class WebGLByteArray :
-    public nsIWebGLByteArray,
+    public nsICanvasByteArray,
     public nsIJSNativeInitializer
 {
 public:
     WebGLByteArray();
     WebGLByteArray(JSContext *cx, JSObject *arrayObj, jsuint arrayLen);
 
     NS_DECL_ISUPPORTS
-    NS_DECL_NSIWEBGLARRAY
-    NS_DECL_NSIWEBGLBYTEARRAY
+    NS_DECL_NSICANVASARRAY
+    NS_DECL_NSICANVASBYTEARRAY
 
     NS_IMETHOD Initialize(nsISupports* aOwner,
                           JSContext* aCx,
                           JSObject* aObj,
                           PRUint32 aArgc,
                           jsval* aArgv);
 protected:
     SimpleBuffer mBuffer;
     PRUint32 mLength;
     PRUint32 mSize;
     PRUint32 mElementSize;
     PRUint32 mCount;
 };
 
 class WebGLUnsignedByteArray :
-    public nsIWebGLUnsignedByteArray,
+    public nsICanvasUnsignedByteArray,
     public nsIJSNativeInitializer
 {
 public:
     WebGLUnsignedByteArray();
     WebGLUnsignedByteArray(JSContext *cx, JSObject *arrayObj, jsuint arrayLen);
 
     NS_DECL_ISUPPORTS
-    NS_DECL_NSIWEBGLARRAY
-    NS_DECL_NSIWEBGLUNSIGNEDBYTEARRAY
+    NS_DECL_NSICANVASARRAY
+    NS_DECL_NSICANVASUNSIGNEDBYTEARRAY
 
     NS_IMETHOD Initialize(nsISupports* aOwner,
                           JSContext* aCx,
                           JSObject* aObj,
                           PRUint32 aArgc,
                           jsval* aArgv);
 protected:
     SimpleBuffer mBuffer;
     PRUint32 mLength;
     PRUint32 mSize;
     PRUint32 mElementSize;
     PRUint32 mCount;
 };
 
 class WebGLShortArray :
-    public nsIWebGLShortArray,
+    public nsICanvasShortArray,
     public nsIJSNativeInitializer
 {
 public:
     WebGLShortArray();
     WebGLShortArray(JSContext *cx, JSObject *arrayObj, jsuint arrayLen);
 
     NS_DECL_ISUPPORTS
-    NS_DECL_NSIWEBGLARRAY
-    NS_DECL_NSIWEBGLSHORTARRAY
+    NS_DECL_NSICANVASARRAY
+    NS_DECL_NSICANVASSHORTARRAY
 
     NS_IMETHOD Initialize(nsISupports* aOwner,
                           JSContext* aCx,
                           JSObject* aObj,
                           PRUint32 aArgc,
                           jsval* aArgv);
 protected:
     SimpleBuffer mBuffer;
     PRUint32 mLength;
     PRUint32 mSize;
     PRUint32 mElementSize;
     PRUint32 mCount;
 };
 
 class WebGLUnsignedShortArray :
-    public nsIWebGLUnsignedShortArray,
+    public nsICanvasUnsignedShortArray,
     public nsIJSNativeInitializer
 {
 public:
     WebGLUnsignedShortArray();
     WebGLUnsignedShortArray(JSContext *cx, JSObject *arrayObj, jsuint arrayLen);
 
     NS_DECL_ISUPPORTS
-    NS_DECL_NSIWEBGLARRAY
-    NS_DECL_NSIWEBGLUNSIGNEDSHORTARRAY
+    NS_DECL_NSICANVASARRAY
+    NS_DECL_NSICANVASUNSIGNEDSHORTARRAY
 
     NS_IMETHOD Initialize(nsISupports* aOwner,
                           JSContext* aCx,
                           JSObject* aObj,
                           PRUint32 aArgc,
                           jsval* aArgv);
 protected:
     SimpleBuffer mBuffer;
     PRUint32 mLength;
     PRUint32 mSize;
     PRUint32 mElementSize;
     PRUint32 mCount;
 };
 
 class WebGLIntArray :
-    public nsIWebGLIntArray,
+    public nsICanvasIntArray,
     public nsIJSNativeInitializer
 {
 public:
     WebGLIntArray();
     WebGLIntArray(JSContext *cx, JSObject *arrayObj, jsuint arrayLen);
 
     NS_DECL_ISUPPORTS
-    NS_DECL_NSIWEBGLARRAY
-    NS_DECL_NSIWEBGLINTARRAY
+    NS_DECL_NSICANVASARRAY
+    NS_DECL_NSICANVASINTARRAY
 
     NS_IMETHOD Initialize(nsISupports* aOwner,
                           JSContext* aCx,
                           JSObject* aObj,
                           PRUint32 aArgc,
                           jsval* aArgv);
 protected:
     SimpleBuffer mBuffer;
     PRUint32 mLength;
     PRUint32 mSize;
     PRUint32 mElementSize;
     PRUint32 mCount;
 };
 
 class WebGLUnsignedIntArray :
-    public nsIWebGLUnsignedIntArray,
+    public nsICanvasUnsignedIntArray,
     public nsIJSNativeInitializer
 {
 public:
     WebGLUnsignedIntArray();
     WebGLUnsignedIntArray(JSContext *cx, JSObject *arrayObj, jsuint arrayLen);
 
     NS_DECL_ISUPPORTS
-    NS_DECL_NSIWEBGLARRAY
-    NS_DECL_NSIWEBGLUNSIGNEDINTARRAY
+    NS_DECL_NSICANVASARRAY
+    NS_DECL_NSICANVASUNSIGNEDINTARRAY
 
     NS_IMETHOD Initialize(nsISupports* aOwner,
                           JSContext* aCx,
                           JSObject* aObj,
                           PRUint32 aArgc,
                           jsval* aArgv);
 protected:
     SimpleBuffer mBuffer;
--- a/content/canvas/src/WebGLContextGL.cpp
+++ b/content/canvas/src/WebGLContextGL.cpp
@@ -102,19 +102,19 @@ NS_IMETHODIMP WebGLContext::name(t1 a1, 
 NS_IMETHODIMP WebGLContext::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5, t6 a6) { \
     MakeContextCurrent(); gl->f##glname(a1,a2,a3,a4,a5,a6); return NS_OK; \
 }
 
 //
 //  WebGL API
 //
 
-/* nsIWebGLFloatArray createFloatArray (); */
+/* nsICanvasFloatArray createFloatArray (); */
 NS_IMETHODIMP
-WebGLContext::CreateFloatArray(nsIWebGLFloatArray **retval)
+WebGLContext::CreateFloatArray(nsICanvasFloatArray **retval)
 {
     NativeJSContext js;
 
     if (js.argc != 1)
         return NS_ERROR_DOM_SYNTAX_ERR;
 
     JSObject *arrayObj;
     jsuint arrayLen;
@@ -129,19 +129,19 @@ WebGLContext::CreateFloatArray(nsIWebGLF
 
     WebGLFloatArray *wgfa = new WebGLFloatArray(js.ctx, arrayObj, arrayLen);
     if (wgfa)
         NS_ADDREF(*retval = wgfa);
 
     return NS_OK;
 }
 
-/* nsIWebGLByteArray createByteArray (); */
+/* nsICanvasByteArray createByteArray (); */
 NS_IMETHODIMP
-WebGLContext::CreateByteArray(nsIWebGLByteArray **retval)
+WebGLContext::CreateByteArray(nsICanvasByteArray **retval)
 {
     NativeJSContext js;
 
     if (js.argc != 1)
         return NS_ERROR_DOM_SYNTAX_ERR;
 
     JSObject *arrayObj;
     jsuint arrayLen;
@@ -155,19 +155,19 @@ WebGLContext::CreateByteArray(nsIWebGLBy
     }
 
     WebGLByteArray *wgba = new WebGLByteArray(js.ctx, arrayObj, arrayLen);
     if (wgba)
         NS_ADDREF(*retval = wgba);
     return NS_OK;
 }
 
-/* nsIWebGLUnsignedByteArray createUnsignedByteArray (); */
+/* nsICanvasUnsignedByteArray createUnsignedByteArray (); */
 NS_IMETHODIMP
-WebGLContext::CreateUnsignedByteArray(nsIWebGLUnsignedByteArray **retval)
+WebGLContext::CreateUnsignedByteArray(nsICanvasUnsignedByteArray **retval)
 {
     NativeJSContext js;
 
     if (js.argc != 1)
         return NS_ERROR_DOM_SYNTAX_ERR;
 
     JSObject *arrayObj;
     jsuint arrayLen;
@@ -181,19 +181,19 @@ WebGLContext::CreateUnsignedByteArray(ns
     }
 
     WebGLUnsignedByteArray *wguba = new WebGLUnsignedByteArray(js.ctx, arrayObj, arrayLen);
     if (wguba)
         NS_ADDREF(*retval = wguba);
     return NS_OK;
 }
 
-/* nsIWebGLShortArray createShortArray (); */
+/* nsICanvasShortArray createShortArray (); */
 NS_IMETHODIMP
-WebGLContext::CreateShortArray(nsIWebGLShortArray **retval)
+WebGLContext::CreateShortArray(nsICanvasShortArray **retval)
 {
     NativeJSContext js;
 
     if (js.argc != 1)
         return NS_ERROR_DOM_SYNTAX_ERR;
 
     JSObject *arrayObj;
     jsuint arrayLen;
@@ -207,19 +207,19 @@ WebGLContext::CreateShortArray(nsIWebGLS
     }
 
     WebGLShortArray *wgsa = new WebGLShortArray(js.ctx, arrayObj, arrayLen);
     if (wgsa)
         NS_ADDREF(*retval = wgsa);
     return NS_OK;
 }
 
-/* nsIWebGLUnsignedShortArray createUnsignedShortArray (); */
+/* nsICanvasUnsignedShortArray createUnsignedShortArray (); */
 NS_IMETHODIMP
-WebGLContext::CreateUnsignedShortArray(nsIWebGLUnsignedShortArray **retval)
+WebGLContext::CreateUnsignedShortArray(nsICanvasUnsignedShortArray **retval)
 {
     NativeJSContext js;
 
     if (js.argc != 1)
         return NS_ERROR_DOM_SYNTAX_ERR;
 
     JSObject *arrayObj;
     jsuint arrayLen;
@@ -234,19 +234,19 @@ WebGLContext::CreateUnsignedShortArray(n
 
     WebGLUnsignedShortArray *wgusa = new WebGLUnsignedShortArray(js.ctx, arrayObj, arrayLen);
     if (wgusa)
         NS_ADDREF(*retval = wgusa);
     return NS_OK;
 }
 
 
-/* nsIWebGLUnsignedByteArray createUnsignedByteArray (); */
+/* nsICanvasUnsignedIntArray createUnsignedIntArray (); */
 NS_IMETHODIMP
-WebGLContext::CreateIntArray(nsIWebGLIntArray **retval)
+WebGLContext::CreateIntArray(nsICanvasIntArray **retval)
 {
     NativeJSContext js;
 
     if (js.argc != 1)
         return NS_ERROR_DOM_SYNTAX_ERR;
 
     JSObject *arrayObj;
     jsuint arrayLen;
@@ -260,19 +260,19 @@ WebGLContext::CreateIntArray(nsIWebGLInt
     }
 
     WebGLIntArray *wgia = new WebGLIntArray(js.ctx, arrayObj, arrayLen);
     if (wgia)
         NS_ADDREF(*retval = wgia);
     return NS_OK;
 }
 
-/* nsIWebGLUnsignedByteArray createUnsignedByteArray (); */
+/* nsICanvasUnsignedIntArray createUnsignedIntArray (); */
 NS_IMETHODIMP
-WebGLContext::CreateUnsignedIntArray(nsIWebGLUnsignedIntArray **retval)
+WebGLContext::CreateUnsignedIntArray(nsICanvasUnsignedIntArray **retval)
 {
     NativeJSContext js;
 
     if (js.argc != 1)
         return NS_ERROR_DOM_SYNTAX_ERR;
 
     JSObject *arrayObj;
     jsuint arrayLen;
@@ -503,17 +503,17 @@ GL_SAME_METHOD_1(BlendEquation, BlendEqu
 
 GL_SAME_METHOD_2(BlendEquationSeparate, BlendEquationSeparate, PRUint32, PRUint32)
 
 GL_SAME_METHOD_2(BlendFunc, BlendFunc, PRUint32, PRUint32)
 
 GL_SAME_METHOD_4(BlendFuncSeparate, BlendFuncSeparate, PRUint32, PRUint32, PRUint32, PRUint32)
 
 NS_IMETHODIMP
-WebGLContext::BufferData(GLenum target, nsIWebGLArray *na, GLenum usage)
+WebGLContext::BufferData(GLenum target, nsICanvasArray *na, GLenum usage)
 {
     WebGLBuffer *boundBuffer = NULL;
 
     if (target == LOCAL_GL_ARRAY_BUFFER) {
         boundBuffer = mBoundArrayBuffer;
     } else if (target == LOCAL_GL_ELEMENT_ARRAY_BUFFER) {
         if (na->NativeType() != LOCAL_GL_UNSIGNED_SHORT)
             return ErrorMessage("glBufferData: %x - GL_ELEMENT_ARRAY_BUFFER target must be used with UnsignedShortBuffer", na->NativeType());
@@ -532,17 +532,17 @@ WebGLContext::BufferData(GLenum target, 
     boundBuffer->Set(na);
 
     gl->fBufferData(target, na->NativeSize(), na->NativePointer(), usage);
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
-WebGLContext::BufferSubData(GLenum target, GLuint offset, nsIWebGLArray *na)
+WebGLContext::BufferSubData(GLenum target, GLuint offset, nsICanvasArray *na)
 {
     WebGLBuffer *boundBuffer = NULL;
 
     if (target == LOCAL_GL_ARRAY_BUFFER) {
         boundBuffer = mBoundArrayBuffer;
     } else if (target == LOCAL_GL_ELEMENT_ARRAY_BUFFER) {
         boundBuffer = mBoundElementArrayBuffer;
     } else {
@@ -1741,19 +1741,19 @@ WebGLContext::GetTexParameterf(GLenum ta
 
         default:
             return NS_ERROR_NOT_IMPLEMENTED;
     }
 
     return NS_OK;
 }
 
-/* nsIWebGLArray getTexParameterfv (in GLenum target, in GLenum pname); */
+/* nsICanvasArray getTexParameterfv (in GLenum target, in GLenum pname); */
 NS_IMETHODIMP
-WebGLContext::GetTexParameterfv(GLenum target, GLenum pname, nsIWebGLArray **retval)
+WebGLContext::GetTexParameterfv(GLenum target, GLenum pname, nsICanvasArray **retval)
 {
     NativeJSContext js;
     if (NS_FAILED(js.error))
         return js.error;
 
     MakeContextCurrent();
 
     switch (pname) {
@@ -1798,19 +1798,19 @@ WebGLContext::GetTexParameteri(GLenum ta
 
         default:
             return NS_ERROR_NOT_IMPLEMENTED;
     }
 
     return NS_OK;
 }
 
-/* nsIWebGLArray getTexParameteriv (in GLenum target, in GLenum pname); */
+/* nsICanvasArray getTexParameteriv (in GLenum target, in GLenum pname); */
 NS_IMETHODIMP
-WebGLContext::GetTexParameteriv(GLenum target, GLenum pname, nsIWebGLArray **retval)
+WebGLContext::GetTexParameteriv(GLenum target, GLenum pname, nsICanvasArray **retval)
 {
     NativeJSContext js;
     if (NS_FAILED(js.error))
         return js.error;
 
     MakeContextCurrent();
 
     switch (pname) {
@@ -1876,32 +1876,32 @@ WebGLContext::GetUniformf(nsIWebGLProgra
         gl->fGetUniformiv(program, location, iv);
         js.SetRetVal((PRInt32*)iv, unitSize);
     } else {
         js.SetRetValAsJSVal(JSVAL_NULL);
     }
 
     return NS_OK;
 }
-/* nsIWebGLArray getUniformfv (in nsIWebGLProgram program, in GLint location); */
+/* nsICanvasArray getUniformfv (in nsIWebGLProgram program, in GLint location); */
 NS_IMETHODIMP
-WebGLContext::GetUniformfv(nsIWebGLProgram *program, GLint location, nsIWebGLArray **retval)
+WebGLContext::GetUniformfv(nsIWebGLProgram *program, GLint location, nsICanvasArray **retval)
 {
     return NS_ERROR_NOT_IMPLEMENTED;
 }
 /* GLint getUniformi (in nsIWebGLProgram program, in GLint location); */
 NS_IMETHODIMP
 WebGLContext::GetUniformi(nsIWebGLProgram *program, GLint location, GLint *retval)
 {
     return NS_ERROR_NOT_IMPLEMENTED;
 }
 
-/* nsIWebGLArray getUniformiv (in nsIWebGLProgram program, in GLint location); */
+/* nsICanvasArray getUniformiv (in nsIWebGLProgram program, in GLint location); */
 NS_IMETHODIMP
-WebGLContext::GetUniformiv(nsIWebGLProgram *program, GLint location, nsIWebGLArray **retval)
+WebGLContext::GetUniformiv(nsIWebGLProgram *program, GLint location, nsICanvasArray **retval)
 {
     return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 WebGLContext::GetUniformLocation(nsIWebGLProgram *prog, const nsAString& name, GLint *retval)
 {
     if (!prog || static_cast<WebGLProgram*>(prog)->Deleted())
@@ -1952,17 +1952,17 @@ WebGLContext::GetVertexAttribf(GLuint in
             return NS_ERROR_NOT_IMPLEMENTED;
 
     }
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
-WebGLContext::GetVertexAttribfv(GLuint index, GLenum pname, nsIWebGLArray **retval)
+WebGLContext::GetVertexAttribfv(GLuint index, GLenum pname, nsICanvasArray **retval)
 {
     return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 WebGLContext::GetVertexAttribi(GLuint index, GLenum pname, GLint *retval)
 {
     NativeJSContext js;
@@ -2000,17 +2000,17 @@ WebGLContext::GetVertexAttribi(GLuint in
             return NS_ERROR_NOT_IMPLEMENTED;
 
     }
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
-WebGLContext::GetVertexAttribiv(GLuint index, GLenum pname, nsIWebGLArray **retval)
+WebGLContext::GetVertexAttribiv(GLuint index, GLenum pname, nsICanvasArray **retval)
 {
     return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 /* GLuint getVertexAttribOffset (in GLuint index, in GLenum pname); */
 NS_IMETHODIMP
 WebGLContext::GetVertexAttribOffset(GLuint index, GLenum pname, GLuint *retval)
 {
@@ -2397,17 +2397,17 @@ GL_SAME_METHOD_5(Uniform4i, Uniform4i, G
 GL_SAME_METHOD_2(Uniform1f, Uniform1f, GLint, GLfloat)
 GL_SAME_METHOD_3(Uniform2f, Uniform2f, GLint, GLfloat, GLfloat)
 GL_SAME_METHOD_4(Uniform3f, Uniform3f, GLint, GLfloat, GLfloat, GLfloat)
 GL_SAME_METHOD_5(Uniform4f, Uniform4f, GLint, GLfloat, GLfloat, GLfloat, GLfloat)
 
 // one uint arg followed by an array of c elements of glTypeConst.
 #define GL_SIMPLE_ARRAY_METHOD(glname, name, c, glTypeConst, ptrType)             \
 NS_IMETHODIMP                                                                     \
-WebGLContext::name(GLint idx, nsIWebGLArray *v)                                   \
+WebGLContext::name(GLint idx, nsICanvasArray *v)                                   \
 {                                                                                 \
     NativeJSContext js;                                                           \
     if (NS_FAILED(js.error))                                                      \
         return js.error;                                                          \
     JSObject *arrayObj;                                                           \
     jsuint arrayLen;                                                              \
     if (js.argc != 2)                                                             \
         return NS_ERROR_INVALID_ARG;                                              \
@@ -2445,17 +2445,17 @@ WebGLContext::name(GLint idx, nsIWebGLAr
             return ErrorMessage("Unhandled glTypeConst"); /* need compiler fail */\
         }                                                                         \
     }                                                                             \
     return NS_OK;                                                                 \
 }
 
 #define GL_SIMPLE_ARRAY_METHOD_NO_COUNT(glname, name, c, glTypeConst, ptrType)    \
 NS_IMETHODIMP                                                                     \
-WebGLContext::name(GLuint idx, nsIWebGLArray *v)                                  \
+WebGLContext::name(GLuint idx, nsICanvasArray *v)                                  \
 {                                                                                 \
     NativeJSContext js;                                                           \
     if (NS_FAILED(js.error))                                                      \
         return js.error;                                                          \
     JSObject *arrayObj;                                                           \
     jsuint arrayLen;                                                              \
     if (js.argc != 2)                                                             \
         return NS_ERROR_INVALID_ARG;                                              \
@@ -2493,17 +2493,17 @@ WebGLContext::name(GLuint idx, nsIWebGLA
             return ErrorMessage("Unhandled glTypeConst"); /* need compiler fail */\
         }                                                                         \
     }                                                                             \
     return NS_OK;                                                                 \
 }
 
 #define GL_SIMPLE_MATRIX_METHOD(glname, name, c, glTypeConst, ptrType)            \
 NS_IMETHODIMP                                                                     \
-WebGLContext::name(GLint location, GLboolean transpose, nsIWebGLArray *value)     \
+WebGLContext::name(GLint location, GLboolean transpose, nsICanvasArray *value)     \
 {                                                                                 \
     NativeJSContext js;                                                           \
     if (NS_FAILED(js.error))                                                      \
         return js.error;                                                          \
     JSObject *arrayObj;                                                           \
     jsuint arrayLen;                                                              \
     if (js.argc != 3)                                                             \
         return NS_ERROR_INVALID_ARG;                                              \
@@ -2675,19 +2675,19 @@ WebGLContext::GetShaderi(nsIWebGLShader 
 
         default:
             return NS_ERROR_NOT_IMPLEMENTED;
     }
 
     return NS_OK;
 }
 
-/* nsIWebGLIntArray getShaderiv (in nsIWebGLShader shader, in GLenum pname); */
+/* nsICanvasIntArray getShaderiv (in nsIWebGLShader shader, in GLenum pname); */
 NS_IMETHODIMP
-WebGLContext::GetShaderiv(nsIWebGLShader *shader, GLenum pname, nsIWebGLIntArray **retval)
+WebGLContext::GetShaderiv(nsIWebGLShader *shader, GLenum pname, nsICanvasIntArray **retval)
 {
     return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 WebGLContext::GetShaderInfoLog(nsIWebGLShader *shobj, nsAString& retval)
 {
     if (!shobj || static_cast<WebGLShader*>(shobj)->Deleted())
--- a/dom/base/nsDOMClassInfo.cpp
+++ b/dom/base/nsDOMClassInfo.cpp
@@ -1321,29 +1321,29 @@ static nsDOMClassInfoData sClassInfoData
   NS_DEFINE_CLASSINFO_DATA(WebGLProgram, nsDOMGenericSH,
                            DOM_DEFAULT_SCRIPTABLE_FLAGS)
   NS_DEFINE_CLASSINFO_DATA(WebGLShader, nsDOMGenericSH,
                            DOM_DEFAULT_SCRIPTABLE_FLAGS)
   NS_DEFINE_CLASSINFO_DATA(WebGLFramebuffer, nsDOMGenericSH,
                            DOM_DEFAULT_SCRIPTABLE_FLAGS)
   NS_DEFINE_CLASSINFO_DATA(WebGLRenderbuffer, nsDOMGenericSH,
                            DOM_DEFAULT_SCRIPTABLE_FLAGS)
-  NS_DEFINE_CLASSINFO_DATA(WebGLFloatArray, nsDOMGenericSH,
-                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
-  NS_DEFINE_CLASSINFO_DATA(WebGLByteArray, nsDOMGenericSH,
-                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
-  NS_DEFINE_CLASSINFO_DATA(WebGLUnsignedByteArray, nsDOMGenericSH,
-                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
-  NS_DEFINE_CLASSINFO_DATA(WebGLShortArray, nsDOMGenericSH,
-                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
-  NS_DEFINE_CLASSINFO_DATA(WebGLUnsignedShortArray, nsDOMGenericSH,
-                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
-  NS_DEFINE_CLASSINFO_DATA(WebGLIntArray, nsDOMGenericSH,
-                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
-  NS_DEFINE_CLASSINFO_DATA(WebGLUnsignedIntArray, nsDOMGenericSH,
+  NS_DEFINE_CLASSINFO_DATA(CanvasFloatArray, nsDOMGenericSH,
+                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
+  NS_DEFINE_CLASSINFO_DATA(CanvasByteArray, nsDOMGenericSH,
+                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
+  NS_DEFINE_CLASSINFO_DATA(CanvasUnsignedByteArray, nsDOMGenericSH,
+                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
+  NS_DEFINE_CLASSINFO_DATA(CanvasShortArray, nsDOMGenericSH,
+                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
+  NS_DEFINE_CLASSINFO_DATA(CanvasUnsignedShortArray, nsDOMGenericSH,
+                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
+  NS_DEFINE_CLASSINFO_DATA(CanvasIntArray, nsDOMGenericSH,
+                           DOM_DEFAULT_SCRIPTABLE_FLAGS)
+  NS_DEFINE_CLASSINFO_DATA(CanvasUnsignedIntArray, nsDOMGenericSH,
                            DOM_DEFAULT_SCRIPTABLE_FLAGS)
 };
 
 // Objects that shuld be constructable through |new Name();|
 struct nsContractIDMapData
 {
   PRInt32 mDOMClassInfoID;
   const char *mContractID;
@@ -1371,23 +1371,23 @@ struct nsConstructorFuncMapData
 #define NS_DEFINE_CONSTRUCTOR_FUNC_DATA(_class, _func)                        \
   { eDOMClassInfo_##_class##_id, _func },
 
 static const nsConstructorFuncMapData kConstructorFuncMap[] =
 {
   NS_DEFINE_CONSTRUCTOR_FUNC_DATA(Worker, nsDOMWorker::NewWorker)
 
   // WebGL Array Types
-  NS_DEFINE_CONSTRUCTOR_FUNC_DATA(WebGLFloatArray, NS_NewCanvasFloatArray)
-  NS_DEFINE_CONSTRUCTOR_FUNC_DATA(WebGLByteArray, NS_NewCanvasByteArray)
-  NS_DEFINE_CONSTRUCTOR_FUNC_DATA(WebGLUnsignedByteArray, NS_NewCanvasUnsignedByteArray)
-  NS_DEFINE_CONSTRUCTOR_FUNC_DATA(WebGLShortArray, NS_NewCanvasShortArray)
-  NS_DEFINE_CONSTRUCTOR_FUNC_DATA(WebGLUnsignedShortArray, NS_NewCanvasUnsignedShortArray)
-  NS_DEFINE_CONSTRUCTOR_FUNC_DATA(WebGLIntArray, NS_NewCanvasIntArray)
-  NS_DEFINE_CONSTRUCTOR_FUNC_DATA(WebGLUnsignedIntArray, NS_NewCanvasUnsignedIntArray)
+  NS_DEFINE_CONSTRUCTOR_FUNC_DATA(CanvasFloatArray, NS_NewCanvasFloatArray)
+  NS_DEFINE_CONSTRUCTOR_FUNC_DATA(CanvasByteArray, NS_NewCanvasByteArray)
+  NS_DEFINE_CONSTRUCTOR_FUNC_DATA(CanvasUnsignedByteArray, NS_NewCanvasUnsignedByteArray)
+  NS_DEFINE_CONSTRUCTOR_FUNC_DATA(CanvasShortArray, NS_NewCanvasShortArray)
+  NS_DEFINE_CONSTRUCTOR_FUNC_DATA(CanvasUnsignedShortArray, NS_NewCanvasUnsignedShortArray)
+  NS_DEFINE_CONSTRUCTOR_FUNC_DATA(CanvasIntArray, NS_NewCanvasIntArray)
+  NS_DEFINE_CONSTRUCTOR_FUNC_DATA(CanvasUnsignedIntArray, NS_NewCanvasUnsignedIntArray)
 };
 
 nsIXPConnect *nsDOMClassInfo::sXPConnect = nsnull;
 nsIScriptSecurityManager *nsDOMClassInfo::sSecMan = nsnull;
 PRBool nsDOMClassInfo::sIsInitialized = PR_FALSE;
 PRBool nsDOMClassInfo::sDisableDocumentAllSupport = PR_FALSE;
 PRBool nsDOMClassInfo::sDisableGlobalScopePollutionSupport = PR_FALSE;
 
@@ -3654,42 +3654,42 @@ nsDOMClassInfo::Init()
   DOM_CLASSINFO_MAP_BEGIN(WebGLFramebuffer, nsIWebGLFramebuffer)
     DOM_CLASSINFO_MAP_ENTRY(nsIWebGLFramebuffer)
   DOM_CLASSINFO_MAP_END
 
   DOM_CLASSINFO_MAP_BEGIN(WebGLRenderbuffer, nsIWebGLRenderbuffer)
     DOM_CLASSINFO_MAP_ENTRY(nsIWebGLRenderbuffer)
   DOM_CLASSINFO_MAP_END
 
-  DOM_CLASSINFO_MAP_BEGIN(WebGLFloatArray, nsIWebGLFloatArray)
-    DOM_CLASSINFO_MAP_ENTRY(nsIWebGLFloatArray)
-  DOM_CLASSINFO_MAP_END
-
-  DOM_CLASSINFO_MAP_BEGIN(WebGLByteArray, nsIWebGLByteArray)
-    DOM_CLASSINFO_MAP_ENTRY(nsIWebGLByteArray)
-  DOM_CLASSINFO_MAP_END
-
-  DOM_CLASSINFO_MAP_BEGIN(WebGLUnsignedByteArray, nsIWebGLUnsignedByteArray)
-    DOM_CLASSINFO_MAP_ENTRY(nsIWebGLUnsignedByteArray)
-  DOM_CLASSINFO_MAP_END
-
-  DOM_CLASSINFO_MAP_BEGIN(WebGLShortArray, nsIWebGLShortArray)
-    DOM_CLASSINFO_MAP_ENTRY(nsIWebGLShortArray)
-  DOM_CLASSINFO_MAP_END
-
-  DOM_CLASSINFO_MAP_BEGIN(WebGLUnsignedShortArray, nsIWebGLUnsignedShortArray)
-    DOM_CLASSINFO_MAP_ENTRY(nsIWebGLUnsignedShortArray)
-  DOM_CLASSINFO_MAP_END
-
-  DOM_CLASSINFO_MAP_BEGIN(WebGLIntArray, nsIWebGLIntArray)
-    DOM_CLASSINFO_MAP_ENTRY(nsIWebGLIntArray)
-  DOM_CLASSINFO_MAP_END
-
-  DOM_CLASSINFO_MAP_BEGIN(WebGLUnsignedIntArray, nsIWebGLUnsignedIntArray)
-    DOM_CLASSINFO_MAP_ENTRY(nsIWebGLUnsignedIntArray)
+  DOM_CLASSINFO_MAP_BEGIN(CanvasFloatArray, nsICanvasFloatArray)
+    DOM_CLASSINFO_MAP_ENTRY(nsICanvasFloatArray)
+  DOM_CLASSINFO_MAP_END
+
+  DOM_CLASSINFO_MAP_BEGIN(CanvasByteArray, nsICanvasByteArray)
+    DOM_CLASSINFO_MAP_ENTRY(nsICanvasByteArray)
+  DOM_CLASSINFO_MAP_END
+
+  DOM_CLASSINFO_MAP_BEGIN(CanvasUnsignedByteArray, nsICanvasUnsignedByteArray)
+    DOM_CLASSINFO_MAP_ENTRY(nsICanvasUnsignedByteArray)
+  DOM_CLASSINFO_MAP_END
+
+  DOM_CLASSINFO_MAP_BEGIN(CanvasShortArray, nsICanvasShortArray)
+    DOM_CLASSINFO_MAP_ENTRY(nsICanvasShortArray)
+  DOM_CLASSINFO_MAP_END
+
+  DOM_CLASSINFO_MAP_BEGIN(CanvasUnsignedShortArray, nsICanvasUnsignedShortArray)
+    DOM_CLASSINFO_MAP_ENTRY(nsICanvasUnsignedShortArray)
+  DOM_CLASSINFO_MAP_END
+
+  DOM_CLASSINFO_MAP_BEGIN(CanvasIntArray, nsICanvasIntArray)
+    DOM_CLASSINFO_MAP_ENTRY(nsICanvasIntArray)
+  DOM_CLASSINFO_MAP_END
+
+  DOM_CLASSINFO_MAP_BEGIN(CanvasUnsignedIntArray, nsICanvasUnsignedIntArray)
+    DOM_CLASSINFO_MAP_ENTRY(nsICanvasUnsignedIntArray)
   DOM_CLASSINFO_MAP_END
 
 #ifdef NS_DEBUG
   {
     PRUint32 i = NS_ARRAY_LENGTH(sClassInfoData);
 
     if (i != eDOMClassInfoIDCount) {
       NS_ERROR("The number of items in sClassInfoData doesn't match the "
--- a/dom/base/nsDOMClassInfoID.h
+++ b/dom/base/nsDOMClassInfoID.h
@@ -466,23 +466,23 @@ enum nsDOMClassInfoID {
   eDOMClassInfo_WebGLBuffer_id,
   eDOMClassInfo_WebGLTexture_id,
   eDOMClassInfo_WebGLProgram_id,
   eDOMClassInfo_WebGLShader_id,
   eDOMClassInfo_WebGLFramebuffer_id,
   eDOMClassInfo_WebGLRenderbuffer_id,
 
   // WebGL Buffers
-  eDOMClassInfo_WebGLFloatArray_id,
-  eDOMClassInfo_WebGLByteArray_id,
-  eDOMClassInfo_WebGLUnsignedByteArray_id,
-  eDOMClassInfo_WebGLShortArray_id,
-  eDOMClassInfo_WebGLUnsignedShortArray_id,
-  eDOMClassInfo_WebGLIntArray_id,
-  eDOMClassInfo_WebGLUnsignedIntArray_id,
+  eDOMClassInfo_CanvasFloatArray_id,
+  eDOMClassInfo_CanvasByteArray_id,
+  eDOMClassInfo_CanvasUnsignedByteArray_id,
+  eDOMClassInfo_CanvasShortArray_id,
+  eDOMClassInfo_CanvasUnsignedShortArray_id,
+  eDOMClassInfo_CanvasIntArray_id,
+  eDOMClassInfo_CanvasUnsignedIntArray_id,
 
   // This one better be the last one in this list
   eDOMClassInfoIDCount
 };
 
 /**
  * nsIClassInfo helper macros
  */
--- a/dom/interfaces/canvas/nsICanvasRenderingContextWebGL.idl
+++ b/dom/interfaces/canvas/nsICanvasRenderingContextWebGL.idl
@@ -61,59 +61,59 @@ typedef long           GLfixed;
 //typedef unsigned long  GLintptr;
 //typedef unsigned long  GLsizeiptr;
 
 //
 // Array types
 //
 
 [scriptable, uuid(84ba4e98-8173-7c10-dca0-b5ba7809fcf3)]
-interface nsIWebGLArray : nsISupports
+interface nsICanvasArray : nsISupports
 {
   attribute unsigned long length;
 
   [noscript, notxpcom] unsigned long nativeType();
   [noscript, notxpcom] voidPtr nativePointer();
   [noscript, notxpcom] unsigned long nativeSize();
   [noscript, notxpcom] unsigned long nativeElementSize();
   [noscript, notxpcom] unsigned long nativeCount();
 };
 
 [scriptable, Uuid(0f6d0e7b-bcfc-9305-6a1d-a9653b5e8c80)]
-interface nsIWebGLFloatArray : nsIWebGLArray
+interface nsICanvasFloatArray : nsICanvasArray
 {
 };
 
 [scriptable, uuid(b29db7cf-fa58-435f-8d45-611cc50979ad)]
-interface nsIWebGLByteArray : nsIWebGLArray
+interface nsICanvasByteArray : nsICanvasArray
 {
 };
 
 [scriptable, uuid(3daa67fa-e743-2cbd-a212-805c2fc520cc)]
-interface nsIWebGLUnsignedByteArray : nsIWebGLArray
+interface nsICanvasUnsignedByteArray : nsICanvasArray
 {
 };
 
 [scriptable, uuid(a8a982e3-3977-7364-f012-c497a5ab7681)]
-interface nsIWebGLShortArray : nsIWebGLArray
+interface nsICanvasShortArray : nsICanvasArray
 {
 };
 
 [scriptable, uuid(8b9c67cc-c7be-a062-84b0-76a910a5c1e6)]
-interface nsIWebGLUnsignedShortArray : nsIWebGLArray
+interface nsICanvasUnsignedShortArray : nsICanvasArray
 {
 };
 
 [scriptable, uuid(b9b2e861-3a28-4311-993c-799e4f77dcba)]
-interface nsIWebGLIntArray : nsIWebGLArray
+interface nsICanvasIntArray : nsICanvasArray
 {
 };
 
 [scriptable, uuid(0d6ee3f8-71b6-460d-b05a-d579cc55edbe)]
-interface nsIWebGLUnsignedIntArray : nsIWebGLArray
+interface nsICanvasUnsignedIntArray : nsICanvasArray
 {
 };
 
 //
 // OpenGL object wrappers
 //
 
 [scriptable, uuid(3b43762a-8305-11de-98ab-000c29206271)]
@@ -168,23 +168,23 @@ interface nsIWebGLActiveInfo {
 
 [scriptable, uuid(f02c85e0-8305-11de-abe2-000c29206271)]
 interface nsICanvasRenderingContextWebGL : nsISupports
 {
   //
   //  ARRAY CONSTRUCTORS
   //
 
-  nsIWebGLFloatArray createFloatArray();
-  nsIWebGLByteArray createByteArray();
-  nsIWebGLUnsignedByteArray createUnsignedByteArray();
-  nsIWebGLShortArray createShortArray();
-  nsIWebGLUnsignedShortArray createUnsignedShortArray();
-  nsIWebGLIntArray createIntArray();
-  nsIWebGLUnsignedIntArray createUnsignedIntArray();
+  nsICanvasFloatArray createFloatArray();
+  nsICanvasByteArray createByteArray();
+  nsICanvasUnsignedByteArray createUnsignedByteArray();
+  nsICanvasShortArray createShortArray();
+  nsICanvasUnsignedShortArray createUnsignedShortArray();
+  nsICanvasIntArray createIntArray();
+  nsICanvasUnsignedIntArray createUnsignedIntArray();
 
   //
   //  CONSTANTS
   //
 
   /* ClearBufferMask */
   const unsigned long DEPTH_BUFFER_BIT               = 0x00000100;
   const unsigned long STENCIL_BUFFER_BIT             = 0x00000400;
@@ -635,20 +635,20 @@ interface nsICanvasRenderingContextWebGL
   void blendColor (in GLclampf red, in GLclampf green, in GLclampf blue, in GLclampf alpha);
   void blendEquation (in GLenum mode);
   void blendEquationSeparate (in GLenum modeRGB, in GLenum modeAlpha);
   void blendFunc (in GLenum sfactor, in GLenum dfactor);
   void blendFuncSeparate (in GLenum srcRGB, in GLenum dstRGB, in GLenum srcAlpha, in GLenum dstAlpha);
 
   // Modified: void glBufferData (GLenum target, GLsizeiptr size, const void* data, GLenum usage);
   // void bufferData (in GLenum target, in GLsizei size, in GLenum usage);
-  void bufferData (in GLenum target, in nsIWebGLArray data, in GLenum usage);
+  void bufferData (in GLenum target, in nsICanvasArray data, in GLenum usage);
 
   // Modified: void glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const void* data);
-  void bufferSubData (in GLenum target, in GLuint offset, in nsIWebGLArray data);
+  void bufferSubData (in GLenum target, in GLuint offset, in nsICanvasArray data);
 
   GLenum checkFramebufferStatus (in GLenum target);
   void clear (in GLbitfield mask);
   void clearColor (in GLclampf red, in GLclampf green, in GLclampf blue, in GLclampf alpha);
   void clearDepthf (in GLclampf depth);
   void clearStencil (in GLint s);
   void colorMask (in GLboolean red, in GLboolean green, in GLboolean blue, in GLboolean alpha);
   void compileShader (in nsIWebGLShader shader);
@@ -737,49 +737,49 @@ interface nsICanvasRenderingContextWebGL
   // Modified: void glGetProgramInfoLog (GLuint program, GLsizei bufsize, GLsizei* length, char* infolog);
   DOMString getProgramInfoLog (in nsIWebGLProgram program);
 
   // Modified: void glGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint* params);
   //nsIWebGLIntArray getRenderbufferParameteriv (in GLenum target, in GLenum pname);
   GLint getRenderbufferParameteri (in GLenum target, in GLenum pname);
 
   GLint getShaderi (in nsIWebGLShader shader, in GLenum pname);
-  nsIWebGLIntArray getShaderiv (in nsIWebGLShader shader, in GLenum pname);
+  nsICanvasIntArray getShaderiv (in nsIWebGLShader shader, in GLenum pname);
   // GONE void getShaderParameter (in nsIWebGLShader shader, in GLenum pname);
 
   // Modified: void glGetShaderInfoLog (GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog);
   DOMString getShaderInfoLog (in nsIWebGLShader shader);
 
   // TBD
   //void glGetShaderPrecisionFormat (GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
 
   DOMString getShaderSource (in nsIWebGLShader shader);
   DOMString getString (in GLenum name);
 
   GLfloat getTexParameterf (in GLenum target, in GLenum pname);
-  nsIWebGLArray getTexParameterfv (in GLenum target, in GLenum pname);
+  nsICanvasArray getTexParameterfv (in GLenum target, in GLenum pname);
   GLint getTexParameteri (in GLenum target, in GLenum pname);
-  nsIWebGLArray getTexParameteriv (in GLenum target, in GLenum pname);
+  nsICanvasArray getTexParameteriv (in GLenum target, in GLenum pname);
 
   // FIXME: This is problematic. We don't implicitly know how big the returned data buffer
   // needs to be like in the other glGet* calls. The only way to find out is to iterate 
   // through all the active uniforms with glGetActiveUniform() looking for the corresponding
   // 'location'. This will give us the type and size of the data. Since this is a get call
   // maybe that's ok?
   GLfloat getUniformf (in nsIWebGLProgram program, in GLint location);
-  nsIWebGLArray getUniformfv (in nsIWebGLProgram program, in GLint location);
+  nsICanvasArray getUniformfv (in nsIWebGLProgram program, in GLint location);
   GLint getUniformi (in nsIWebGLProgram program, in GLint location);
-  nsIWebGLArray getUniformiv (in nsIWebGLProgram program, in GLint location);
+  nsICanvasArray getUniformiv (in nsIWebGLProgram program, in GLint location);
 
   GLint getUniformLocation (in nsIWebGLProgram program, in DOMString name);
 
   GLfloat getVertexAttribf (in GLuint index, in GLenum pname);
-  nsIWebGLArray getVertexAttribfv (in GLuint index, in GLenum pname);
+  nsICanvasArray getVertexAttribfv (in GLuint index, in GLenum pname);
   GLint getVertexAttribi (in GLuint index, in GLenum pname);
-  nsIWebGLArray getVertexAttribiv (in GLuint index, in GLenum pname);
+  nsICanvasArray getVertexAttribiv (in GLuint index, in GLenum pname);
 
   // TBD
   // void glGetVertexAttribPointerv (GLuint index, GLenum pname, void** pointer);
   GLuint getVertexAttribOffset(in GLuint index, in GLenum pname);
 
   void hint (in GLenum target, in GLenum mode);
 
   GLboolean isBuffer (in nsIWebGLBuffer buffer);
@@ -832,56 +832,56 @@ interface nsICanvasRenderingContextWebGL
   // Modified: void glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels);
   //void glTexSubImage2D (in GLenum target, in GLint level, in GLint xoffset, in GLint yoffset, in GLsizei width, in GLsizei height, in GLenum format, in GLenum type, nsIWebGLArray pixels);
   //void glTexSubImage2D (in GLenum target, in GLint level, in GLint xoffset, in GLint yoffset, in GLsizei width, in GLsizei height, in HTMLImageElement image);
   //void glTexSubImage2D (in GLenum target, in GLint level, in GLint xoffset, in GLint yoffset, in GLsizei width, in GLsizei height, in HTMLnsIWebGLElement canvas);
   //void glTexSubImage2D (in GLenum target, in GLint level, in GLint xoffset, in GLint yoffset, in GLsizei width, in GLsizei height, in HTMLVideoElement video);
 
   void texSubImage2D ();
 
-  // Modified: All the glUniform*v forms below are modified by replacing 'count' and 'v' with a nsIWebGLArray
+  // Modified: All the glUniform*v forms below are modified by replacing 'count' and 'v' with a nsICanvasArray
   void uniform1f (in GLint location, in GLfloat x);
   void uniform1i (in GLint location, in GLint x);
   void uniform2f (in GLint location, in GLfloat x, in GLfloat y);
   void uniform2i (in GLint location, in GLint x, in GLint y);
   void uniform3f (in GLint location, in GLfloat x, in GLfloat y, in GLfloat z);
   void uniform3i (in GLint location, in GLint x, in GLint y, in GLint z);
   void uniform4f (in GLint location, in GLfloat x, in GLfloat y, in GLfloat z, in GLfloat w);
   void uniform4i (in GLint location, in GLint x, in GLint y, in GLint z, in GLint w);
 
-  void uniform1fv (in GLint location, in nsIWebGLArray v);
-  void uniform1iv (in GLint location, in nsIWebGLArray v);
-  void uniform2fv (in GLint location, in nsIWebGLArray v);
-  void uniform2iv (in GLint location, in nsIWebGLArray v);
-  void uniform3fv (in GLint location, in nsIWebGLArray v);
-  void uniform3iv (in GLint location, in nsIWebGLArray v);
-  void uniform4fv (in GLint location, in nsIWebGLArray v);
-  void uniform4iv (in GLint location, in nsIWebGLArray v);
+  void uniform1fv (in GLint location, in nsICanvasArray v);
+  void uniform1iv (in GLint location, in nsICanvasArray v);
+  void uniform2fv (in GLint location, in nsICanvasArray v);
+  void uniform2iv (in GLint location, in nsICanvasArray v);
+  void uniform3fv (in GLint location, in nsICanvasArray v);
+  void uniform3iv (in GLint location, in nsICanvasArray v);
+  void uniform4fv (in GLint location, in nsICanvasArray v);
+  void uniform4iv (in GLint location, in nsICanvasArray v);
 
-  // Modified. These are modified by replacing 'count' and 'value' with a nsIWebGLArray
-  void uniformMatrix2fv (in GLint location, in GLboolean transpose, in nsIWebGLArray value);
-  void uniformMatrix3fv (in GLint location, in GLboolean transpose, in nsIWebGLArray value);
-  void uniformMatrix4fv (in GLint location, in GLboolean transpose, in nsIWebGLArray value);
+  // Modified. These are modified by replacing 'count' and 'value' with a nsICanvasArray
+  void uniformMatrix2fv (in GLint location, in GLboolean transpose, in nsICanvasArray value);
+  void uniformMatrix3fv (in GLint location, in GLboolean transpose, in nsICanvasArray value);
+  void uniformMatrix4fv (in GLint location, in GLboolean transpose, in nsICanvasArray value);
 
   // Added API using top entry from the passed nsIWebGLMatrixStack
   //ZZ void glUniformMatrix (in GLint location, in GLboolean transpose, in nsIWebGLMatrixStack value);
 
   void useProgram (in nsIWebGLProgram program);
   void validateProgram (in nsIWebGLProgram program);
 
-  // Modified: All the glVertexAttrib*v forms below are modified by replacing 'values' with a nsIWebGLArray
+  // Modified: All the glVertexAttrib*v forms below are modified by replacing 'values' with a nsICanvasArray
   void vertexAttrib1f (in GLuint indx, in GLfloat x);
   void vertexAttrib2f (in GLuint indx, in GLfloat x, in GLfloat y);
   void vertexAttrib3f (in GLuint indx, in GLfloat x, in GLfloat y, in GLfloat z);
   void vertexAttrib4f (in GLuint indx, in GLfloat x, in GLfloat y, in GLfloat z, in GLfloat w);
 
-  void vertexAttrib1fv (in GLuint indx, in nsIWebGLArray values);
-  void vertexAttrib2fv (in GLuint indx, in nsIWebGLArray values);
-  void vertexAttrib3fv (in GLuint indx, in nsIWebGLArray values);
-  void vertexAttrib4fv (in GLuint indx, in nsIWebGLArray values);
+  void vertexAttrib1fv (in GLuint indx, in nsICanvasArray values);
+  void vertexAttrib2fv (in GLuint indx, in nsICanvasArray values);
+  void vertexAttrib3fv (in GLuint indx, in nsICanvasArray values);
+  void vertexAttrib4fv (in GLuint indx, in nsICanvasArray values);
 
   // TBD
   //void glVertexAttribPointer (in GLuint indx, GLint size, GLenum type, GLboolean normalized, 
   // GLsizei stride, const void* ptr);
 
   // size is number of elements; type must match the bound vbo type; offset is in elements
   void vertexAttribPointer (in GLuint idx, in GLint size, in GLenum type, in GLboolean normalized, in GLuint stride, in GLuint offset);