[V8] Pass Isolate to throwNotEnoughArgumentsError()
[WebKit-https.git] / Source / WebCore / bindings / v8 / custom / V8WebGLRenderingContextCustom.cpp
1 /*
2  * Copyright (C) 2009 Google Inc. All rights reserved.
3  * 
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  * 
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  * 
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32
33 #if ENABLE(WEBGL)
34
35 #include "V8WebGLRenderingContext.h"
36
37 #include "ExceptionCode.h"
38 #include "NotImplemented.h"
39 #include "V8ArrayBufferView.h"
40 #include "V8Binding.h"
41 #include "V8BindingMacros.h"
42 #include "V8EXTTextureFilterAnisotropic.h"
43 #include "V8Float32Array.h"
44 #include "V8HTMLCanvasElement.h"
45 #include "V8HTMLImageElement.h"
46 #include "V8HTMLVideoElement.h"
47 #include "V8ImageData.h"
48 #include "V8Int16Array.h"
49 #include "V8Int32Array.h"
50 #include "V8Int8Array.h"
51 #include "V8OESStandardDerivatives.h"
52 #include "V8OESTextureFloat.h"
53 #include "V8OESVertexArrayObject.h"
54 #include "V8Proxy.h"
55 #include "V8Uint16Array.h"
56 #include "V8Uint32Array.h"
57 #include "V8Uint8Array.h"
58 #include "V8WebGLBuffer.h"
59 #include "V8WebGLCompressedTextureS3TC.h"
60 #include "V8WebGLDebugRendererInfo.h"
61 #include "V8WebGLDebugShaders.h"
62 #include "V8WebGLFramebuffer.h"
63 #include "V8WebGLLoseContext.h"
64 #include "V8WebGLProgram.h"
65 #include "V8WebGLRenderbuffer.h"
66 #include "V8WebGLShader.h"
67 #include "V8WebGLTexture.h"
68 #include "V8WebGLUniformLocation.h"
69 #include "V8WebGLVertexArrayObjectOES.h"
70 #include "WebGLRenderingContext.h"
71 #include <limits>
72 #include <wtf/FastMalloc.h>
73
74 namespace WebCore {
75
76 // Allocates new storage via tryFastMalloc.
77 // Returns NULL if array failed to convert for any reason.
78 static float* jsArrayToFloatArray(v8::Handle<v8::Array> array, uint32_t len)
79 {
80     // Convert the data element-by-element.
81     float* data = 0;
82     if (len > std::numeric_limits<uint32_t>::max() / sizeof(float)
83         || !tryFastMalloc(len * sizeof(float)).getValue(data))
84         return 0;
85     for (uint32_t i = 0; i < len; i++) {
86         v8::Local<v8::Value> val = array->Get(i);
87         if (!val->IsNumber()) {
88             fastFree(data);
89             return 0;
90         }
91         data[i] = toFloat(val);
92     }
93     return data;
94 }
95
96 // Allocates new storage via tryFastMalloc.
97 // Returns NULL if array failed to convert for any reason.
98 static int* jsArrayToIntArray(v8::Handle<v8::Array> array, uint32_t len)
99 {
100     // Convert the data element-by-element.
101     int* data = 0;
102     if (len > std::numeric_limits<uint32_t>::max() / sizeof(int)
103         || !tryFastMalloc(len * sizeof(int)).getValue(data))
104         return 0;
105     for (uint32_t i = 0; i < len; i++) {
106         v8::Local<v8::Value> val = array->Get(i);
107         bool ok;
108         int ival = toInt32(val, ok);
109         if (!ok) {
110             fastFree(data);
111             return 0;
112         }
113         data[i] = ival;
114     }
115     return data;
116 }
117
118 static v8::Handle<v8::Value> toV8Object(const WebGLGetInfo& info, v8::Isolate* isolate)
119 {
120     switch (info.getType()) {
121     case WebGLGetInfo::kTypeBool:
122         return v8::Boolean::New(info.getBool());
123     case WebGLGetInfo::kTypeBoolArray: {
124         const Vector<bool>& value = info.getBoolArray();
125         v8::Local<v8::Array> array = v8::Array::New(value.size());
126         for (size_t ii = 0; ii < value.size(); ++ii)
127             array->Set(v8::Integer::New(ii), v8::Boolean::New(value[ii]));
128         return array;
129     }
130     case WebGLGetInfo::kTypeFloat:
131         return v8::Number::New(info.getFloat());
132     case WebGLGetInfo::kTypeInt:
133         return v8::Integer::New(info.getInt());
134     case WebGLGetInfo::kTypeNull:
135         return v8::Null();
136     case WebGLGetInfo::kTypeString:
137         return v8::String::New(fromWebCoreString(info.getString()), info.getString().length());
138     case WebGLGetInfo::kTypeUnsignedInt:
139         return v8::Integer::NewFromUnsigned(info.getUnsignedInt());
140     case WebGLGetInfo::kTypeWebGLBuffer:
141         return toV8(info.getWebGLBuffer(), isolate);
142     case WebGLGetInfo::kTypeWebGLFloatArray:
143         return toV8(info.getWebGLFloatArray(), isolate);
144     case WebGLGetInfo::kTypeWebGLFramebuffer:
145         return toV8(info.getWebGLFramebuffer(), isolate);
146     case WebGLGetInfo::kTypeWebGLIntArray:
147         return toV8(info.getWebGLIntArray(), isolate);
148     // FIXME: implement WebGLObjectArray
149     // case WebGLGetInfo::kTypeWebGLObjectArray:
150     case WebGLGetInfo::kTypeWebGLProgram:
151         return toV8(info.getWebGLProgram(), isolate);
152     case WebGLGetInfo::kTypeWebGLRenderbuffer:
153         return toV8(info.getWebGLRenderbuffer(), isolate);
154     case WebGLGetInfo::kTypeWebGLTexture:
155         return toV8(info.getWebGLTexture(), isolate);
156     case WebGLGetInfo::kTypeWebGLUnsignedByteArray:
157         return toV8(info.getWebGLUnsignedByteArray(), isolate);
158     case WebGLGetInfo::kTypeWebGLUnsignedIntArray:
159         return toV8(info.getWebGLUnsignedIntArray(), isolate);
160     case WebGLGetInfo::kTypeWebGLVertexArrayObjectOES:
161         return toV8(info.getWebGLVertexArrayObjectOES(), isolate);
162     default:
163         notImplemented();
164         return v8::Undefined();
165     }
166 }
167
168 static v8::Handle<v8::Value> toV8Object(WebGLExtension* extension, v8::Handle<v8::Object> contextObject, v8::Isolate* isolate)
169 {
170     if (!extension)
171         return v8::Null();
172     v8::Handle<v8::Value> extensionObject;
173     const char* referenceName = 0;
174     switch (extension->getName()) {
175     case WebGLExtension::WebKitWebGLLoseContextName:
176         extensionObject = toV8(static_cast<WebGLLoseContext*>(extension), isolate);
177         referenceName = "webKitWebGLLoseContextName";
178         break;
179     case WebGLExtension::EXTTextureFilterAnisotropicName:
180         extensionObject = toV8(static_cast<EXTTextureFilterAnisotropic*>(extension), isolate);
181         referenceName = "extTextureFilterAnisotropicName";
182         break;
183     case WebGLExtension::OESStandardDerivativesName:
184         extensionObject = toV8(static_cast<OESStandardDerivatives*>(extension), isolate);
185         referenceName = "oesStandardDerivativesName";
186         break;
187     case WebGLExtension::OESTextureFloatName:
188         extensionObject = toV8(static_cast<OESTextureFloat*>(extension), isolate);
189         referenceName = "oesTextureFloatName";
190         break;
191     case WebGLExtension::OESVertexArrayObjectName:
192         extensionObject = toV8(static_cast<OESVertexArrayObject*>(extension), isolate);
193         referenceName = "oesVertexArrayObjectName";
194         break;
195     case WebGLExtension::WebGLDebugRendererInfoName:
196         extensionObject = toV8(static_cast<WebGLDebugRendererInfo*>(extension), isolate);
197         referenceName = "webGLDebugRendererInfoName";
198         break;
199     case WebGLExtension::WebGLDebugShadersName:
200         extensionObject = toV8(static_cast<WebGLDebugShaders*>(extension), isolate);
201         referenceName = "webGLDebugShadersName";
202         break;
203     case WebGLExtension::WebKitWebGLCompressedTextureS3TCName:
204         extensionObject = toV8(static_cast<WebGLCompressedTextureS3TC*>(extension), isolate);
205         referenceName = "webKitWebGLCompressedTextureS3TCName";
206         break;
207     }
208     ASSERT(!extensionObject.IsEmpty());
209     V8DOMWrapper::setNamedHiddenReference(contextObject, referenceName, extensionObject);
210     return extensionObject;
211 }
212
213 enum ObjectType {
214     kBuffer, kRenderbuffer, kTexture, kVertexAttrib
215 };
216
217 static v8::Handle<v8::Value> getObjectParameter(const v8::Arguments& args, ObjectType objectType)
218 {
219     if (args.Length() != 2)
220         return V8Proxy::throwNotEnoughArgumentsError(args.GetIsolate());
221
222     ExceptionCode ec = 0;
223     WebGLRenderingContext* context = V8WebGLRenderingContext::toNative(args.Holder());
224     unsigned target = toInt32(args[0]);
225     unsigned pname = toInt32(args[1]);
226     WebGLGetInfo info;
227     switch (objectType) {
228     case kBuffer:
229         info = context->getBufferParameter(target, pname, ec);
230         break;
231     case kRenderbuffer:
232         info = context->getRenderbufferParameter(target, pname, ec);
233         break;
234     case kTexture:
235         info = context->getTexParameter(target, pname, ec);
236         break;
237     case kVertexAttrib:
238         // target => index
239         info = context->getVertexAttrib(target, pname, ec);
240         break;
241     default:
242         notImplemented();
243         break;
244     }
245     if (ec) {
246         V8Proxy::setDOMException(ec, args.GetIsolate());
247         return v8::Undefined();
248     }
249     return toV8Object(info, args.GetIsolate());
250 }
251
252 static WebGLUniformLocation* toWebGLUniformLocation(v8::Handle<v8::Value> value, bool& ok)
253 {
254     ok = false;
255     WebGLUniformLocation* location = 0;
256     if (V8WebGLUniformLocation::HasInstance(value)) {
257         location = V8WebGLUniformLocation::toNative(value->ToObject());
258         ok = true;
259     }
260     return location;
261 }
262
263 enum WhichProgramCall {
264     kProgramParameter, kUniform
265 };
266
267 v8::Handle<v8::Value> V8WebGLRenderingContext::getAttachedShadersCallback(const v8::Arguments& args)
268 {
269     INC_STATS("DOM.WebGLRenderingContext.getAttachedShaders()");
270
271     if (args.Length() < 1)
272         return V8Proxy::throwNotEnoughArgumentsError(args.GetIsolate());
273
274     ExceptionCode ec = 0;
275     WebGLRenderingContext* context = V8WebGLRenderingContext::toNative(args.Holder());
276     if (args.Length() > 0 && !isUndefinedOrNull(args[0]) && !V8WebGLProgram::HasInstance(args[0])) {
277         V8Proxy::throwTypeError();
278         return notHandledByInterceptor();
279     }
280     WebGLProgram* program = V8WebGLProgram::HasInstance(args[0]) ? V8WebGLProgram::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0;
281     Vector<RefPtr<WebGLShader> > shaders;
282     bool succeed = context->getAttachedShaders(program, shaders, ec);
283     if (ec) {
284         V8Proxy::setDOMException(ec, args.GetIsolate());
285         return v8::Null();
286     }
287     if (!succeed)
288         return v8::Null();
289     v8::Local<v8::Array> array = v8::Array::New(shaders.size());
290     for (size_t ii = 0; ii < shaders.size(); ++ii)
291         array->Set(v8::Integer::New(ii), toV8(shaders[ii].get(), args.GetIsolate()));
292     return array;
293 }
294
295 v8::Handle<v8::Value> V8WebGLRenderingContext::getBufferParameterCallback(const v8::Arguments& args)
296 {
297     INC_STATS("DOM.WebGLRenderingContext.getBufferParameter()");
298     return getObjectParameter(args, kBuffer);
299 }
300
301 v8::Handle<v8::Value> V8WebGLRenderingContext::getExtensionCallback(const v8::Arguments& args)
302 {
303     INC_STATS("DOM.WebGLRenderingContext.getExtensionCallback()");
304     WebGLRenderingContext* imp = V8WebGLRenderingContext::toNative(args.Holder());
305     if (args.Length() < 1)
306         return V8Proxy::throwNotEnoughArgumentsError(args.GetIsolate());
307     STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, name, args[0]);
308     WebGLExtension* extension = imp->getExtension(name);
309     return toV8Object(extension, args.Holder(), args.GetIsolate());
310 }
311
312 v8::Handle<v8::Value> V8WebGLRenderingContext::getFramebufferAttachmentParameterCallback(const v8::Arguments& args)
313 {
314     INC_STATS("DOM.WebGLRenderingContext.getFramebufferAttachmentParameter()");
315
316     if (args.Length() != 3)
317         return V8Proxy::throwNotEnoughArgumentsError(args.GetIsolate());
318
319     ExceptionCode ec = 0;
320     WebGLRenderingContext* context = V8WebGLRenderingContext::toNative(args.Holder());
321     unsigned target = toInt32(args[0]);
322     unsigned attachment = toInt32(args[1]);
323     unsigned pname = toInt32(args[2]);
324     WebGLGetInfo info = context->getFramebufferAttachmentParameter(target, attachment, pname, ec);
325     if (ec) {
326         V8Proxy::setDOMException(ec, args.GetIsolate());
327         return v8::Undefined();
328     }
329     return toV8Object(info, args.GetIsolate());
330 }
331
332 v8::Handle<v8::Value> V8WebGLRenderingContext::getParameterCallback(const v8::Arguments& args)
333 {
334     INC_STATS("DOM.WebGLRenderingContext.getParameter()");
335
336     if (args.Length() != 1)
337         return V8Proxy::throwNotEnoughArgumentsError(args.GetIsolate());
338
339     ExceptionCode ec = 0;
340     WebGLRenderingContext* context = V8WebGLRenderingContext::toNative(args.Holder());
341     unsigned pname = toInt32(args[0]);
342     WebGLGetInfo info = context->getParameter(pname, ec);
343     if (ec) {
344         V8Proxy::setDOMException(ec, args.GetIsolate());
345         return v8::Undefined();
346     }
347     return toV8Object(info, args.GetIsolate());
348 }
349
350 v8::Handle<v8::Value> V8WebGLRenderingContext::getProgramParameterCallback(const v8::Arguments& args)
351 {
352     INC_STATS("DOM.WebGLRenderingContext.getProgramParameter()");
353
354     if (args.Length() != 2)
355         return V8Proxy::throwNotEnoughArgumentsError(args.GetIsolate());
356
357     ExceptionCode ec = 0;
358     WebGLRenderingContext* context = V8WebGLRenderingContext::toNative(args.Holder());
359     if (args.Length() > 0 && !isUndefinedOrNull(args[0]) && !V8WebGLProgram::HasInstance(args[0])) {
360         V8Proxy::throwTypeError();
361         return notHandledByInterceptor();
362     }
363     WebGLProgram* program = V8WebGLProgram::HasInstance(args[0]) ? V8WebGLProgram::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0;
364     unsigned pname = toInt32(args[1]);
365     WebGLGetInfo info = context->getProgramParameter(program, pname, ec);
366     if (ec) {
367         V8Proxy::setDOMException(ec, args.GetIsolate());
368         return v8::Undefined();
369     }
370     return toV8Object(info, args.GetIsolate());
371 }
372
373 v8::Handle<v8::Value> V8WebGLRenderingContext::getRenderbufferParameterCallback(const v8::Arguments& args)
374 {
375     INC_STATS("DOM.WebGLRenderingContext.getRenderbufferParameter()");
376     return getObjectParameter(args, kRenderbuffer);
377 }
378
379 v8::Handle<v8::Value> V8WebGLRenderingContext::getShaderParameterCallback(const v8::Arguments& args)
380 {
381     INC_STATS("DOM.WebGLRenderingContext.getShaderParameter()");
382
383     if (args.Length() != 2)
384         return V8Proxy::throwNotEnoughArgumentsError(args.GetIsolate());
385
386     ExceptionCode ec = 0;
387     WebGLRenderingContext* context = V8WebGLRenderingContext::toNative(args.Holder());
388     if (args.Length() > 0 && !isUndefinedOrNull(args[0]) && !V8WebGLShader::HasInstance(args[0])) {
389         V8Proxy::throwTypeError();
390         return notHandledByInterceptor();
391     }
392     WebGLShader* shader = V8WebGLShader::HasInstance(args[0]) ? V8WebGLShader::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0;
393     unsigned pname = toInt32(args[1]);
394     WebGLGetInfo info = context->getShaderParameter(shader, pname, ec);
395     if (ec) {
396         V8Proxy::setDOMException(ec, args.GetIsolate());
397         return v8::Undefined();
398     }
399     return toV8Object(info, args.GetIsolate());
400 }
401
402 v8::Handle<v8::Value> V8WebGLRenderingContext::getSupportedExtensionsCallback(const v8::Arguments& args)
403 {
404     INC_STATS("DOM.WebGLRenderingContext.getSupportedExtensionsCallback()");
405     WebGLRenderingContext* imp = V8WebGLRenderingContext::toNative(args.Holder());
406     if (imp->isContextLost())
407         return v8::Null();
408
409     Vector<String> value = imp->getSupportedExtensions();
410     v8::Local<v8::Array> array = v8::Array::New(value.size());
411     for (size_t ii = 0; ii < value.size(); ++ii)
412         array->Set(v8::Integer::New(ii), v8::String::New(fromWebCoreString(value[ii]), value[ii].length()));
413     return array;
414 }
415
416 v8::Handle<v8::Value> V8WebGLRenderingContext::getTexParameterCallback(const v8::Arguments& args)
417 {
418     INC_STATS("DOM.WebGLRenderingContext.getTexParameter()");
419     return getObjectParameter(args, kTexture);
420 }
421
422 v8::Handle<v8::Value> V8WebGLRenderingContext::getUniformCallback(const v8::Arguments& args)
423 {
424     INC_STATS("DOM.WebGLRenderingContext.getUniform()");
425
426     if (args.Length() != 2)
427         return V8Proxy::throwNotEnoughArgumentsError(args.GetIsolate());
428
429     ExceptionCode ec = 0;
430     WebGLRenderingContext* context = V8WebGLRenderingContext::toNative(args.Holder());
431     if (args.Length() > 0 && !isUndefinedOrNull(args[0]) && !V8WebGLProgram::HasInstance(args[0])) {
432         V8Proxy::throwTypeError();
433         return notHandledByInterceptor();
434     }
435     WebGLProgram* program = V8WebGLProgram::HasInstance(args[0]) ? V8WebGLProgram::toNative(v8::Handle<v8::Object>::Cast(args[0])) : 0;
436
437     if (args.Length() > 1 && !isUndefinedOrNull(args[1]) && !V8WebGLUniformLocation::HasInstance(args[1])) {
438         V8Proxy::throwTypeError();
439         return notHandledByInterceptor();
440     }
441     bool ok = false;
442     WebGLUniformLocation* location = toWebGLUniformLocation(args[1], ok);
443
444     WebGLGetInfo info = context->getUniform(program, location, ec);
445     if (ec) {
446         V8Proxy::setDOMException(ec, args.GetIsolate());
447         return v8::Undefined();
448     }
449     return toV8Object(info, args.GetIsolate());
450 }
451
452 v8::Handle<v8::Value> V8WebGLRenderingContext::getVertexAttribCallback(const v8::Arguments& args)
453 {
454     INC_STATS("DOM.WebGLRenderingContext.getVertexAttrib()");
455     return getObjectParameter(args, kVertexAttrib);
456 }
457
458 enum FunctionToCall {
459     kUniform1v, kUniform2v, kUniform3v, kUniform4v,
460     kVertexAttrib1v, kVertexAttrib2v, kVertexAttrib3v, kVertexAttrib4v
461 };
462
463 bool isFunctionToCallForAttribute(FunctionToCall functionToCall)
464 {
465     switch (functionToCall) {
466     case kVertexAttrib1v:
467     case kVertexAttrib2v:
468     case kVertexAttrib3v:
469     case kVertexAttrib4v:
470         return true;
471     default:
472         break;
473     }
474     return false;
475 }
476
477 static v8::Handle<v8::Value> vertexAttribAndUniformHelperf(const v8::Arguments& args,
478                                                            FunctionToCall functionToCall) {
479     // Forms:
480     // * glUniform1fv(WebGLUniformLocation location, Array data);
481     // * glUniform1fv(WebGLUniformLocation location, Float32Array data);
482     // * glUniform2fv(WebGLUniformLocation location, Array data);
483     // * glUniform2fv(WebGLUniformLocation location, Float32Array data);
484     // * glUniform3fv(WebGLUniformLocation location, Array data);
485     // * glUniform3fv(WebGLUniformLocation location, Float32Array data);
486     // * glUniform4fv(WebGLUniformLocation location, Array data);
487     // * glUniform4fv(WebGLUniformLocation location, Float32Array data);
488     // * glVertexAttrib1fv(GLint index, Array data);
489     // * glVertexAttrib1fv(GLint index, Float32Array data);
490     // * glVertexAttrib2fv(GLint index, Array data);
491     // * glVertexAttrib2fv(GLint index, Float32Array data);
492     // * glVertexAttrib3fv(GLint index, Array data);
493     // * glVertexAttrib3fv(GLint index, Float32Array data);
494     // * glVertexAttrib4fv(GLint index, Array data);
495     // * glVertexAttrib4fv(GLint index, Float32Array data);
496
497     if (args.Length() != 2)
498         return V8Proxy::throwNotEnoughArgumentsError(args.GetIsolate());
499
500     bool ok = false;
501     int index = -1;
502     WebGLUniformLocation* location = 0;
503
504     if (isFunctionToCallForAttribute(functionToCall))
505         index = toInt32(args[0]);
506     else {
507         if (args.Length() > 0 && !isUndefinedOrNull(args[0]) && !V8WebGLUniformLocation::HasInstance(args[0])) {
508             V8Proxy::throwTypeError();
509             return notHandledByInterceptor();
510         }
511         location = toWebGLUniformLocation(args[0], ok);
512     }
513
514     WebGLRenderingContext* context = V8WebGLRenderingContext::toNative(args.Holder());
515
516     if (V8Float32Array::HasInstance(args[1])) {
517         Float32Array* array = V8Float32Array::toNative(args[1]->ToObject());
518         ASSERT(array != NULL);
519         ExceptionCode ec = 0;
520         switch (functionToCall) {
521             case kUniform1v: context->uniform1fv(location, array, ec); break;
522             case kUniform2v: context->uniform2fv(location, array, ec); break;
523             case kUniform3v: context->uniform3fv(location, array, ec); break;
524             case kUniform4v: context->uniform4fv(location, array, ec); break;
525             case kVertexAttrib1v: context->vertexAttrib1fv(index, array); break;
526             case kVertexAttrib2v: context->vertexAttrib2fv(index, array); break;
527             case kVertexAttrib3v: context->vertexAttrib3fv(index, array); break;
528             case kVertexAttrib4v: context->vertexAttrib4fv(index, array); break;
529             default: ASSERT_NOT_REACHED(); break;
530         }
531         if (ec)
532             V8Proxy::setDOMException(ec, args.GetIsolate());
533         return v8::Undefined();
534     }
535
536     if (args[1].IsEmpty() || !args[1]->IsArray()) {
537         V8Proxy::throwTypeError();
538         return notHandledByInterceptor();
539     }
540     v8::Handle<v8::Array> array =
541       v8::Local<v8::Array>::Cast(args[1]);
542     uint32_t len = array->Length();
543     float* data = jsArrayToFloatArray(array, len);
544     if (!data) {
545         // FIXME: consider different / better exception type.
546         V8Proxy::setDOMException(SYNTAX_ERR, args.GetIsolate());
547         return notHandledByInterceptor();
548     }
549     ExceptionCode ec = 0;
550     switch (functionToCall) {
551         case kUniform1v: context->uniform1fv(location, data, len, ec); break;
552         case kUniform2v: context->uniform2fv(location, data, len, ec); break;
553         case kUniform3v: context->uniform3fv(location, data, len, ec); break;
554         case kUniform4v: context->uniform4fv(location, data, len, ec); break;
555         case kVertexAttrib1v: context->vertexAttrib1fv(index, data, len); break;
556         case kVertexAttrib2v: context->vertexAttrib2fv(index, data, len); break;
557         case kVertexAttrib3v: context->vertexAttrib3fv(index, data, len); break;
558         case kVertexAttrib4v: context->vertexAttrib4fv(index, data, len); break;
559         default: ASSERT_NOT_REACHED(); break;
560     }
561     fastFree(data);
562     if (ec)
563         V8Proxy::setDOMException(ec, args.GetIsolate());
564     return v8::Undefined();
565 }
566
567 static v8::Handle<v8::Value> uniformHelperi(const v8::Arguments& args,
568                                             FunctionToCall functionToCall) {
569     // Forms:
570     // * glUniform1iv(GLUniformLocation location, Array data);
571     // * glUniform1iv(GLUniformLocation location, Int32Array data);
572     // * glUniform2iv(GLUniformLocation location, Array data);
573     // * glUniform2iv(GLUniformLocation location, Int32Array data);
574     // * glUniform3iv(GLUniformLocation location, Array data);
575     // * glUniform3iv(GLUniformLocation location, Int32Array data);
576     // * glUniform4iv(GLUniformLocation location, Array data);
577     // * glUniform4iv(GLUniformLocation location, Int32Array data);
578
579     if (args.Length() != 2)
580         return V8Proxy::throwNotEnoughArgumentsError(args.GetIsolate());
581
582     WebGLRenderingContext* context = V8WebGLRenderingContext::toNative(args.Holder());
583     if (args.Length() > 0 && !isUndefinedOrNull(args[0]) && !V8WebGLUniformLocation::HasInstance(args[0])) {
584         V8Proxy::throwTypeError();
585         return notHandledByInterceptor();
586     }
587     bool ok = false;
588     WebGLUniformLocation* location = toWebGLUniformLocation(args[0], ok);
589
590     if (V8Int32Array::HasInstance(args[1])) {
591         Int32Array* array = V8Int32Array::toNative(args[1]->ToObject());
592         ASSERT(array != NULL);
593         ExceptionCode ec = 0;
594         switch (functionToCall) {
595             case kUniform1v: context->uniform1iv(location, array, ec); break;
596             case kUniform2v: context->uniform2iv(location, array, ec); break;
597             case kUniform3v: context->uniform3iv(location, array, ec); break;
598             case kUniform4v: context->uniform4iv(location, array, ec); break;
599             default: ASSERT_NOT_REACHED(); break;
600         }
601         if (ec)
602             V8Proxy::setDOMException(ec, args.GetIsolate());
603         return v8::Undefined();
604     }
605
606     if (args[1].IsEmpty() || !args[1]->IsArray()) {
607         V8Proxy::throwTypeError();
608         return notHandledByInterceptor();
609     }
610     v8::Handle<v8::Array> array =
611       v8::Local<v8::Array>::Cast(args[1]);
612     uint32_t len = array->Length();
613     int* data = jsArrayToIntArray(array, len);
614     if (!data) {
615         // FIXME: consider different / better exception type.
616         V8Proxy::setDOMException(SYNTAX_ERR, args.GetIsolate());
617         return notHandledByInterceptor();
618     }
619     ExceptionCode ec = 0;
620     switch (functionToCall) {
621         case kUniform1v: context->uniform1iv(location, data, len, ec); break;
622         case kUniform2v: context->uniform2iv(location, data, len, ec); break;
623         case kUniform3v: context->uniform3iv(location, data, len, ec); break;
624         case kUniform4v: context->uniform4iv(location, data, len, ec); break;
625         default: ASSERT_NOT_REACHED(); break;
626     }
627     fastFree(data);
628     if (ec)
629         V8Proxy::setDOMException(ec, args.GetIsolate());
630     return v8::Undefined();
631 }
632
633 v8::Handle<v8::Value> V8WebGLRenderingContext::uniform1fvCallback(const v8::Arguments& args)
634 {
635     INC_STATS("DOM.WebGLRenderingContext.uniform1fv()");
636     return vertexAttribAndUniformHelperf(args, kUniform1v);
637 }
638
639 v8::Handle<v8::Value> V8WebGLRenderingContext::uniform1ivCallback(const v8::Arguments& args)
640 {
641     INC_STATS("DOM.WebGLRenderingContext.uniform1iv()");
642     return uniformHelperi(args, kUniform1v);
643 }
644
645 v8::Handle<v8::Value> V8WebGLRenderingContext::uniform2fvCallback(const v8::Arguments& args)
646 {
647     INC_STATS("DOM.WebGLRenderingContext.uniform2fv()");
648     return vertexAttribAndUniformHelperf(args, kUniform2v);
649 }
650
651 v8::Handle<v8::Value> V8WebGLRenderingContext::uniform2ivCallback(const v8::Arguments& args)
652 {
653     INC_STATS("DOM.WebGLRenderingContext.uniform2iv()");
654     return uniformHelperi(args, kUniform2v);
655 }
656
657 v8::Handle<v8::Value> V8WebGLRenderingContext::uniform3fvCallback(const v8::Arguments& args)
658 {
659     INC_STATS("DOM.WebGLRenderingContext.uniform3fv()");
660     return vertexAttribAndUniformHelperf(args, kUniform3v);
661 }
662
663 v8::Handle<v8::Value> V8WebGLRenderingContext::uniform3ivCallback(const v8::Arguments& args)
664 {
665     INC_STATS("DOM.WebGLRenderingContext.uniform3iv()");
666     return uniformHelperi(args, kUniform3v);
667 }
668
669 v8::Handle<v8::Value> V8WebGLRenderingContext::uniform4fvCallback(const v8::Arguments& args)
670 {
671     INC_STATS("DOM.WebGLRenderingContext.uniform4fv()");
672     return vertexAttribAndUniformHelperf(args, kUniform4v);
673 }
674
675 v8::Handle<v8::Value> V8WebGLRenderingContext::uniform4ivCallback(const v8::Arguments& args)
676 {
677     INC_STATS("DOM.WebGLRenderingContext.uniform4iv()");
678     return uniformHelperi(args, kUniform4v);
679 }
680
681 static v8::Handle<v8::Value> uniformMatrixHelper(const v8::Arguments& args,
682                                                  int matrixSize)
683 {
684     // Forms:
685     // * glUniformMatrix2fv(GLint location, GLboolean transpose, Array data);
686     // * glUniformMatrix2fv(GLint location, GLboolean transpose, Float32Array data);
687     // * glUniformMatrix3fv(GLint location, GLboolean transpose, Array data);
688     // * glUniformMatrix3fv(GLint location, GLboolean transpose, Float32Array data);
689     // * glUniformMatrix4fv(GLint location, GLboolean transpose, Array data);
690     // * glUniformMatrix4fv(GLint location, GLboolean transpose, Float32Array data);
691     //
692     // FIXME: need to change to accept Float32Array as well.
693     if (args.Length() != 3)
694         return V8Proxy::throwNotEnoughArgumentsError(args.GetIsolate());
695
696     WebGLRenderingContext* context = V8WebGLRenderingContext::toNative(args.Holder());
697
698     if (args.Length() > 0 && !isUndefinedOrNull(args[0]) && !V8WebGLUniformLocation::HasInstance(args[0])) {
699         V8Proxy::throwTypeError();
700         return notHandledByInterceptor();
701     }
702     bool ok = false;
703     WebGLUniformLocation* location = toWebGLUniformLocation(args[0], ok);
704     
705     bool transpose = args[1]->BooleanValue();
706     if (V8Float32Array::HasInstance(args[2])) {
707         Float32Array* array = V8Float32Array::toNative(args[2]->ToObject());
708         ASSERT(array != NULL);
709         ExceptionCode ec = 0;
710         switch (matrixSize) {
711             case 2: context->uniformMatrix2fv(location, transpose, array, ec); break;
712             case 3: context->uniformMatrix3fv(location, transpose, array, ec); break;
713             case 4: context->uniformMatrix4fv(location, transpose, array, ec); break;
714             default: ASSERT_NOT_REACHED(); break;
715         }
716         if (ec)
717             V8Proxy::setDOMException(ec, args.GetIsolate());
718         return v8::Undefined();
719     }
720
721     if (args[2].IsEmpty() || !args[2]->IsArray()) {
722         V8Proxy::throwTypeError();
723         return notHandledByInterceptor();
724     }
725     v8::Handle<v8::Array> array =
726       v8::Local<v8::Array>::Cast(args[2]);
727     uint32_t len = array->Length();
728     float* data = jsArrayToFloatArray(array, len);
729     if (!data) {
730         // FIXME: consider different / better exception type.
731         V8Proxy::setDOMException(SYNTAX_ERR, args.GetIsolate());
732         return notHandledByInterceptor();
733     }
734     ExceptionCode ec = 0;
735     switch (matrixSize) {
736         case 2: context->uniformMatrix2fv(location, transpose, data, len, ec); break;
737         case 3: context->uniformMatrix3fv(location, transpose, data, len, ec); break;
738         case 4: context->uniformMatrix4fv(location, transpose, data, len, ec); break;
739         default: ASSERT_NOT_REACHED(); break;
740     }
741     fastFree(data);
742     if (ec)
743         V8Proxy::setDOMException(ec, args.GetIsolate()); 
744     return v8::Undefined();
745 }
746
747 v8::Handle<v8::Value> V8WebGLRenderingContext::uniformMatrix2fvCallback(const v8::Arguments& args)
748 {
749     INC_STATS("DOM.WebGLRenderingContext.uniformMatrix2fv()");
750     return uniformMatrixHelper(args, 2);
751 }
752
753 v8::Handle<v8::Value> V8WebGLRenderingContext::uniformMatrix3fvCallback(const v8::Arguments& args)
754 {
755     INC_STATS("DOM.WebGLRenderingContext.uniformMatrix3fv()");
756     return uniformMatrixHelper(args, 3);
757 }
758
759 v8::Handle<v8::Value> V8WebGLRenderingContext::uniformMatrix4fvCallback(const v8::Arguments& args)
760 {
761     INC_STATS("DOM.WebGLRenderingContext.uniformMatrix4fv()");
762     return uniformMatrixHelper(args, 4);
763 }
764
765 v8::Handle<v8::Value> V8WebGLRenderingContext::vertexAttrib1fvCallback(const v8::Arguments& args)
766 {
767     INC_STATS("DOM.WebGLRenderingContext.vertexAttrib1fv()");
768     return vertexAttribAndUniformHelperf(args, kVertexAttrib1v);
769 }
770
771 v8::Handle<v8::Value> V8WebGLRenderingContext::vertexAttrib2fvCallback(const v8::Arguments& args)
772 {
773     INC_STATS("DOM.WebGLRenderingContext.vertexAttrib2fv()");
774     return vertexAttribAndUniformHelperf(args, kVertexAttrib2v);
775 }
776
777 v8::Handle<v8::Value> V8WebGLRenderingContext::vertexAttrib3fvCallback(const v8::Arguments& args)
778 {
779     INC_STATS("DOM.WebGLRenderingContext.vertexAttrib3fv()");
780     return vertexAttribAndUniformHelperf(args, kVertexAttrib3v);
781 }
782
783 v8::Handle<v8::Value> V8WebGLRenderingContext::vertexAttrib4fvCallback(const v8::Arguments& args)
784 {
785     INC_STATS("DOM.WebGLRenderingContext.vertexAttrib4fv()");
786     return vertexAttribAndUniformHelperf(args, kVertexAttrib4v);
787 }
788
789 } // namespace WebCore
790
791 #endif // ENABLE(WEBGL)