WebGL support.

Source/WebCore/bindings/dart/custom/DartWebGLRenderingContextCustom.cpp

Index: Source/WebCore/bindings/dart/custom/DartWebGLRenderingContextCustom.cpp
diff --git a/Source/WebCore/bindings/dart/custom/DartWebGLRenderingContextCustom.cpp b/Source/WebCore/bindings/dart/custom/DartWebGLRenderingContextCustom.cpp
index b8f74a299519d963314a2fb4aa2cb4646b7be043..153c02e89d78ec1598cc5b2b1d20b7927a8ce1e0 100644
--- a/Source/WebCore/bindings/dart/custom/DartWebGLRenderingContextCustom.cpp
+++ b/Source/WebCore/bindings/dart/custom/DartWebGLRenderingContextCustom.cpp
@@ -32,170 +32,714 @@
 
 #if ENABLE(WEBGL)
 
+#include "DartArrayBufferView.h"
+#include "DartDOMWrapper.h"
+#include "DartFloat32Array.h"
+#include "DartHTMLCanvasElement.h"
+#include "DartHTMLImageElement.h"
+#include "DartHTMLVideoElement.h"
+#include "DartImageData.h"
+#include "DartInt16Array.h"
+#include "DartInt32Array.h"
+#include "DartInt8Array.h"
+#include "DartOESStandardDerivatives.h"
+#include "DartOESTextureFloat.h"
+#include "DartOESVertexArrayObject.h"
+#include "DartUint16Array.h"
+#include "DartUint32Array.h"
+#include "DartUint8Array.h"
+#include "DartWebGLBuffer.h"
+#include "DartWebGLDebugRendererInfo.h"
+#include "DartWebGLDebugShaders.h"
+#include "DartWebGLFramebuffer.h"
+#include "DartWebGLLoseContext.h"
+#include "DartWebGLProgram.h"
+#include "DartWebGLRenderbuffer.h"
+#include "DartWebGLShader.h"
+#include "DartWebGLTexture.h"
+#include "DartWebGLUniformLocation.h"
+#include "DartWebGLVertexArrayObjectOES.h"
+#include "ExceptionCode.h"
+#include "NotImplemented.h"
+#include "WebGLRenderingContext.h"
+
+#include <limits>
+#include <wtf/FastMalloc.h>
+
 namespace WebCore {
 
 namespace DartWebGLRenderingContextInternal {
 
-void getAttachedShadersCallback(Dart_NativeArguments)
+static Dart_Handle webGLExtensionToDart(WebGLExtension* extension)
+{
+    if (!extension)
+        return 0;
+    switch (extension->getName()) {
+    case WebGLExtension::WebKitWebGLLoseContextName:
+        return toDartValue(static_cast<WebGLLoseContext*>(extension));
+    case WebGLExtension::OESStandardDerivativesName:
+        return toDartValue(static_cast<OESStandardDerivatives*>(extension));
+    case WebGLExtension::OESTextureFloatName:
+        return toDartValue(static_cast<OESTextureFloat*>(extension));
+    case WebGLExtension::OESVertexArrayObjectName:
+        return toDartValue(static_cast<OESVertexArrayObject*>(extension));
+    case WebGLExtension::WebGLDebugRendererInfoName:
+        return toDartValue(static_cast<WebGLDebugRendererInfo*>(extension));
+    case WebGLExtension::WebGLDebugShadersName:
+        return toDartValue(static_cast<WebGLDebugShaders*>(extension));
+    default:
+        ASSERT_NOT_REACHED();
+        return 0;
+    }
+}
+
+static Dart_Handle webGLGetInfoToDart(const WebGLGetInfo& info)
+{
+    switch (info.getType()) {
+    case WebGLGetInfo::kTypeBool:
+        return toDartValue(info.getBool());
+    case WebGLGetInfo::kTypeBoolArray:
+        return DartUtilities::vectorToDartList(info.getBoolArray());
+    case WebGLGetInfo::kTypeFloat:
+        return toDartValue(info.getFloat());
+    case WebGLGetInfo::kTypeInt:
+        return toDartValue(info.getInt());
+    case WebGLGetInfo::kTypeNull:
+        return 0;
+    case WebGLGetInfo::kTypeString:
+        return toDartValue(info.getString());
+    case WebGLGetInfo::kTypeUnsignedInt:
+        return toDartValue(static_cast<intptr_t>(info.getUnsignedInt()));
+    case WebGLGetInfo::kTypeWebGLBuffer:
+        return toDartValue(info.getWebGLBuffer());
+    case WebGLGetInfo::kTypeWebGLFloatArray:
+        return toDartValue(info.getWebGLFloatArray());
+    case WebGLGetInfo::kTypeWebGLFramebuffer:
+        return toDartValue(info.getWebGLFramebuffer());
+    case WebGLGetInfo::kTypeWebGLIntArray:
+        return toDartValue(info.getWebGLIntArray());
+    // FIXME: implement WebGLObjectArray.
+    // case WebGLGetInfo::kTypeWebGLObjectArray:
+    case WebGLGetInfo::kTypeWebGLProgram:
+        return toDartValue(info.getWebGLProgram());
+    case WebGLGetInfo::kTypeWebGLRenderbuffer:
+        return toDartValue(info.getWebGLRenderbuffer());
+    case WebGLGetInfo::kTypeWebGLTexture:
+        return toDartValue(info.getWebGLTexture());
+    case WebGLGetInfo::kTypeWebGLUnsignedByteArray:
+        return toDartValue(info.getWebGLUnsignedByteArray());
+    case WebGLGetInfo::kTypeWebGLVertexArrayObjectOES:
+        return toDartValue(info.getWebGLVertexArrayObjectOES());
+    default:
+        ASSERT_NOT_REACHED();
+        return 0;
+    }
+}
+
+enum ObjectType {
+    kBuffer, kRenderbuffer, kTexture, kVertexAttrib
+};
+
+static void getObjectParameter(Dart_NativeArguments args, ObjectType objectType)
+{
+    DartApiScope dartApiScope;
+    Dart_Handle exception;
+    {
+        ExceptionCode ec = 0;
+        WebGLRenderingContext* context = DartDOMWrapper::receiver<WebGLRenderingContext>(args);
+        const ParameterAdapter<int> target(Dart_GetNativeArgument(args, 1));
+        if (!target.conversionSuccessful()) {
+            exception = target.exception();
+            goto fail;
+        }
+        const ParameterAdapter<int> pname(Dart_GetNativeArgument(args, 2));
+        if (!pname.conversionSuccessful()) {
+            exception = pname.exception();
+            goto fail;
+        }
+
+        WebGLGetInfo info;
+        switch (objectType) {
+        case kBuffer:
+            info = context->getBufferParameter(target, pname, ec);
+            break;
+        case kRenderbuffer:
+            info = context->getRenderbufferParameter(target, pname, ec);
+            break;
+        case kTexture:
+            info = context->getTexParameter(target, pname, ec);
+            break;
+        case kVertexAttrib:
+            // target => index
+            info = context->getVertexAttrib(target, pname, ec);
+            break;
+        default:
+            notImplemented();
+            break;
+        }
+        if (UNLIKELY(ec)) {
+            exception = DartDOMWrapper::exceptionCodeToDartException(ec);
+            goto fail;
+        }
+        Dart_Handle result = webGLGetInfoToDart(info);
+        if (!DartUtilities::checkResult(result, exception))
+            goto fail;
+
+        Dart_SetReturnValue(args, result);
+        return;
+    }
+
+fail:
+    Dart_ThrowException(exception);
+    ASSERT_NOT_REACHED();
+}
+
+void getAttachedShadersCallback(Dart_NativeArguments args)
+{
+    DartApiScope dartApiScope;
+    Dart_Handle exception = 0;
+    {
+        WebGLRenderingContext* context = DartDOMWrapper::receiver<WebGLRenderingContext>(args);
+        const ParameterAdapter<RefPtr<WebGLProgram>, DartWebGLProgram> program(Dart_GetNativeArgument(args, 1));
+        if (!program.conversionSuccessful()) {
+            exception = program.exception();
+            goto fail;
+        }
+
+        Vector<RefPtr<WebGLShader> > shaders;
+        ExceptionCode ec = 0;
+        bool succeed = context->getAttachedShaders(program, shaders, ec);
+        if (UNLIKELY(ec)) {
+            exception = DartDOMWrapper::exceptionCodeToDartException(ec);
+            goto fail;
+        }
+        Dart_Handle result;
+        if (succeed) {
+            result = DartUtilities::vectorToDartList(shaders);
+            if (!DartUtilities::checkResult(result, exception))
+                goto fail;
+        } else
+            result = 0;
+        Dart_SetReturnValue(args, result);
+        return;
+    }
+
+fail:
+    Dart_ThrowException(exception);
+    ASSERT_NOT_REACHED();
+}
+
+void getBufferParameterCallback(Dart_NativeArguments args)
+{
+    getObjectParameter(args, kBuffer);
+}
+
+void getExtensionCallback(Dart_NativeArguments args)
+{
+    DartApiScope dartApiScope;
+    Dart_Handle exception;
+    {
+        WebGLRenderingContext* context = DartDOMWrapper::receiver<WebGLRenderingContext>(args);
+        const ParameterAdapter<String> name(Dart_GetNativeArgument(args, 1));
+        if (!name.conversionSuccessful()) {
+            exception = name.exception();
+            goto fail;
+        }
+
+        WebGLExtension* extension = context->getExtension(name);
+        Dart_Handle result = webGLExtensionToDart(extension);
+        if (!DartUtilities::checkResult(result, exception))
+            goto fail;
+        Dart_SetReturnValue(args, result);
+        return;
+    }
+
+fail:
+    Dart_ThrowException(exception);
+    ASSERT_NOT_REACHED();
+}
+
+void getFramebufferAttachmentParameterCallback(Dart_NativeArguments args)
+{
+    DartApiScope dartApiScope;
+    Dart_Handle exception;
+    {
+        WebGLRenderingContext* context = DartDOMWrapper::receiver<WebGLRenderingContext>(args);
+        const ParameterAdapter<int> target(Dart_GetNativeArgument(args, 1));
+        if (!target.conversionSuccessful()) {
+            exception = target.exception();
+            goto fail;
+        }
+        const ParameterAdapter<int> attachment(Dart_GetNativeArgument(args, 2));
+        if (!attachment.conversionSuccessful()) {
+            exception = attachment.exception();
+            goto fail;
+        }
+        const ParameterAdapter<int> pname(Dart_GetNativeArgument(args, 3));
+        if (!pname.conversionSuccessful()) {
+            exception = pname.exception();
+            goto fail;
+        }
+
+        ExceptionCode ec = 0;
+        WebGLGetInfo info = context->getFramebufferAttachmentParameter(target, attachment, pname, ec);
+        if (UNLIKELY(ec)) {
+            exception = DartDOMWrapper::exceptionCodeToDartException(ec);
+            goto fail;
+        }
+        Dart_Handle result = webGLGetInfoToDart(info);
+        if (!DartUtilities::checkResult(result, exception))
+            goto fail;
+        Dart_SetReturnValue(args, result);
+        return;
+    }
+
+fail:
+    Dart_ThrowException(exception);
+    ASSERT_NOT_REACHED();
+}
+
+void getParameterCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    DartApiScope dartApiScope;
+    Dart_Handle exception = 0;
+    {
+        WebGLRenderingContext* context = DartDOMWrapper::receiver<WebGLRenderingContext>(args);
+        const ParameterAdapter<int> pname(Dart_GetNativeArgument(args, 1));
+        if (!pname.conversionSuccessful()) {
+            exception = pname.exception();
+            goto fail;
+        }
+
+        ExceptionCode ec = 0;
+        WebGLGetInfo info = context->getParameter(pname, ec);
+        if (UNLIKELY(ec)) {
+            exception = DartDOMWrapper::exceptionCodeToDartException(ec);
+            goto fail;
+        }
+        Dart_Handle result = webGLGetInfoToDart(info);
+        if (!DartUtilities::checkResult(result, exception))
+            goto fail;
+
+        Dart_SetReturnValue(args, result);
+        return;
+    }
+
+fail:
+    Dart_ThrowException(exception);
+    ASSERT_NOT_REACHED();
 }
 
-void getBufferParameterCallback(Dart_NativeArguments)
+void getProgramParameterCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    DartApiScope dartApiScope;
+    Dart_Handle exception;
+    {
+        WebGLRenderingContext* context = DartDOMWrapper::receiver<WebGLRenderingContext>(args);
+        const ParameterAdapter<WebGLProgram, DartWebGLProgram> program(Dart_GetNativeArgument(args, 1));
+        if (!program.conversionSuccessful()) {
+            exception = program.exception();
+            goto fail;
+        }
+        const ParameterAdapter<int> pname(Dart_GetNativeArgument(args, 2));
+        if (!pname.conversionSuccessful()) {
+            exception = pname.exception();
+            goto fail;
+        }
+
+        ExceptionCode ec = 0;
+        WebGLGetInfo info = context->getProgramParameter(program, pname, ec);
+        if (UNLIKELY(ec)) {
+            exception = DartDOMWrapper::exceptionCodeToDartException(ec);
+            goto fail;
+        }
+        Dart_Handle result = webGLGetInfoToDart(info);
+        if (!DartUtilities::checkResult(result, exception))
+            goto fail;
+
+        Dart_SetReturnValue(args, result);
+        return;
+    }
+
+fail:
+    Dart_ThrowException(exception);
+    ASSERT_NOT_REACHED();
 }
 
-void getExtensionCallback(Dart_NativeArguments)
+void getRenderbufferParameterCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    getObjectParameter(args, kRenderbuffer);
 }
 
-void getFramebufferAttachmentParameterCallback(Dart_NativeArguments)
+void getShaderParameterCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    DartApiScope dartApiScope;
+    Dart_Handle exception;
+    {
+        WebGLRenderingContext* context = DartDOMWrapper::receiver<WebGLRenderingContext>(args);
+        const ParameterAdapter<WebGLShader, DartWebGLShader> shader(Dart_GetNativeArgument(args, 1));
+        if (!shader.conversionSuccessful()) {
+            exception = shader.exception();
+            goto fail;
+        }
+        const ParameterAdapter<int> pname(Dart_GetNativeArgument(args, 2));
+        if (!pname.conversionSuccessful()) {
+            exception = pname.exception();
+            goto fail;
+        }
+
+        ExceptionCode ec = 0;
+        WebGLGetInfo info = context->getShaderParameter(shader, pname, ec);
+        if (UNLIKELY(ec)) {
+            exception = DartDOMWrapper::exceptionCodeToDartException(ec);
+            goto fail;
+        }
+        Dart_Handle result = webGLGetInfoToDart(info);
+        if (!DartUtilities::checkResult(result, exception))
+            goto fail;
+
+        Dart_SetReturnValue(args, result);
+        return;
+    }
+
+fail:
+    Dart_ThrowException(exception);
+    ASSERT_NOT_REACHED();
 }
 
-void getParameterCallback(Dart_NativeArguments)
+void getSupportedExtensionsCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    DartApiScope dartApiScope;
+    Dart_Handle exception = 0;
+    {
+        WebGLRenderingContext* context = DartDOMWrapper::receiver<WebGLRenderingContext>(args);
+        Vector<String> value = context->getSupportedExtensions();
+        Dart_Handle result = DartUtilities::vectorToDartList(value);
+        if (!DartUtilities::checkResult(result, exception))
+            goto fail;
+
+        Dart_SetReturnValue(args, result);
+        return;
+    }
+
+fail:
+    Dart_ThrowException(exception);
+    ASSERT_NOT_REACHED();
 }
 
-void getProgramParameterCallback(Dart_NativeArguments)
+void getTexParameterCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    getObjectParameter(args, kTexture);
 }
 
-void getRenderbufferParameterCallback(Dart_NativeArguments)
+void getUniformCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    getObjectParameter(args, kVertexAttrib);
 }
 
-void getShaderParameterCallback(Dart_NativeArguments)
+void getVertexAttribCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    getObjectParameter(args, kVertexAttrib);
 }
 
-void getSupportedExtensionsCallback(Dart_NativeArguments)
+enum FunctionToCall {
+    kUniform1v, kUniform2v, kUniform3v, kUniform4v,
+    kVertexAttrib1v, kVertexAttrib2v, kVertexAttrib3v, kVertexAttrib4v
+};
+
+static inline bool isFunctionToCallForAttribute(FunctionToCall functionToCall)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    switch (functionToCall) {
+    case kVertexAttrib1v:
+    case kVertexAttrib2v:
+    case kVertexAttrib3v:
+    case kVertexAttrib4v:
+        return true;
+    default:
+        break;
+    }
+    return false;
 }
 
-void getTexParameterCallback(Dart_NativeArguments)
+static void vertexAttribAndUniformHelperf(Dart_NativeArguments args, FunctionToCall functionToCall)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    DartApiScope dartApiScope;
+    Dart_Handle exception;
+    {
+        // Forms:
+        // * glUniform1fv(WebGLUniformLocation location, Array data);
+        // * glUniform1fv(WebGLUniformLocation location, Float32Array data);
+        // * glUniform2fv(WebGLUniformLocation location, Array data);
+        // * glUniform2fv(WebGLUniformLocation location, Float32Array data);
+        // * glUniform3fv(WebGLUniformLocation location, Array data);
+        // * glUniform3fv(WebGLUniformLocation location, Float32Array data);
+        // * glUniform4fv(WebGLUniformLocation location, Array data);
+        // * glUniform4fv(WebGLUniformLocation location, Float32Array data);
+        // * glVertexAttrib1fv(GLint index, Array data);
+        // * glVertexAttrib1fv(GLint index, Float32Array data);
+        // * glVertexAttrib2fv(GLint index, Array data);
+        // * glVertexAttrib2fv(GLint index, Float32Array data);
+        // * glVertexAttrib3fv(GLint index, Array data);
+        // * glVertexAttrib3fv(GLint index, Float32Array data);
+        // * glVertexAttrib4fv(GLint index, Array data);
+        // * glVertexAttrib4fv(GLint index, Float32Array data);
+        WebGLRenderingContext* context = DartDOMWrapper::receiver<WebGLRenderingContext>(args);
+        int index = -1;
+        WebGLUniformLocation* location = 0;
+
+        if (isFunctionToCallForAttribute(functionToCall)) {
+            const ParameterAdapter<int> indexParam(Dart_GetNativeArgument(args, 1));
+            if (!indexParam.conversionSuccessful()) {
+                exception = indexParam.exception();
+                goto fail;
+            }
+            index = indexParam;
+        } else {
+            const ParameterAdapter<WebGLUniformLocation, DartWebGLUniformLocation> locationParam(Dart_GetNativeArgument(args, 1));
+            if (!locationParam.conversionSuccessful()) {
+                exception = locationParam.exception();
+                goto fail;
+            }
+            location = locationParam;
+        }
+
+        // FIXME: process Dart lists as parameters.
+        const ParameterAdapter<Float32Array, DartFloat32Array> array(Dart_GetNativeArgument(args, 2));
+        if (!array.conversionSuccessful()) {
+            exception = array.exception();
+            goto fail;
+        }
+
+        ExceptionCode ec = 0;
+        switch (functionToCall) {
+        case kUniform1v:
+            context->uniform1fv(location, array, ec);
+            break;
+        case kUniform2v:
+            context->uniform2fv(location, array, ec);
+            break;
+        case kUniform3v:
+            context->uniform3fv(location, array, ec);
+            break;
+        case kUniform4v:
+            context->uniform4fv(location, array, ec);
+            break;
+        case kVertexAttrib1v:
+            context->vertexAttrib1fv(index, array);
+            break;
+        case kVertexAttrib2v:
+            context->vertexAttrib2fv(index, array);
+            break;
+        case kVertexAttrib3v:
+            context->vertexAttrib3fv(index, array);
+            break;
+        case kVertexAttrib4v:
+            context->vertexAttrib4fv(index, array);
+            break;
+        default:
+            ASSERT_NOT_REACHED();
+            break;
+        }
+        if (UNLIKELY(ec)) {
+            exception = DartDOMWrapper::exceptionCodeToDartException(ec);
+            goto fail;
+        }
+        return;
+    }
+
+fail:
+    Dart_ThrowException(exception);
+    ASSERT_NOT_REACHED();
 }
 
-void getUniformCallback(Dart_NativeArguments)
+static void uniformHelperi(Dart_NativeArguments args, FunctionToCall functionToCall)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    DartApiScope dartApiScope;
+    Dart_Handle exception;
+    {
+        // Forms:
+        // * glUniform1iv(GLUniformLocation location, Array data);
+        // * glUniform1iv(GLUniformLocation location, Int32Array data);
+        // * glUniform2iv(GLUniformLocation location, Array data);
+        // * glUniform2iv(GLUniformLocation location, Int32Array data);
+        // * glUniform3iv(GLUniformLocation location, Array data);
+        // * glUniform3iv(GLUniformLocation location, Int32Array data);
+        // * glUniform4iv(GLUniformLocation location, Array data);
+        // * glUniform4iv(GLUniformLocation location, Int32Array data);
+        WebGLRenderingContext* context = DartDOMWrapper::receiver<WebGLRenderingContext>(args);
+        const ParameterAdapter<WebGLUniformLocation, DartWebGLUniformLocation> location(Dart_GetNativeArgument(args, 1));
+        if (!location.conversionSuccessful()) {
+            exception = location.exception();
+            goto fail;
+        }
+        const ParameterAdapter<Int32Array, DartInt32Array> array(Dart_GetNativeArgument(args, 2));
+        // FIXME: maybe process Dart lists ars parameters too?
+        if (!array.conversionSuccessful()) {
+            exception = array.exception();
+            goto fail;
+        }
+
+        ExceptionCode ec = 0;
+        switch (functionToCall) {
+        case kUniform1v:
+            context->uniform1iv(location, array, ec);
+            break;
+        case kUniform2v:
+            context->uniform2iv(location, array, ec);
+            break;
+        case kUniform3v:
+            context->uniform3iv(location, array, ec);
+            break;
+        case kUniform4v:
+            context->uniform4iv(location, array, ec);
+            break;
+        default:
+            ASSERT_NOT_REACHED();
+            break;
+        }
+        if (UNLIKELY(ec)) {
+            exception = DartDOMWrapper::exceptionCodeToDartException(ec);
+            goto fail;
+        }
+        return;
+    }
+
+fail:
+    Dart_ThrowException(exception);
+    ASSERT_NOT_REACHED();
 }
 
-void getVertexAttribCallback(Dart_NativeArguments)
+static void uniformMatrixHelper(Dart_NativeArguments args, int matrixSize)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    DartApiScope dartApiScope;
+    Dart_Handle exception;
+    {
+        // Forms:
+        // * glUniformMatrix2fv(GLint location, GLboolean transpose, Array data);
+        // * glUniformMatrix2fv(GLint location, GLboolean transpose, Float32Array data);
+        // * glUniformMatrix3fv(GLint location, GLboolean transpose, Array data);
+        // * glUniformMatrix3fv(GLint location, GLboolean transpose, Float32Array data);
+        // * glUniformMatrix4fv(GLint location, GLboolean transpose, Array data);
+        // * glUniformMatrix4fv(GLint location, GLboolean transpose, Float32Array data);
+        //
+        WebGLRenderingContext* context = DartDOMWrapper::receiver<WebGLRenderingContext>(args);
+        const ParameterAdapter<WebGLUniformLocation, DartWebGLUniformLocation> location(Dart_GetNativeArgument(args, 1));
+        if (!location.conversionSuccessful()) {
+            exception = location.exception();
+            goto fail;
+        }
+        const ParameterAdapter<bool> transpose(Dart_GetNativeArgument(args, 2));
+        if (!transpose.conversionSuccessful()) {
+            exception = transpose.exception();
+            goto fail;
+        }
+        // FIXME: maybe process Dart lists ars parameters too?
+        const ParameterAdapter<Float32Array, DartFloat32Array> array(Dart_GetNativeArgument(args, 3));
+        if (!array.conversionSuccessful()) {
+            exception = array.exception();
+            goto fail;
+        }
+
+        ExceptionCode ec = 0;
+        switch (matrixSize) {
+        case 2:
+            context->uniformMatrix2fv(location, transpose, array, ec);
+            break;
+        case 3:
+            context->uniformMatrix3fv(location, transpose, array, ec);
+            break;
+        case 4:
+            context->uniformMatrix4fv(location, transpose, array, ec);
+            break;
+        default:
+            ASSERT_NOT_REACHED();
+            break;
+        }
+        if (UNLIKELY(ec)) {
+            exception = DartDOMWrapper::exceptionCodeToDartException(ec);
+             goto fail;
+        }
+        return;
+    }
+
+fail:
+    Dart_ThrowException(exception);
+    ASSERT_NOT_REACHED();
 }
 
-void uniform1fvCallback(Dart_NativeArguments)
+void uniform1fvCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    vertexAttribAndUniformHelperf(args, kUniform1v);
 }
 
-void uniform1ivCallback(Dart_NativeArguments)
+void uniform1ivCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    uniformHelperi(args, kUniform1v);
 }
 
-void uniform2fvCallback(Dart_NativeArguments)
+void uniform2fvCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    vertexAttribAndUniformHelperf(args, kUniform2v);
 }
 
-void uniform2ivCallback(Dart_NativeArguments)
+void uniform2ivCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    uniformHelperi(args, kUniform2v);
 }
 
-void uniform3fvCallback(Dart_NativeArguments)
+void uniform3fvCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    vertexAttribAndUniformHelperf(args, kUniform3v);
 }
 
-void uniform3ivCallback(Dart_NativeArguments)
+void uniform3ivCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    uniformHelperi(args, kUniform3v);
 }
 
-void uniform4fvCallback(Dart_NativeArguments)
+void uniform4fvCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    vertexAttribAndUniformHelperf(args, kUniform4v);
 }
 
-void uniform4ivCallback(Dart_NativeArguments)
+void uniform4ivCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    uniformHelperi(args, kUniform4v);
 }
 
-void uniformMatrix2fvCallback(Dart_NativeArguments)
+void uniformMatrix2fvCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    uniformMatrixHelper(args, 2);
 }
 
-void uniformMatrix3fvCallback(Dart_NativeArguments)
+void uniformMatrix3fvCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    uniformMatrixHelper(args, 3);
 }
 
-void uniformMatrix4fvCallback(Dart_NativeArguments)
+void uniformMatrix4fvCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    uniformMatrixHelper(args, 4);
 }
 
-void vertexAttrib1fvCallback(Dart_NativeArguments)
+void vertexAttrib1fvCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    vertexAttribAndUniformHelperf(args, kVertexAttrib1v);
 }
 
-void vertexAttrib2fvCallback(Dart_NativeArguments)
+void vertexAttrib2fvCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    vertexAttribAndUniformHelperf(args, kVertexAttrib2v);
 }
 
-void vertexAttrib3fvCallback(Dart_NativeArguments)
+void vertexAttrib3fvCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    vertexAttribAndUniformHelperf(args, kVertexAttrib3v);
 }
 
-void vertexAttrib4fvCallback(Dart_NativeArguments)
+void vertexAttrib4fvCallback(Dart_NativeArguments args)
 {
-    // FIXME: proper implementation.
-    DART_UNIMPLEMENTED();
+    vertexAttribAndUniformHelperf(args, kVertexAttrib4v);
 }
 
 }