From 4da5f26c019971a319dda77e4bfe6480c269bdf1 Mon Sep 17 00:00:00 2001
From: Zhenyao Mo <zmo@google.com>
Date: Thu, 30 Jun 2011 23:24:26 +0000
Subject: Improve WebGL object lifetime management in WebGLRenderingContext

2011-06-30  Zhenyao Mo  <zmo@google.com>

        Reviewed by Kenneth Russell.

        Improve WebGL object lifetime management in WebGLRenderingContext
        https://bugs.webkit.org/show_bug.cgi?id=63635

        * fast/canvas/webgl/gl-object-get-calls-expected.txt:
        * fast/canvas/webgl/gl-object-get-calls.html: Fix a bug so getFramebufferAtatchmentParameter generates an error if nothing is attached and something other than TYPE is queried.
        * fast/canvas/webgl/object-deletion-behaviour-expected.txt:
        * fast/canvas/webgl/object-deletion-behaviour.html: Ditto.
        * fast/canvas/webgl/program-test.html: Fix the test so the order of shaders returned by getAttachedShaders doesn't matter.
2011-06-30  Zhenyao Mo  <zmo@google.com>

        Reviewed by Kenneth Russell.

        Improve WebGL object lifetime management in WebGLRenderingContext
        https://bugs.webkit.org/show_bug.cgi?id=63635

        * html/canvas/WebGLRenderingContext.cpp:
        (WebCore::WebGLRenderingContext::getAttachedShaders): Use cached objects instead of querying the underlying GL.
        (WebCore::WebGLRenderingContext::getFramebufferAttachmentParameter): Ditto.
        (WebCore::WebGLRenderingContext::detachAndRemoveAllObjects): Multiple loop because objects might be removed from the table within an iteration.
        * html/canvas/WebGLRenderingContext.h:

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@90180 268f45cc-cd09-0410-ab3c-d52691b4dbfc
CRs-fixed: 407009

(cherry-picked from commit 2dbba5d5facb2c0c57a37eb0cf3958bae0f697fa)

Change-Id: I2cb88cc5790452c18f6e58420cc7b063c9ffce26
---
 .../canvas/webgl/gl-object-get-calls-expected.txt  |  92 ++++++
 .../fast/canvas/webgl/gl-object-get-calls.html     | 252 +++++++++++++++++
 .../canvas/webgl/object-deletion-behaviour.html    | 290 +------------------
 LayoutTests/fast/canvas/webgl/program-test.html    | 311 +++++++++++++++++++++
 .../v8/custom/V8WebGLRenderingContextCustom.cpp    |   2 +-
 Source/WebCore/html/canvas/WebGLObject.cpp         |  10 +
 Source/WebCore/html/canvas/WebGLObject.h           |   7 +-
 .../WebCore/html/canvas/WebGLRenderingContext.cpp  |  89 +-----
 Source/WebCore/html/canvas/WebGLRenderingContext.h |   6 +-
 9 files changed, 682 insertions(+), 377 deletions(-)
 create mode 100644 LayoutTests/fast/canvas/webgl/gl-object-get-calls-expected.txt
 create mode 100644 LayoutTests/fast/canvas/webgl/gl-object-get-calls.html
 create mode 100644 LayoutTests/fast/canvas/webgl/program-test.html

diff --git a/LayoutTests/fast/canvas/webgl/gl-object-get-calls-expected.txt b/LayoutTests/fast/canvas/webgl/gl-object-get-calls-expected.txt
new file mode 100644
index 0000000..c899480
--- /dev/null
+++ b/LayoutTests/fast/canvas/webgl/gl-object-get-calls-expected.txt
@@ -0,0 +1,92 @@
+Test of get calls against GL objects like getBufferParameter, etc.
+
+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
+
+PASS shaders.length is 2
+PASS shaders[0] == standardVert && shaders[1] == standardFrag || shaders[1] == standardVert && shaders[0] == standardFrag is true
+PASS getError was expected value: NO_ERROR : 
+PASS gl.getAttachedShaders(null) is null
+PASS getError was expected value: INVALID_VALUE : 
+PASS gl.getAttachedShaders(standardVert) threw exception TypeError: Type error.
+PASS getError was expected value: NO_ERROR : 
+PASS gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_SIZE) is 16
+PASS gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_USAGE) is gl.DYNAMIC_DRAW
+PASS getError was expected value: NO_ERROR : 
+PASS getError was expected value: NO_ERROR : 
+PASS getError was expected value: NO_ERROR : 
+PASS gl.checkFramebufferStatus(gl.FRAMEBUFFER) is gl.FRAMEBUFFER_COMPLETE
+PASS gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE) is gl.TEXTURE
+PASS gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME) is texture
+PASS gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL) is 0
+PASS gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE) is 0
+PASS gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE) is gl.RENDERBUFFER
+PASS gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME) is renderbuffer
+PASS gl.getProgramParameter(standardProgram, gl.DELETE_STATUS) is false
+PASS gl.getProgramParameter(standardProgram, gl.LINK_STATUS) is true
+PASS typeof gl.getProgramParameter(standardProgram, gl.VALIDATE_STATUS) is "boolean"
+PASS gl.getProgramParameter(standardProgram, gl.ATTACHED_SHADERS) is 2
+PASS gl.getProgramParameter(standardProgram, gl.ACTIVE_ATTRIBUTES) is 2
+PASS gl.getProgramParameter(standardProgram, gl.ACTIVE_UNIFORMS) is 1
+PASS gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_WIDTH) is 2
+PASS gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_HEIGHT) is 2
+PASS gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_INTERNAL_FORMAT) is non-zero.
+PASS gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_DEPTH_SIZE) is non-zero.
+PASS getError was expected value: NO_ERROR : 
+PASS getError was expected value: NO_ERROR : 
+PASS gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_RED_SIZE) is non-zero.
+PASS gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_GREEN_SIZE) is non-zero.
+PASS gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_BLUE_SIZE) is non-zero.
+PASS gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_ALPHA_SIZE) is non-zero.
+PASS gl.getShaderParameter(standardVert, gl.SHADER_TYPE) is gl.VERTEX_SHADER
+PASS gl.getShaderParameter(standardVert, gl.DELETE_STATUS) is false
+PASS gl.getShaderParameter(standardVert, gl.COMPILE_STATUS) is true
+PASS gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER) is gl.NEAREST
+PASS gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER) is gl.NEAREST
+PASS gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S) is gl.CLAMP_TO_EDGE
+PASS gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T) is gl.CLAMP_TO_EDGE
+PASS gl.getProgramParameter(boolProgram, gl.LINK_STATUS) is true
+PASS getError was expected value: NO_ERROR : 
+PASS gl.getUniform(boolProgram, bvalLoc) is true
+PASS gl.getUniform(boolProgram, bval2Loc) is [true, false]
+PASS gl.getUniform(boolProgram, bval3Loc) is [true, false, true]
+PASS gl.getUniform(boolProgram, bval4Loc) is [true, false, true, false]
+PASS gl.getProgramParameter(intProgram, gl.LINK_STATUS) is true
+PASS getError was expected value: NO_ERROR : 
+PASS gl.getUniform(intProgram, ivalLoc) is 1
+PASS gl.getUniform(intProgram, ival2Loc) is [2, 3]
+PASS gl.getUniform(intProgram, ival3Loc) is [4, 5, 6]
+PASS gl.getUniform(intProgram, ival4Loc) is [7, 8, 9, 10]
+PASS gl.getProgramParameter(floatProgram, gl.LINK_STATUS) is true
+PASS getError was expected value: NO_ERROR : 
+PASS gl.getUniform(floatProgram, fvalLoc) is 11
+PASS gl.getUniform(floatProgram, fval2Loc) is [12, 13]
+PASS gl.getUniform(floatProgram, fval3Loc) is [14, 15, 16]
+PASS gl.getUniform(floatProgram, fval4Loc) is [17, 18, 19, 20]
+PASS gl.getProgramParameter(samplerProgram, gl.LINK_STATUS) is true
+PASS getError was expected value: NO_ERROR : 
+PASS gl.getUniform(samplerProgram, s2DValLoc) is 0
+PASS gl.getUniform(samplerProgram, sCubeValLoc) is 1
+PASS gl.getProgramParameter(matProgram, gl.LINK_STATUS) is true
+PASS getError was expected value: NO_ERROR : 
+PASS gl.getUniform(matProgram, mval2Loc) is [1, 2, 3, 4]
+PASS gl.getUniform(matProgram, mval3Loc) is [5, 6, 7, 8, 9, 10, 11, 12, 13]
+PASS gl.getUniform(matProgram, mval4Loc) is [14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
+PASS gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) is buffer
+PASS gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_ENABLED) is true
+PASS gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_SIZE) is 4
+PASS gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_STRIDE) is 0
+PASS gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_TYPE) is gl.FLOAT
+PASS gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED) is false
+PASS gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_STRIDE) is 36
+PASS gl.getVertexAttribOffset(1, gl.VERTEX_ATTRIB_ARRAY_POINTER) is 12
+PASS gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_ENABLED) is false
+PASS gl.getVertexAttrib(1, gl.CURRENT_VERTEX_ATTRIB) is [5, 6, 7, 8]
+PASS getError was expected value: NO_ERROR : 
+PASS gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE) is gl.NONE
+PASS gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE) is gl.NONE
+PASS gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) is null
+PASS getError was expected value: NO_ERROR : 
+PASS successfullyParsed is true
+
+TEST COMPLETE
+
diff --git a/LayoutTests/fast/canvas/webgl/gl-object-get-calls.html b/LayoutTests/fast/canvas/webgl/gl-object-get-calls.html
new file mode 100644
index 0000000..92a7ecb
--- /dev/null
+++ b/LayoutTests/fast/canvas/webgl/gl-object-get-calls.html
@@ -0,0 +1,252 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<link rel="stylesheet" href="../../js/resources/js-test-style.css"/>
+<script src="../../js/resources/js-test-pre.js"></script>
+<script src="resources/webgl-test.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+
+<script>
+description("Test of get calls against GL objects like getBufferParameter, etc.");
+
+function sizeInBytes(type) {
+  switch (type) {
+  case gl.BYTE:
+  case gl.UNSIGNED_BYTE:
+    return 1;
+  case gl.SHORT:
+  case gl.UNSIGNED_SHORT:
+    return 2;
+  case gl.INT:
+  case gl.UNSIGNED_INT:
+  case gl.FLOAT:
+    return 4;
+  default:
+    throw "unknown type";
+  }
+}
+
+var gl = create3DContext();
+
+var standardVert = loadStandardVertexShader(gl);
+var standardFrag = loadStandardFragmentShader(gl);
+var standardProgram = gl.createProgram();
+gl.attachShader(standardProgram, standardVert);
+gl.attachShader(standardProgram, standardFrag);
+gl.linkProgram(standardProgram);
+var shaders = gl.getAttachedShaders(standardProgram);
+shouldBe('shaders.length', '2');
+shouldBeTrue('shaders[0] == standardVert && shaders[1] == standardFrag || shaders[1] == standardVert && shaders[0] == standardFrag');
+glErrorShouldBe(gl, gl.NO_ERROR);
+shouldBeNull('gl.getAttachedShaders(null)');
+glErrorShouldBe(gl, gl.INVALID_VALUE);
+shouldThrow('gl.getAttachedShaders(standardVert)');
+glErrorShouldBe(gl, gl.NO_ERROR);
+
+// Test getBufferParameter
+var buffer = gl.createBuffer();
+gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+gl.bufferData(gl.ARRAY_BUFFER, 16, gl.DYNAMIC_DRAW);
+shouldBe('gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_SIZE)', '16');
+shouldBe('gl.getBufferParameter(gl.ARRAY_BUFFER, gl.BUFFER_USAGE)', 'gl.DYNAMIC_DRAW');
+
+// Test getFramebufferAttachmentParameter
+var texture = gl.createTexture();
+gl.bindTexture(gl.TEXTURE_2D, texture);
+gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 2, 2, 0, gl.RGBA, gl.UNSIGNED_BYTE,
+              new Uint8Array([
+                  0, 0, 0, 255,
+                  255, 255, 255, 255,
+                  255, 255, 255, 255,
+                  0, 0, 0, 255]));
+gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+gl.bindTexture(gl.TEXTURE_2D, null);
+var framebuffer = gl.createFramebuffer();
+gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+var renderbuffer = gl.createRenderbuffer();
+glErrorShouldBe(gl, gl.NO_ERROR);
+gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer);
+glErrorShouldBe(gl, gl.NO_ERROR);
+gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, 2, 2);
+glErrorShouldBe(gl, gl.NO_ERROR);
+gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, renderbuffer);
+// FIXME: on some machines (in particular the WebKit commit bots) the
+// framebuffer status is FRAMEBUFFER_UNSUPPORTED; more investigation
+// is needed why this is the case, because the FBO allocated
+// internally by the WebKit implementation has almost identical
+// parameters to this one. See https://bugs.webkit.org/show_bug.cgi?id=31843.
+shouldBe('gl.checkFramebufferStatus(gl.FRAMEBUFFER)', 'gl.FRAMEBUFFER_COMPLETE');
+shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.TEXTURE');
+shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)', 'texture');
+shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL)', '0');
+shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE)', '0');
+
+shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.RENDERBUFFER');
+shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)', 'renderbuffer');
+
+// Test getProgramParameter
+shouldBe('gl.getProgramParameter(standardProgram, gl.DELETE_STATUS)', 'false');
+shouldBe('gl.getProgramParameter(standardProgram, gl.LINK_STATUS)', 'true');
+shouldBe('typeof gl.getProgramParameter(standardProgram, gl.VALIDATE_STATUS)', '"boolean"');
+shouldBe('gl.getProgramParameter(standardProgram, gl.ATTACHED_SHADERS)', '2');
+shouldBe('gl.getProgramParameter(standardProgram, gl.ACTIVE_ATTRIBUTES)', '2');
+shouldBe('gl.getProgramParameter(standardProgram, gl.ACTIVE_UNIFORMS)', '1');
+
+// Test getRenderbufferParameter
+shouldBe('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_WIDTH)', '2');
+shouldBe('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_HEIGHT)', '2');
+// Note: we can't test the actual value of the internal format since
+// the implementation is allowed to change it.
+shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_INTERNAL_FORMAT)');
+shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_DEPTH_SIZE)');
+var colorbuffer = gl.createRenderbuffer();
+glErrorShouldBe(gl, gl.NO_ERROR);
+gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer);
+glErrorShouldBe(gl, gl.NO_ERROR);
+gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGBA4, 2, 2);
+shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_RED_SIZE)');
+shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_GREEN_SIZE)');
+shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_BLUE_SIZE)');
+shouldBeNonZero('gl.getRenderbufferParameter(gl.RENDERBUFFER, gl.RENDERBUFFER_ALPHA_SIZE)');
+
+// Test getShaderParameter
+shouldBe('gl.getShaderParameter(standardVert, gl.SHADER_TYPE)', 'gl.VERTEX_SHADER');
+shouldBe('gl.getShaderParameter(standardVert, gl.DELETE_STATUS)', 'false');
+shouldBe('gl.getShaderParameter(standardVert, gl.COMPILE_STATUS)', 'true');
+
+// Test getTexParameter
+gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+gl.bindTexture(gl.TEXTURE_2D, texture);
+gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER)', 'gl.NEAREST');
+shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER)', 'gl.NEAREST');
+shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S)', 'gl.CLAMP_TO_EDGE');
+shouldBe('gl.getTexParameter(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T)', 'gl.CLAMP_TO_EDGE');
+
+// Test getUniform with all variants of data types
+// Boolean uniform variables
+var boolProgram = loadProgram(gl, "resources/boolUniformShader.vert", "resources/noopUniformShader.frag");
+shouldBe('gl.getProgramParameter(boolProgram, gl.LINK_STATUS)', 'true');
+var bvalLoc = gl.getUniformLocation(boolProgram, "bval");
+var bval2Loc = gl.getUniformLocation(boolProgram, "bval2");
+var bval3Loc = gl.getUniformLocation(boolProgram, "bval3");
+var bval4Loc = gl.getUniformLocation(boolProgram, "bval4");
+gl.useProgram(boolProgram);
+gl.uniform1i(bvalLoc, 1);
+gl.uniform2i(bval2Loc, 1, 0);
+gl.uniform3i(bval3Loc, 1, 0, 1);
+gl.uniform4i(bval4Loc, 1, 0, 1, 0);
+glErrorShouldBe(gl, gl.NO_ERROR);
+shouldBe('gl.getUniform(boolProgram, bvalLoc)', 'true');
+shouldBe('gl.getUniform(boolProgram, bval2Loc)', '[true, false]');
+shouldBe('gl.getUniform(boolProgram, bval3Loc)', '[true, false, true]');
+shouldBe('gl.getUniform(boolProgram, bval4Loc)', '[true, false, true, false]');
+// Integer uniform variables
+var intProgram = loadProgram(gl, "resources/intUniformShader.vert", "resources/noopUniformShader.frag");
+shouldBe('gl.getProgramParameter(intProgram, gl.LINK_STATUS)', 'true');
+var ivalLoc = gl.getUniformLocation(intProgram, "ival");
+var ival2Loc = gl.getUniformLocation(intProgram, "ival2");
+var ival3Loc = gl.getUniformLocation(intProgram, "ival3");
+var ival4Loc = gl.getUniformLocation(intProgram, "ival4");
+gl.useProgram(intProgram);
+gl.uniform1i(ivalLoc, 1);
+gl.uniform2i(ival2Loc, 2, 3);
+gl.uniform3i(ival3Loc, 4, 5, 6);
+gl.uniform4i(ival4Loc, 7, 8, 9, 10);
+glErrorShouldBe(gl, gl.NO_ERROR);
+shouldBe('gl.getUniform(intProgram, ivalLoc)', '1');
+shouldBe('gl.getUniform(intProgram, ival2Loc)', '[2, 3]');
+shouldBe('gl.getUniform(intProgram, ival3Loc)', '[4, 5, 6]');
+shouldBe('gl.getUniform(intProgram, ival4Loc)', '[7, 8, 9, 10]');
+// Float uniform variables
+var floatProgram = loadProgram(gl, "resources/floatUniformShader.vert", "resources/noopUniformShader.frag");
+shouldBe('gl.getProgramParameter(floatProgram, gl.LINK_STATUS)', 'true');
+var fvalLoc = gl.getUniformLocation(floatProgram, "fval");
+var fval2Loc = gl.getUniformLocation(floatProgram, "fval2");
+var fval3Loc = gl.getUniformLocation(floatProgram, "fval3");
+var fval4Loc = gl.getUniformLocation(floatProgram, "fval4");
+gl.useProgram(floatProgram);
+gl.uniform1f(fvalLoc, 11);
+gl.uniform2f(fval2Loc, 12, 13);
+gl.uniform3f(fval3Loc, 14, 15, 16);
+gl.uniform4f(fval4Loc, 17, 18, 19, 20);
+glErrorShouldBe(gl, gl.NO_ERROR);
+shouldBe('gl.getUniform(floatProgram, fvalLoc)', '11');
+shouldBe('gl.getUniform(floatProgram, fval2Loc)', '[12, 13]');
+shouldBe('gl.getUniform(floatProgram, fval3Loc)', '[14, 15, 16]');
+shouldBe('gl.getUniform(floatProgram, fval4Loc)', '[17, 18, 19, 20]');
+// Sampler uniform variables
+var samplerProgram = loadProgram(gl, "resources/noopUniformShader.vert", "resources/samplerUniformShader.frag");
+shouldBe('gl.getProgramParameter(samplerProgram, gl.LINK_STATUS)', 'true');
+var s2DValLoc = gl.getUniformLocation(samplerProgram, "s2D");
+var sCubeValLoc = gl.getUniformLocation(samplerProgram, "sCube");
+gl.useProgram(samplerProgram);
+gl.uniform1i(s2DValLoc, 0);
+gl.uniform1i(sCubeValLoc, 1);
+glErrorShouldBe(gl, gl.NO_ERROR);
+shouldBe('gl.getUniform(samplerProgram, s2DValLoc)', '0');
+shouldBe('gl.getUniform(samplerProgram, sCubeValLoc)', '1');
+// Matrix uniform variables
+var matProgram = loadProgram(gl, "resources/matUniformShader.vert", "resources/noopUniformShader.frag");
+shouldBe('gl.getProgramParameter(matProgram, gl.LINK_STATUS)', 'true');
+var mval2Loc = gl.getUniformLocation(matProgram, "mval2");
+var mval3Loc = gl.getUniformLocation(matProgram, "mval3");
+var mval4Loc = gl.getUniformLocation(matProgram, "mval4");
+gl.useProgram(matProgram);
+gl.uniformMatrix2fv(mval2Loc, false, [1, 2, 3, 4]);
+gl.uniformMatrix3fv(mval3Loc, false, [5, 6, 7, 8, 9, 10, 11, 12, 13]);
+gl.uniformMatrix4fv(mval4Loc, false, [14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]);
+glErrorShouldBe(gl, gl.NO_ERROR);
+shouldBe('gl.getUniform(matProgram, mval2Loc)', '[1, 2, 3, 4]');
+shouldBe('gl.getUniform(matProgram, mval3Loc)', '[5, 6, 7, 8, 9, 10, 11, 12, 13]');
+shouldBe('gl.getUniform(matProgram, mval4Loc)', '[14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]');
+
+// Test getVertexAttrib
+var array = new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+gl.bufferData(gl.ARRAY_BUFFER, array, gl.DYNAMIC_DRAW);
+// Vertex attribute 0 is special in that it has no current state, so
+// fetching GL_CURRENT_VERTEX_ATTRIB generates an error. Use attribute
+// 1 for these tests instead.
+gl.enableVertexAttribArray(1);
+gl.vertexAttribPointer(1, 4, gl.FLOAT, false, 0, 0);
+shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING)', 'buffer');
+shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_ENABLED)', 'true');
+shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_SIZE)', '4');
+// Stride MUST be the value the user put in.
+shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_STRIDE)', '0');
+shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_TYPE)', 'gl.FLOAT');
+shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED)', 'false');
+gl.vertexAttribPointer(1, 4, gl.FLOAT, false, 36, 12);
+shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_STRIDE)', '36');
+shouldBe('gl.getVertexAttribOffset(1, gl.VERTEX_ATTRIB_ARRAY_POINTER)', '12');
+gl.disableVertexAttribArray(1);
+shouldBe('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_ENABLED)', 'false');
+gl.vertexAttrib4f(1, 5, 6, 7, 8);
+shouldBe('gl.getVertexAttrib(1, gl.CURRENT_VERTEX_ATTRIB)', '[5, 6, 7, 8]');
+glErrorShouldBe(gl, gl.NO_ERROR);
+
+// Test cases where name == 0
+gl.deleteTexture(texture);
+shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.NONE');
+gl.deleteRenderbuffer(renderbuffer);
+shouldBe('gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)', 'gl.NONE');
+gl.deleteBuffer(buffer);
+shouldBeNull('gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING)');
+glErrorShouldBe(gl, gl.NO_ERROR);
+
+successfullyParsed = true;
+</script>
+
+<script src="../../js/resources/js-test-post.js"></script>
+</body>
+</html>
diff --git a/LayoutTests/fast/canvas/webgl/object-deletion-behaviour.html b/LayoutTests/fast/canvas/webgl/object-deletion-behaviour.html
index 0c6b115..02053ff 100644
--- a/LayoutTests/fast/canvas/webgl/object-deletion-behaviour.html
+++ b/LayoutTests/fast/canvas/webgl/object-deletion-behaviour.html
@@ -2,6 +2,7 @@
 <html>
 <head>
 <meta charset="utf-8">
+<link rel="stylesheet" href="../../js/resources/js-test-style.css"/>
 <script src="../../js/resources/js-test-pre.js"></script>
 <script src="resources/webgl-test.js"></script>
 <script src="resources/webgl-test-utils.js"></script>
@@ -26,7 +27,6 @@ var fragmentShader = wtu.loadStandardFragmentShader(gl);
 assertMsg(fragmentShader, "fragment shader loaded");
 
 var program = gl.createProgram();
-shouldBeNonNull("program");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.attachShader(program, vertexShader)");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.attachShader(program, fragmentShader)");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.linkProgram(program)");
@@ -50,19 +50,14 @@ shouldBeFalse("gl.isShader(fragmentShader)");
 debug("");
 debug("texture deletion");
 
-var fbo = gl.createFramebuffer(), fbo2 = gl.createFramebuffer(), fbo3 = gl.createFramebuffer();
-shouldBeNonNull("fbo");
-shouldBeNonNull("fbo2");
-shouldBeNonNull("fbo3");
+var fbo = gl.createFramebuffer();
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo)");
 
 var tex = gl.createTexture();
-shouldBeNonNull("tex");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindTexture(gl.TEXTURE_2D, tex)");
 shouldBe("gl.getParameter(gl.TEXTURE_BINDING_2D)", "tex");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, 0)");
 shouldBe("gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)", "tex");
-shouldBe("gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)", "gl.TEXTURE");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteTexture(tex)");
 // Deleting a texture bound to the currently-bound fbo is the same as
 // detaching the textue from fbo first, then delete the texture.
@@ -74,7 +69,6 @@ shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindTexture(gl.TEXTURE_2D, tex)");
 shouldBeNull("gl.getParameter(gl.TEXTURE_BINDING_2D)");
 
 var texCubeMap = gl.createTexture();
-shouldBeNonNull("texCubeMap");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindTexture(gl.TEXTURE_CUBE_MAP, texCubeMap)");
 shouldBe("gl.getParameter(gl.TEXTURE_BINDING_CUBE_MAP)", "texCubeMap");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteTexture(texCubeMap)");
@@ -83,34 +77,10 @@ shouldBeNull("gl.getParameter(gl.TEXTURE_BINDING_CUBE_MAP)");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindTexture(gl.TEXTURE_CUBE_MAP, texCubeMap)");
 shouldBeNull("gl.getParameter(gl.TEXTURE_BINDING_CUBE_MAP)");
 
-var t = gl.createTexture();
-shouldBeNonNull("t");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindTexture(gl.TEXTURE_2D, t)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteTexture(t)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindTexture(gl.TEXTURE_2D, t)");
-shouldGenerateGLError(gl, gl.INVALID_OPERATION, "gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)");
-
-var t2 = gl.createTexture();
-shouldBeNonNull("t2");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.activeTexture(gl.TEXTURE0)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindTexture(gl.TEXTURE_2D, t2)");
-shouldBe("gl.getParameter(gl.TEXTURE_BINDING_2D)", "t2");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.activeTexture(gl.TEXTURE1)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindTexture(gl.TEXTURE_2D, t2)");
-shouldBe("gl.getParameter(gl.TEXTURE_BINDING_2D)", "t2");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteTexture(t2)");
-shouldBeNull("gl.getParameter(gl.TEXTURE_BINDING_2D)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.activeTexture(gl.TEXTURE0)");
-shouldBeNull("gl.getParameter(gl.TEXTURE_BINDING_2D)");
-
 debug("");
 debug("renderbuffer deletion");
 
-var rbo = gl.createRenderbuffer(), rbo2 = gl.createRenderbuffer(), rbo3 = gl.createRenderbuffer();
-shouldBeNonNull("rbo");
-shouldBeNonNull("rbo2");
-shouldBeNonNull("rbo3");
+var rbo = gl.createRenderbuffer();
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindRenderbuffer(gl.RENDERBUFFER, rbo)");
 shouldBe("gl.getParameter(gl.RENDERBUFFER_BINDING)", "rbo");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, rbo)");
@@ -124,184 +94,11 @@ shouldBeFalse("gl.isRenderbuffer(rbo)");
 shouldBeNull("gl.getParameter(gl.RENDERBUFFER_BINDING)");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindRenderbuffer(gl.RENDERBUFFER, rbo)");
 shouldBeNull("gl.getParameter(gl.RENDERBUFFER_BINDING)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindRenderbuffer(gl.RENDERBUFFER, rbo2)");
-shouldBe("gl.getParameter(gl.RENDERBUFFER_BINDING)", "rbo2");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteRenderbuffer(rbo3)");
-shouldBe("gl.getParameter(gl.RENDERBUFFER_BINDING)", "rbo2");
-
-debug("");
-debug("using deleted renderbuffer");
-rbo = gl.createRenderbuffer();
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindRenderbuffer(gl.RENDERBUFFER, rbo)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGBA4, 16, 16)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, rbo)");
-if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) == gl.FRAMEBUFFER_COMPLETE) {
-  // make backbuffer red
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, null)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clearColor(1,0,0,1)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clear(gl.COLOR_BUFFER_BIT)");
-  // make fbo green
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clearColor(0,1,0,1)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clear(gl.COLOR_BUFFER_BIT)");
-  // Bind backbuffer.
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, null)");
-  // delete renderbuffer. It should still be attached to fbo though.
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteRenderbuffer(rbo)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 16, 16, [255,0,0,255], "backbuffer should be red")');
-  // Use fbo that has deleted rbo.
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 16, 16, [0,255,0,255], "fbo should be green")');
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clearColor(0,0,1,1)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clear(gl.COLOR_BUFFER_BIT)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 16, 16, [0,0,255,255], "fbo should be blue")');
-  // Bind backbuffer.
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, null)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 16, 16, [255,0,0,255], "backbuffer should be red")');
-}
-
-debug("");
-debug("renderbuffer attached twice to same framebuffer");
-rbo = gl.createRenderbuffer();
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindRenderbuffer(gl.RENDERBUFFER, rbo)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGBA4, 16, 16)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, rbo)");
-if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) == gl.FRAMEBUFFER_COMPLETE) {
-  rbo2 = gl.createRenderbuffer();
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindRenderbuffer(gl.RENDERBUFFER, rbo2)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGBA4, 16, 16)");
-  // attach rbo2 at two attachment points incompatible with it
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, rbo2)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.RENDERBUFFER, rbo2)");
-  shouldBe("gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)", "rbo2");
-  shouldBe("gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)", "rbo2");
-  // fbo can't be complete as rbo2 is attached at incompatible attachment points
-  shouldNotBe("gl.checkFramebufferStatus(gl.FRAMEBUFFER)", "gl.FRAMEBUFFER_COMPLETE");
-  // now we delete rbo2, which detaches it from the two attachment points where it currently is attached
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteRenderbuffer(rbo2)");
-  shouldBe("gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)", "gl.NONE");
-  shouldBe("gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)", "gl.NONE");
-  // we should now be in the same state as before with only rbo attached, so fbo should be complete again
-  shouldBe("gl.checkFramebufferStatus(gl.FRAMEBUFFER)", "gl.FRAMEBUFFER_COMPLETE");
-  shouldBe("gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)", "rbo");
-}
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteRenderbuffer(rbo)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, null)");
-
-
-
-debug("");
-debug("using deleted texture");
-tex = gl.createTexture();
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindTexture(gl.TEXTURE_2D, tex)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, 0)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, null)");
-if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) == gl.FRAMEBUFFER_COMPLETE) {
-  // make fbo green
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clearColor(0,1,0,1)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clear(gl.COLOR_BUFFER_BIT)");
-  // Bind backbuffer.
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, null)");
-  // delete texture. It should still be attached to fbo though.
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteTexture(tex)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 1, 1, [255,0,0,255], "backbuffer should be red")');
-  // Use fbo that has deleted texture.
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 1, 1, [0,255,0,255], "fbo should be green")');
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clearColor(0,0,1,1)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clear(gl.COLOR_BUFFER_BIT)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 1, 1, [0,0,255,255], "fbo should be blue")');
-  // Bind backbuffer.
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, null)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 16, 16, [255,0,0,255], "backbuffer should be red")');
-}
-
-debug("");
-debug("using deleted renderbuffer");
-rbo = gl.createRenderbuffer();
-shouldBeNonNull("rbo");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindRenderbuffer(gl.RENDERBUFFER, rbo)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGBA4, 16, 16)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, rbo)");
-if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) == gl.FRAMEBUFFER_COMPLETE) {
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo2)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, rbo)");
-  shouldBe("gl.checkFramebufferStatus(gl.FRAMEBUFFER)", "gl.FRAMEBUFFER_COMPLETE");
-  // make backbuffer red
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, null)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clearColor(1,0,0,1)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clear(gl.COLOR_BUFFER_BIT)");
-  // make fbo green
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clearColor(0,1,0,1)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clear(gl.COLOR_BUFFER_BIT)");
-  // delete renderbuffer. It should still be attached to fbo2 though.
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteRenderbuffer(rbo)");
-  // fbo has no attachments
-  shouldNotBe("gl.checkFramebufferStatus(gl.FRAMEBUFFER)", "gl.FRAMEBUFFER_COMPLETE");
-  // Use fbo2 that has deleted rbo.
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo2)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 16, 16, [0,255,0,255], "fbo should be green")');
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clearColor(0,0,1,1)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clear(gl.COLOR_BUFFER_BIT)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 16, 16, [0,0,255,255], "fbo should be blue")');
-  shouldBe("gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)", "rbo");
-
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo)");
-  shouldGenerateGLError(gl, gl.INVALID_ENUM, "gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)");
-  shouldGenerateGLError(gl, gl.NONE, "gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)");
-  shouldNotBe("gl.checkFramebufferStatus(gl.FRAMEBUFFER)", "gl.FRAMEBUFFER_COMPLETE");
-  // Bind backbuffer.
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, null)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 16, 16, [255,0,0,255], "backbuffer should be red")');
-}
-
-debug("");
-debug("using deleted texture");
-tex = gl.createTexture();
-shouldBeNonNull("tex");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindTexture(gl.TEXTURE_2D, tex)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, 0)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, null)");
-if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) == gl.FRAMEBUFFER_COMPLETE) {
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo2)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, 0)");
-  // make fbo green
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clearColor(0,1,0,1)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clear(gl.COLOR_BUFFER_BIT)");
-  // delete texture. It should still be attached to fbo2 though.
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteTexture(tex)");
-  // fbo has no attachments
-  shouldNotBe("gl.checkFramebufferStatus(gl.FRAMEBUFFER)", "gl.FRAMEBUFFER_COMPLETE");
-  // Use fbo that has deleted texture.
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo2)");
-  shouldBe("gl.checkFramebufferStatus(gl.FRAMEBUFFER)", "gl.FRAMEBUFFER_COMPLETE");
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 1, 1, [0,255,0,255], "fbo should be green")');
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clearColor(0,0,1,1)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clear(gl.COLOR_BUFFER_BIT)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 1, 1, [0,0,255,255], "fbo should be blue")');
-  shouldBe("gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)", "tex");
-
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo)");
-  shouldGenerateGLError(gl, gl.INVALID_ENUM, "gl.getFramebufferAttachmentParameter(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)");
-  shouldNotBe("gl.checkFramebufferStatus(gl.FRAMEBUFFER)", "gl.FRAMEBUFFER_COMPLETE");
-  // Bind backbuffer.
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, null)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 16, 16, [255,0,0,255], "backbuffer should be red")');
-}
 
 debug("");
 debug("buffer deletion");
 
 var buffer = gl.createBuffer();
-shouldBeNonNull("buffer");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindBuffer(gl.ARRAY_BUFFER, buffer)");
 shouldBe("gl.getParameter(gl.ARRAY_BUFFER_BINDING)", "buffer");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteBuffer(buffer)");
@@ -310,19 +107,7 @@ shouldBeNull("gl.getParameter(gl.ARRAY_BUFFER_BINDING)");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindBuffer(gl.ARRAY_BUFFER, buffer)");
 shouldBeNull("gl.getParameter(gl.ARRAY_BUFFER_BINDING)");
 
-var buffer2 = gl.createBuffer();
-shouldBeNonNull("buffer2");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindBuffer(gl.ARRAY_BUFFER, buffer2)");
-shouldBe("gl.getParameter(gl.ARRAY_BUFFER_BINDING)", "buffer2");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindBuffer(gl.ARRAY_BUFFER, null)");
-shouldBeNull("gl.getParameter(gl.ARRAY_BUFFER_BINDING)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteBuffer(buffer2)");
-shouldBeFalse("gl.isBuffer(buffer2)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindBuffer(gl.ARRAY_BUFFER, buffer2)");
-shouldBeNull("gl.getParameter(gl.ARRAY_BUFFER_BINDING)");
-
 var bufferElement = gl.createBuffer();
-shouldBeNonNull("bufferElement");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, bufferElement)");
 shouldBe("gl.getParameter(gl.ELEMENT_ARRAY_BUFFER_BINDING)", "bufferElement");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteBuffer(bufferElement)");
@@ -331,36 +116,6 @@ shouldBeNull("gl.getParameter(gl.ELEMENT_ARRAY_BUFFER_BINDING)");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, bufferElement)");
 shouldBeNull("gl.getParameter(gl.ELEMENT_ARRAY_BUFFER_BINDING)");
 
-var b = gl.createBuffer();
-shouldBeNonNull("b");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindBuffer(gl.ARRAY_BUFFER, b)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bufferData(gl.ARRAY_BUFFER, 1, gl.STATIC_DRAW)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteBuffer(b)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindBuffer(gl.ARRAY_BUFFER, b)");
-shouldGenerateGLError(gl, gl.INVALID_OPERATION, "gl.bufferData(gl.ARRAY_BUFFER, 1, gl.STATIC_DRAW)");
-
-var b1 = gl.createBuffer();
-shouldBeNonNull("b1");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindBuffer(gl.ARRAY_BUFFER, b1);");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.enableVertexAttribArray(1);");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.vertexAttribPointer(1, 4, gl.FLOAT, false, 0, 0);");
-var b2 = gl.createBuffer();
-shouldBeNonNull("b2");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindBuffer(gl.ARRAY_BUFFER, b2);");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.enableVertexAttribArray(2);");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.vertexAttribPointer(2, 4, gl.FLOAT, false, 0, 0);");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.enableVertexAttribArray(3);");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.vertexAttribPointer(3, 4, gl.FLOAT, false, 0, 0);");
-shouldBe("gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING)", "b1");
-shouldBe("gl.getVertexAttrib(2, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING)", "b2");
-shouldBe("gl.getVertexAttrib(3, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING)", "b2");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteBuffer(b2);");
-shouldBe("gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING)", "b1");
-shouldBeNull("gl.getVertexAttrib(2, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING)");
-shouldBeNull("gl.getVertexAttrib(3, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteBuffer(b1);");
-shouldBeNull("gl.getVertexAttrib(1, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING)");
-
 debug("");
 debug("framebuffer deletion");
 
@@ -371,45 +126,6 @@ shouldBeFalse("gl.isFramebuffer(fbo)");
 shouldBeNull("gl.getParameter(gl.FRAMEBUFFER_BINDING)");
 shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo)");
 shouldBeNull("gl.getParameter(gl.FRAMEBUFFER_BINDING)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo2)");
-shouldBe("gl.getParameter(gl.FRAMEBUFFER_BINDING)", "fbo2");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteFramebuffer(fbo3)");
-shouldBe("gl.getParameter(gl.FRAMEBUFFER_BINDING)", "fbo2");
-
-fbo = gl.createFramebuffer();
-rbo = gl.createRenderbuffer();
-shouldBeNonNull("fbo");
-shouldBeNonNull("rbo");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindRenderbuffer(gl.RENDERBUFFER, rbo)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.renderbufferStorage(gl.RENDERBUFFER, gl.RGBA4, 16, 16)");
-shouldGenerateGLError(gl, gl.NO_ERROR, "gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, rbo)");
-if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) == gl.FRAMEBUFFER_COMPLETE) {
-  // set backbuffer to red
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, null)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clearColor(1,0,0,1)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clear(gl.COLOR_BUFFER_BIT)");
-  // set framebuffer to green
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, fbo)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clearColor(0,1,0,1)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clear(gl.COLOR_BUFFER_BIT)");
-  // check framebuffer
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 16, 16, [0,255,0,255], "fbo should be green")');
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 16, 16, 1, 1, [0,0,0,0], "outside fbo should be black")');
-  // delete framebuffer. because this was the bound fbo the backbuffer should be active now
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.deleteFramebuffer(fbo)");
-  // check backbuffer
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 300, 150, [255,0,0,255], "backbuffer should be red")');
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 300, 0, 300, 300, [0,0,0,0], "outside backbuffer should be black")');
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 150, 300, 300, [0,0,0,0], "outside backbuffer should be black")');
-  // check drawing to backbuffer
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clearColor(0,1,0,1)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.clear(gl.COLOR_BUFFER_BIT)");
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 300, 150, [0,255,0,255], "fbo should be green")');
-  shouldGenerateGLError(gl, gl.NO_ERROR, "gl.bindFramebuffer(gl.FRAMEBUFFER, null)");
-  // check again because many buggy implementations will have bound to the true backbuffer on deleteFramebuffer.
-  shouldGenerateGLError(gl, gl.NO_ERROR, 'wtu.checkCanvasRect(gl, 0, 0, 300, 150, [0,255,0,255], "fbo should be green")');
-}
 
 successfullyParsed = true;
 </script>
diff --git a/LayoutTests/fast/canvas/webgl/program-test.html b/LayoutTests/fast/canvas/webgl/program-test.html
new file mode 100644
index 0000000..9b4575a
--- /dev/null
+++ b/LayoutTests/fast/canvas/webgl/program-test.html
@@ -0,0 +1,311 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL Program Compiling/Linking Conformance Test</title>
+<link rel="stylesheet" href="../../js/resources/js-test-style.css"/>
+<script src="../../js/resources/js-test-pre.js" type="text/javascript"></script>
+<script src="resources/webgl-test.js" type="text/javascript"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="canvas" width="2" height="2"> </canvas>
+<script type="text/javascript">
+function go() {
+    description("Tests that program compiling/linking/using works correctly.");
+
+    debug("");
+    debug("Canvas.getContext");
+
+    var gl = create3DContext(document.getElementById("canvas"));
+    if (!gl) {
+        testFailed("context does not exist");
+        return;
+    }
+
+    testPassed("context exists");
+
+    gl.clearColor(0.0, 0.0, 0.0, 0.0);
+    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+
+    function doArraysHaveSameContents(a, b) {
+        var flags = [];
+        function hasUnusedValue(a, value) {
+            for (var ii = 0; ii < a.length; ++ii) {
+                if (a[ii] === value && !flags[ii]) {
+                    flags[ii] = true;
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        try {
+            if (a.length !== b.length) {
+                return false;
+            }
+            for (var ii = 0; ii < a.length; ii++) {
+                if (!hasUnusedValue(b, a[ii])) {
+                    return false;
+                }
+            }
+        } catch (ex) {
+            return false;
+        }
+        return true;
+    }
+
+/////// Check compileShader() /////////////////////////////
+
+    var vs = gl.createShader(gl.VERTEX_SHADER);
+    gl.shaderSource(vs, "attribute vec4 aVertex; attribute vec4 aColor; varying vec4 vColor; void main() { vColor = aColor; gl_Position = aVertex; }");
+    gl.compileShader(vs);
+
+    assertMsg(gl.getShaderParameter(vs, gl.COMPILE_STATUS) == true,
+              "good vertex shader should compile");
+
+    var vs2 = gl.createShader(gl.VERTEX_SHADER);
+    gl.shaderSource(vs2, "attribute vec4 aVertex; attribute vec4 aColor; varying vec4 vColor; void main() { vColor = aColor; gl_Position = aVertex * 0.5; }");
+    gl.compileShader(vs2);
+
+    assertMsg(gl.getShaderParameter(vs2, gl.COMPILE_STATUS) == true,
+              "good vertex shader #2 should compile");
+
+    var vsBad = gl.createShader(gl.VERTEX_SHADER);
+    gl.shaderSource(vsBad, "WILL NOT COMPILE;");
+    gl.compileShader(vsBad);
+
+    assertMsg(gl.getShaderParameter(vsBad, gl.COMPILE_STATUS) == false,
+              "bad vertex shader should fail to compile");
+
+    var fs = gl.createShader(gl.FRAGMENT_SHADER);
+    gl.shaderSource(fs, "precision mediump float; varying vec4 vColor; void main() { gl_FragColor = vColor; }");
+    gl.compileShader(fs);
+
+    assertMsg(gl.getShaderParameter(fs, gl.COMPILE_STATUS) == true,
+              "good fragment shader should compile");
+
+    var fs2 = gl.createShader(gl.FRAGMENT_SHADER);
+    gl.shaderSource(fs2, "precision mediump float; varying vec4 vColor; void main() { gl_FragColor = vColor * 0.5; }");
+    gl.compileShader(fs2);
+
+    assertMsg(gl.getShaderParameter(fs2, gl.COMPILE_STATUS) == true,
+              "good fragment shader #2 should compile");
+
+    var fsBad = gl.createShader(gl.FRAGMENT_SHADER);
+    gl.shaderSource(fsBad, "WILL NOT COMPILE;");
+    gl.compileShader(fsBad);
+
+    assertMsg(gl.getShaderParameter(fsBad, gl.COMPILE_STATUS) == false,
+              "bad fragment shader should fail to compile");
+
+    glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors at this point");
+
+/////// Check attachShader() /////////////////////////////
+
+    function checkAttachShader(already_attached_shaders, shader, expected_error_code, errmsg) {
+        var prog = gl.createProgram();
+        for (var i = 0; i < already_attached_shaders.length; ++i)
+            gl.attachShader(prog, already_attached_shaders[i]);
+        if(gl.getError() != gl.NO_ERROR)
+            assertMsg(false, "unexpected error in attachShader()");
+        gl.attachShader(prog, shader);
+        glErrorShouldBe(gl, expected_error_code, errmsg);
+    }
+
+    checkAttachShader([], vs, gl.NO_ERROR, "attaching a vertex shader should succeed");
+    checkAttachShader([vs], vs, gl.INVALID_OPERATION,
+                      "attaching an already attached vertex shader should generate INVALID_OPERATION");
+    checkAttachShader([], fs, gl.NO_ERROR, "attaching a fragment shader should succeed");
+    checkAttachShader([fs], fs, gl.INVALID_OPERATION,
+                      "attaching an already attached fragment shader should generate INVALID_OPERATION");
+    checkAttachShader([vs], vs2, gl.INVALID_OPERATION,
+                      "attaching shaders of the same type to a program should generate INVALID_OPERATION");
+    checkAttachShader([fs], fs2, gl.INVALID_OPERATION,
+                      "attaching shaders of the same type to a program should generate INVALID_OPERATION");
+
+/////// Check detachShader() /////////////////////////////
+
+    function checkDetachShader(already_attached_shaders, shader, expected_error_code, errmsg) {
+        var prog = gl.createProgram();
+        for (var i = 0; i < already_attached_shaders.length; ++i)
+            gl.attachShader(prog, already_attached_shaders[i]);
+        if(gl.getError() != gl.NO_ERROR)
+            assertMsg(false, "unexpected error in attachShader()");
+        gl.detachShader(prog, shader);
+        glErrorShouldBe(gl, expected_error_code, errmsg);
+    }
+
+    checkDetachShader([vs], vs, gl.NO_ERROR, "detaching a vertex shader should succeed");
+    checkDetachShader([fs], vs, gl.INVALID_OPERATION,
+                      "detaching a not already attached vertex shader should generate INVALID_OPERATION");
+    checkDetachShader([fs], fs, gl.NO_ERROR, "detaching a fragment shader should succeed");
+    checkDetachShader([vs], fs, gl.INVALID_OPERATION,
+                      "detaching a not already attached fragment shader should generate INVALID_OPERATION");
+
+/////// Check getAttachedShaders() /////////////////////////////
+
+    function checkGetAttachedShaders(shaders_to_attach, shaders_to_detach, expected_shaders, errmsg) {
+        var prog = gl.createProgram();
+        for (var i = 0; i < shaders_to_attach.length; ++i)
+            gl.attachShader(prog, shaders_to_attach[i]);
+        if(gl.getError() != gl.NO_ERROR)
+            assertMsg(false, "unexpected error in attachShader()");
+        for (var i = 0; i < shaders_to_detach.length; ++i)
+            gl.detachShader(prog, shaders_to_detach[i]);
+        if(gl.getError() != gl.NO_ERROR)
+            assertMsg(false, "unexpected error in detachShader()");
+        assertMsg(doArraysHaveSameContents(gl.getAttachedShaders(prog), expected_shaders), errmsg);
+    }
+    checkGetAttachedShaders([], [], [], "getAttachedShaders should return an empty list by default");
+    checkGetAttachedShaders([fs], [], [fs], "attaching a single shader should give the expected list");
+    checkGetAttachedShaders([fs, vs], [], [fs, vs],
+        "attaching some shaders should give the expected list");
+    checkGetAttachedShaders([fs], [fs], [], "attaching a shader and detaching it shoud leave an empty list");
+    checkGetAttachedShaders([fs, vs], [fs, vs], [],
+        "attaching some shaders and detaching them in same order shoud leave an empty list");
+    checkGetAttachedShaders([fs, vs], [vs, fs], [],
+        "attaching some shaders and detaching them in random order shoud leave an empty list");
+    checkGetAttachedShaders([fs, vs], [vs], [fs],
+        "attaching and detaching some shaders should leave the difference list");
+    checkGetAttachedShaders([fs, vs], [fs], [vs],
+        "attaching and detaching some shaders should leave the difference list");
+    checkGetAttachedShaders([fsBad], [], [fsBad],
+        "attaching a shader that failed to compile should still show it in the list");
+    checkGetAttachedShaders([fs, vsBad], [], [fs, vsBad],
+        "attaching shaders, including one that failed to compile, should still show the it in the list");
+
+/////// Check linkProgram() and useProgram /////////////////////////////
+
+    function checkLinkAndUse(shaders, deleteShaderAfterAttach, expected_status, errmsg) {
+        var prog = gl.createProgram();
+        for (var i = 0; i < shaders.length; ++i) {
+            gl.attachShader(prog, shaders[i]);
+            if (deleteShaderAfterAttach)
+                gl.deleteShader(shaders[i]);
+        }
+        gl.bindAttribLocation(prog, 0, "aVertex");
+        gl.bindAttribLocation(prog, 1, "aColor");
+        gl.linkProgram(prog);
+        if (gl.getError() != gl.NO_ERROR)
+            assertMsg(false, "unexpected error in linkProgram()");
+        assertMsg(gl.getProgramParameter(prog, gl.LINK_STATUS) == expected_status, errmsg);
+        if (expected_status == true && gl.getProgramParameter(prog, gl.LINK_STATUS) == false)
+            debug(gl.getProgramInfoLog(prog));
+        if (gl.getError() != gl.NO_ERROR)
+            assertMsg(false, "unexpected error in getProgramParameter()");
+        gl.useProgram(prog);
+        if (expected_status == true)
+            glErrorShouldBe(gl, gl.NO_ERROR, "using a valid program should succeed");
+        if (expected_status == false)
+            glErrorShouldBe(gl, gl.INVALID_OPERATION, "using an invalid program should generate INVALID_OPERATION");
+        return prog;
+    }
+
+    var progGood1 = checkLinkAndUse([vs, fs], false, true, "valid program should link");
+    var progGood2 = checkLinkAndUse([vs, fs2], false, true, "valid program #2 should link");
+    var progBad1 = checkLinkAndUse([vs], false, false, "program with no fragment shader should fail to link");
+    var progBad2 = checkLinkAndUse([fs], false, false, "program with no vertex shader should fail to link");
+    var progBad3 = checkLinkAndUse([vsBad, fs], false, false, "program with bad vertex shader should fail to link");
+    var progBad4 = checkLinkAndUse([vs, fsBad], false, false, "program with bad fragment shader should fail to link");
+    var progBad5 = checkLinkAndUse([vsBad, fsBad], false, false, "program with bad shaders should fail to link");
+
+    gl.useProgram(progGood1);
+    glErrorShouldBe(gl, gl.NO_ERROR, "using a valid program shouldn't generate a GL error");
+
+    var vbuf = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, vbuf);
+    gl.bufferData(gl.ARRAY_BUFFER,
+                  new Float32Array([
+                      0.0, 0.0, 0.0, 1.0,
+                      1.0, 0.0, 0.0, 1.0,
+                      1.0, 1.0, 0.0, 1.0,
+                      0.0, 1.0, 0.0, 1.0]),
+                  gl.STATIC_DRAW);
+    gl.vertexAttribPointer(0, 4, gl.FLOAT, false, 0, 0);
+    gl.enableVertexAttribArray(0);
+    gl.vertexAttrib3f(1, 1.0, 0.0, 0.0);
+
+    glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors at this point #2");
+
+    gl.useProgram(progGood1);
+    gl.drawArrays(gl.TRIANGLES, 0, 3);
+    glErrorShouldBe(gl, gl.NO_ERROR, "drawing with a valid program shouldn't generate a GL error");
+
+    gl.useProgram(progBad1);
+    glErrorShouldBe(gl, gl.INVALID_OPERATION, "using an invalid program should generate INVALID_OPERATION");
+    gl.drawArrays(gl.TRIANGLES, 0, 3);
+    glErrorShouldBe(gl, gl.NO_ERROR, "Try to use an invalid program should not change the current rendering state");
+
+    gl.useProgram(progGood2);
+    gl.drawArrays(gl.TRIANGLES, 0, 3);
+    glErrorShouldBe(gl, gl.NO_ERROR, "drawing with a valid program shouldn't generate a GL error");
+    gl.detachShader(progGood2, fs2);
+    gl.attachShader(progGood2, fsBad);
+    gl.linkProgram(progGood2);
+    assertMsg(gl.getProgramParameter(progGood2, gl.LINK_STATUS) == false,
+              "linking should fail with in-use formerly good program, with new bad shader attached");
+
+    gl.useProgram(progGood1);
+    gl.drawArrays(gl.TRIANGLES, 0, 4);
+    glErrorShouldBe(gl, gl.NO_ERROR, "drawing with a valid when last used program shouldn't generate a GL error");
+
+    var progGood1 = checkLinkAndUse([vs, fs], true, true, "delete shaders after attaching them and before linking program should not affect linkProgram");
+    gl.useProgram(progGood1);
+    gl.drawArrays(gl.TRIANGLES, 0, 4);
+    glErrorShouldBe(gl, gl.NO_ERROR, "drawing with a valid when last used program shouldn't generate a GL error");
+
+/////// Check deleteProgram() and deleteShader() /////////////////////////////
+
+    gl.useProgram(progGood1);
+    gl.deleteProgram(progGood1);
+    gl.drawArrays(gl.TRIANGLES, 0, 4);
+    glErrorShouldBe(gl, gl.NO_ERROR, "delete the current program shouldn't change the current rendering state");
+
+    gl.linkProgram(progGood1);
+    glErrorShouldBe(gl, gl.NO_ERROR, "The current program shouldn't be deleted");
+
+    var fs3 = gl.createShader(gl.FRAGMENT_SHADER);
+    gl.shaderSource(fs3, "precision mediump float; varying vec4 vColor; void main() { gl_FragColor = vColor; }");
+    gl.compileShader(fs3);
+
+    assertMsg(gl.getShaderParameter(fs3, gl.COMPILE_STATUS) == true,
+              "good fragment shader should compile");
+
+    gl.deleteShader(fs3);
+    gl.compileShader(fs3);
+    glErrorShouldBe(gl, gl.INVALID_VALUE, "an unattached shader should be deleted immediately");
+
+    fs3 = gl.createShader(gl.FRAGMENT_SHADER);
+    gl.shaderSource(fs3, "precision mediump float; varying vec4 vColor; void main() { gl_FragColor = vColor; }");
+    gl.compileShader(fs3);
+
+    assertMsg(gl.getShaderParameter(fs3, gl.COMPILE_STATUS) == true,
+              "good fragment shader should compile");
+
+    gl.detachShader(progGood1, fs);
+    gl.attachShader(progGood1, fs3);
+
+    gl.deleteShader(fs3);
+    gl.compileShader(fs3);
+    assertMsg(gl.getShaderParameter(fs3, gl.COMPILE_STATUS) == true,
+              "an attached shader shouldn't be deleted");
+
+    gl.useProgram(null);
+    gl.linkProgram(progGood1);
+    glErrorShouldBe(gl, gl.INVALID_VALUE, "a delete-marked program should be deleted once it's no longer the current program");
+
+    gl.compileShader(fs3);
+    glErrorShouldBe(gl, gl.INVALID_VALUE, "a delete-marked shader should be deleted once all its attachments are removed");
+}
+
+debug("");
+go();
+
+successfullyParsed = true;
+</script>
+<script src="../../js/resources/js-test-post.js"></script>
+
+</body>
+</html>
diff --git a/Source/WebCore/bindings/v8/custom/V8WebGLRenderingContextCustom.cpp b/Source/WebCore/bindings/v8/custom/V8WebGLRenderingContextCustom.cpp
index a23b707..2441dfb 100644
--- a/Source/WebCore/bindings/v8/custom/V8WebGLRenderingContextCustom.cpp
+++ b/Source/WebCore/bindings/v8/custom/V8WebGLRenderingContextCustom.cpp
@@ -164,7 +164,7 @@ static v8::Handle<v8::Value> toV8Object(WebGLExtension* extension, v8::Handle<v8
     if (!extension)
         return v8::Null();
     v8::Handle<v8::Value> extensionObject;
-    const char* referenceName;
+    const char* referenceName = 0;
     switch (extension->getName()) {
     case WebGLExtension::WebKitLoseContextName:
         extensionObject = toV8(static_cast<WebKitLoseContext*>(extension));
diff --git a/Source/WebCore/html/canvas/WebGLObject.cpp b/Source/WebCore/html/canvas/WebGLObject.cpp
index d47013e..7b629a6 100644
--- a/Source/WebCore/html/canvas/WebGLObject.cpp
+++ b/Source/WebCore/html/canvas/WebGLObject.cpp
@@ -66,6 +66,16 @@ void WebGLObject::deleteObject()
     }
 }
 
+void WebGLObject::detachContext()
+{
+    m_attachmentCount = 0; // Make sure OpenGL resource is deleted.
+    if (m_context) {
+        deleteObject();
+        m_context->removeObject(this);
+        m_context = 0;
+    }
+}
+
 }
 
 #endif // ENABLE(WEBGL)
diff --git a/Source/WebCore/html/canvas/WebGLObject.h b/Source/WebCore/html/canvas/WebGLObject.h
index 3bb9f29..44cc36f 100644
--- a/Source/WebCore/html/canvas/WebGLObject.h
+++ b/Source/WebCore/html/canvas/WebGLObject.h
@@ -46,12 +46,7 @@ public:
     // FIXME: revisit this when resource sharing between contexts are implemented.
     void deleteObject();
 
-    void detachContext()
-    {
-        m_attachmentCount = 0; // Make sure OpenGL resource is deleted.
-        deleteObject();
-        m_context = 0;
-    }
+    void detachContext();
 
     WebGLRenderingContext* context() const { return m_context; }
 
diff --git a/Source/WebCore/html/canvas/WebGLRenderingContext.cpp b/Source/WebCore/html/canvas/WebGLRenderingContext.cpp
index 30a88fa..7e7bfe3 100644
--- a/Source/WebCore/html/canvas/WebGLRenderingContext.cpp
+++ b/Source/WebCore/html/canvas/WebGLRenderingContext.cpp
@@ -1929,23 +1929,15 @@ bool WebGLRenderingContext::getAttachedShaders(WebGLProgram* program, Vector<Web
     shaderObjects.clear();
     if (isContextLost() || !validateWebGLObject(program))
         return false;
-    GC3Dint numShaders = 0;
-    m_context->getProgramiv(objectOrZero(program), GraphicsContext3D::ATTACHED_SHADERS, &numShaders);
-    if (numShaders) {
-        OwnArrayPtr<Platform3DObject> shaders = adoptArrayPtr(new Platform3DObject[numShaders]);
-        GC3Dsizei count = 0;
-        m_context->getAttachedShaders(objectOrZero(program), numShaders, &count, shaders.get());
-        if (count != numShaders)
-            return false;
-        shaderObjects.resize(numShaders);
-        for (GC3Dint ii = 0; ii < numShaders; ++ii) {
-            WebGLShader* shader = findShader(shaders[ii]);
-            if (!shader) {
-                shaderObjects.clear();
-                return false;
-            }
-            shaderObjects[ii] = shader;
-        }
+
+    const GC3Denum shaderType[] = {
+        GraphicsContext3D::VERTEX_SHADER,
+        GraphicsContext3D::FRAGMENT_SHADER
+    };
+    for (unsigned i = 0; i < sizeof(shaderType) / sizeof(GC3Denum); ++i) {
+        WebGLShader* shader = program->getAttachedShader(shaderType[i]);
+        if (shader)
+            shaderObjects.append(shader);
     }
     return true;
 }
@@ -2047,16 +2039,6 @@ WebGLGetInfo WebGLRenderingContext::getFramebufferAttachmentParameter(GC3Denum t
     UNUSED_PARAM(ec);
     if (isContextLost() || !validateFramebufferFuncParameters(target, attachment))
         return WebGLGetInfo();
-    switch (pname) {
-    case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
-    case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
-    case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
-    case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
-        break;
-    default:
-        m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);
-        return WebGLGetInfo();
-    }
 
     if (!m_framebufferBinding || !m_framebufferBinding->object()) {
         m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);
@@ -4123,59 +4105,10 @@ void WebGLRenderingContext::addObject(WebGLObject* object)
 
 void WebGLRenderingContext::detachAndRemoveAllObjects()
 {
-    HashSet<RefPtr<WebGLObject> >::iterator pend = m_canvasObjects.end();
-    for (HashSet<RefPtr<WebGLObject> >::iterator it = m_canvasObjects.begin(); it != pend; ++it)
+    while (m_canvasObjects.size() > 0) {
+        HashSet<WebGLObject*>::iterator it = m_canvasObjects.begin();
         (*it)->detachContext();
-
-    m_canvasObjects.clear();
-}
-
-WebGLTexture* WebGLRenderingContext::findTexture(Platform3DObject obj)
-{
-    if (!obj)
-        return 0;
-    HashSet<RefPtr<WebGLObject> >::iterator pend = m_canvasObjects.end();
-    for (HashSet<RefPtr<WebGLObject> >::iterator it = m_canvasObjects.begin(); it != pend; ++it) {
-        if ((*it)->isTexture() && (*it)->object() == obj)
-            return reinterpret_cast<WebGLTexture*>((*it).get());
-    }
-    return 0;
-}
-
-WebGLRenderbuffer* WebGLRenderingContext::findRenderbuffer(Platform3DObject obj)
-{
-    if (!obj)
-        return 0;
-    HashSet<RefPtr<WebGLObject> >::iterator pend = m_canvasObjects.end();
-    for (HashSet<RefPtr<WebGLObject> >::iterator it = m_canvasObjects.begin(); it != pend; ++it) {
-        if ((*it)->isRenderbuffer() && (*it)->object() == obj)
-            return reinterpret_cast<WebGLRenderbuffer*>((*it).get());
-    }
-    return 0;
-}
-
-WebGLBuffer* WebGLRenderingContext::findBuffer(Platform3DObject obj)
-{
-    if (!obj)
-        return 0;
-    HashSet<RefPtr<WebGLObject> >::iterator pend = m_canvasObjects.end();
-    for (HashSet<RefPtr<WebGLObject> >::iterator it = m_canvasObjects.begin(); it != pend; ++it) {
-        if ((*it)->isBuffer() && (*it)->object() == obj)
-            return reinterpret_cast<WebGLBuffer*>((*it).get());
     }
-    return 0;
-}
-
-WebGLShader* WebGLRenderingContext::findShader(Platform3DObject obj)
-{
-    if (!obj)
-        return 0;
-    HashSet<RefPtr<WebGLObject> >::iterator pend = m_canvasObjects.end();
-    for (HashSet<RefPtr<WebGLObject> >::iterator it = m_canvasObjects.begin(); it != pend; ++it) {
-        if ((*it)->isShader() && (*it)->object() == obj)
-            return reinterpret_cast<WebGLShader*>((*it).get());
-    }
-    return 0;
 }
 
 WebGLGetInfo WebGLRenderingContext::getBooleanParameter(GC3Denum pname)
diff --git a/Source/WebCore/html/canvas/WebGLRenderingContext.h b/Source/WebCore/html/canvas/WebGLRenderingContext.h
index c4a167f..2a0a90d 100644
--- a/Source/WebCore/html/canvas/WebGLRenderingContext.h
+++ b/Source/WebCore/html/canvas/WebGLRenderingContext.h
@@ -329,10 +329,6 @@ public:
 
     void addObject(WebGLObject*);
     void detachAndRemoveAllObjects();
-    WebGLTexture* findTexture(Platform3DObject);
-    WebGLRenderbuffer* findRenderbuffer(Platform3DObject);
-    WebGLBuffer* findBuffer(Platform3DObject);
-    WebGLShader* findShader(Platform3DObject);
 
     void markContextChanged();
     void cleanupAfterGraphicsCall(bool changed)
@@ -388,7 +384,7 @@ public:
 
     bool m_needsUpdate;
     bool m_markedCanvasDirty;
-    HashSet<RefPtr<WebGLObject> > m_canvasObjects;
+    HashSet<WebGLObject*> m_canvasObjects;
 
     // List of bound VBO's. Used to maintain info about sizes for ARRAY_BUFFER and stored values for ELEMENT_ARRAY_BUFFER
     RefPtr<WebGLBuffer> m_boundArrayBuffer;
-- 
cgit v1.1