From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Sun, 7 Apr 2024 21:33:14 +0200
Subject: Adding upstream version 115.7.0esr.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 .../checkout/conformance/uniforms/00_test_list.txt |  31 +
 .../gl-get-uniform-non-current-program.html        |  79 +++
 .../conformance/uniforms/gl-uniform-arrays.html    | 738 +++++++++++++++++++++
 .../conformance/uniforms/gl-uniform-bool.html      |  59 ++
 .../uniforms/gl-uniform-struct-unused.html         |  83 +++
 ...niform-unused-array-elements-get-truncated.html | 114 ++++
 .../conformance/uniforms/gl-uniformmatrix4fv.html  | 149 +++++
 .../conformance/uniforms/gl-unknown-uniform.html   |  67 ++
 .../no-over-optimization-on-uniform-array-00.html  |  39 ++
 .../no-over-optimization-on-uniform-array-01.html  |  39 ++
 .../no-over-optimization-on-uniform-array-02.html  |  39 ++
 .../no-over-optimization-on-uniform-array-03.html  |  39 ++
 .../no-over-optimization-on-uniform-array-04.html  |  39 ++
 .../no-over-optimization-on-uniform-array-05.html  |  39 ++
 .../no-over-optimization-on-uniform-array-06.html  |  39 ++
 .../no-over-optimization-on-uniform-array-07.html  |  39 ++
 .../no-over-optimization-on-uniform-array-08.html  |  39 ++
 .../no-over-optimization-on-uniform-array-09.html  |  39 ++
 .../no-over-optimization-on-uniform-array-10.html  |  39 ++
 .../no-over-optimization-on-uniform-array-11.html  |  39 ++
 .../no-over-optimization-on-uniform-array-12.html  |  39 ++
 .../no-over-optimization-on-uniform-array-13.html  |  39 ++
 .../no-over-optimization-on-uniform-array-14.html  |  39 ++
 .../no-over-optimization-on-uniform-array-15.html  |  39 ++
 .../no-over-optimization-on-uniform-array-16.html  |  39 ++
 .../no-over-optimization-on-uniform-array-17.html  |  39 ++
 .../uniforms/null-uniform-location.html            |  81 +++
 .../out-of-bounds-uniform-array-access.html        | 168 +++++
 .../uniforms/uniform-default-values.html           | 339 ++++++++++
 .../conformance/uniforms/uniform-location.html     |  96 +++
 .../uniforms/uniform-samplers-test.html            | 111 ++++
 .../uniforms/uniform-values-per-program.html       | 179 +++++
 32 files changed, 2996 insertions(+)
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/00_test_list.txt
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-get-uniform-non-current-program.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniform-arrays.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniform-bool.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniform-struct-unused.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniform-unused-array-elements-get-truncated.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniformmatrix4fv.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-unknown-uniform.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-00.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-01.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-02.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-03.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-04.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-05.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-06.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-07.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-08.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-09.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-10.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-11.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-12.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-13.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-14.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-15.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-16.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-17.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/null-uniform-location.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/out-of-bounds-uniform-array-access.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/uniform-default-values.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/uniform-location.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/uniform-samplers-test.html
 create mode 100644 dom/canvas/test/webgl-conf/checkout/conformance/uniforms/uniform-values-per-program.html

(limited to 'dom/canvas/test/webgl-conf/checkout/conformance/uniforms')

diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/00_test_list.txt b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/00_test_list.txt
new file mode 100644
index 0000000000..2da0fc47a3
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/00_test_list.txt
@@ -0,0 +1,31 @@
+gl-uniform-arrays.html
+# This test is no longer valid with the new packing restrictions
+#--min-version 1.0.02 gl-uniform-unused-array-elements-get-truncated.html
+gl-uniform-bool.html
+--min-version 1.0.4 gl-get-uniform-non-current-program.html
+gl-uniformmatrix4fv.html
+gl-unknown-uniform.html
+no-over-optimization-on-uniform-array-00.html
+no-over-optimization-on-uniform-array-01.html
+no-over-optimization-on-uniform-array-02.html
+no-over-optimization-on-uniform-array-03.html
+no-over-optimization-on-uniform-array-04.html
+no-over-optimization-on-uniform-array-05.html
+no-over-optimization-on-uniform-array-06.html
+no-over-optimization-on-uniform-array-07.html
+no-over-optimization-on-uniform-array-08.html
+no-over-optimization-on-uniform-array-09.html
+no-over-optimization-on-uniform-array-10.html
+no-over-optimization-on-uniform-array-11.html
+no-over-optimization-on-uniform-array-12.html
+no-over-optimization-on-uniform-array-13.html
+no-over-optimization-on-uniform-array-14.html
+no-over-optimization-on-uniform-array-15.html
+no-over-optimization-on-uniform-array-16.html
+no-over-optimization-on-uniform-array-17.html
+null-uniform-location.html
+--min-version 1.0.2 out-of-bounds-uniform-array-access.html
+--min-version 1.0.2 uniform-default-values.html
+--min-version 1.0.3 uniform-values-per-program.html
+uniform-location.html
+uniform-samplers-test.html
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-get-uniform-non-current-program.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-get-uniform-non-current-program.html
new file mode 100644
index 0000000000..f6628748f0
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-get-uniform-non-current-program.html
@@ -0,0 +1,79 @@
+<!--
+Copyright (c) 2022 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL getUniform from non-current program</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+    <script id="vshader" type="x-shader/x-vertex">
+        attribute vec4 vPosition;
+        void main()
+        {
+            gl_Position = vPosition;
+        }
+    </script>
+
+    <script id="fshader" type="x-shader/x-fragment">
+        precision mediump float;
+        uniform float color;
+        void main()
+        {
+            gl_FragColor = vec4(color);
+        }
+    </script>
+<script>
+"use strict";
+description("This test ensures WebGL implementations handle getUniform when the program is not the current program");
+
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var program1 = wtu.setupProgram(gl, ["vshader", "fshader"], ["vPosition"]);
+var program2 = wtu.setupProgram(gl, ["vshader", "fshader"], ["vPosition"]);
+var loc = gl.getUniformLocation(program1, "color");
+
+debug("check we can call getUniform when the program is current")
+gl.useProgram(program1);
+shouldBe("gl.getUniform(program1, loc)", "0");
+debug("check we can call getUniform when a different program is current")
+gl.useProgram(program2);
+shouldBe("gl.getUniform(program1, loc)", "0");
+debug("check we can call getUniform when no program is current")
+gl.useProgram(null);
+shouldBe("gl.getUniform(program1, loc)", "0");
+
+debug("check we can call getUniform when the program is current")
+gl.useProgram(program1);
+gl.uniform1f(loc, 123)
+shouldBe("gl.getUniform(program1, loc)", "123");
+debug("check we can call getUniform when a different program is current")
+gl.useProgram(program2);
+shouldBe("gl.getUniform(program1, loc)", "123");
+debug("check we can call getUniform when no program is current")
+gl.useProgram(null);
+shouldBe("gl.getUniform(program1, loc)", "123");
+
+
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should no errors");
+
+debug("");
+var successfullyParsed = true;
+
+</script>
+<script src="../../js/js-test-post.js"></script>
+
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniform-arrays.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniform-arrays.html
new file mode 100644
index 0000000000..7ffde96d84
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniform-arrays.html
@@ -0,0 +1,738 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script id="vshader" type="x-shader/x-vertex">
+    attribute vec4 a_position;
+    void main()
+    {
+        gl_Position = a_position;
+    }
+</script>
+
+<script id="fshader" type="x-shader/x-fragment">
+    precision mediump float;
+    uniform $(type) color[3];
+    void main()
+    {
+        gl_FragColor = vec4(color[0]$(elem), color[1]$(elem), color[2]$(elem), 1);
+    }
+</script>
+<script id="vshader300" type="x-shader/x-vertex">
+    #version 300 es
+    in vec4 a_position;
+    void main()
+    {
+        gl_Position = a_position;
+    }
+</script>
+
+<script id="fshader300" type="x-shader/x-fragment">
+    #version 300 es
+    precision mediump float;
+    uniform $(type) color[3];
+    out vec4 o_FragColor;
+    void main()
+    {
+        o_FragColor = vec4(color[0]$(elem), color[1]$(elem), color[2]$(elem), 1);
+    }
+</script>
+<script>
+"use strict";
+description();
+debug("");
+// MaxInt32 is 2^32-1. We need +1 of that to test overflow conditions.
+var MaxInt32PlusOne = 4294967296;
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+
+const contextVersion = wtu.getDefault3DContextVersion();
+
+let [vElemId, fElemId] = ["vshader", "fshader"];
+if (contextVersion >= 2) {
+  [vElemId, fElemId] = ["vshader300", "fshader300"];
+}
+
+var vSrc = wtu.getScript(vElemId).trim();
+var fTemplate = wtu.getScript(fElemId).trim();
+
+const typeInfos = [
+  { type: 'float',
+    jsTypeOf: 'number',
+    setter: 'uniform1fv',
+    elem: '',
+    numSrcValues: 3,
+    invalidSet: function(loc) {
+      gl.uniform2fv(loc, [1, 2]);
+    },
+    srcValueAsString: function(index, srcValues) {
+      return srcValues[index].toString();
+    },
+    returnValueAsString: function(value) {
+      return value === null ? 'null' : value.toString();
+    },
+    checkType: function(value) {
+      return typeof value === 'number';
+    },
+    checkValue: function(typeInfo, index, value) {
+      return typeInfo.srcValues[index] == value;
+    },
+    srcValues: [16, 15, 14],
+    srcValuesLess: [],
+    srcValuesLessMultiple: [16],
+    srcValuesMoreMultiple: [16, 15, 14, 13],
+    srcValuesNonMultiple: null,
+  },
+  { type: 'vec2',
+    jsTypeOf: 'Float32Array',
+    setter: 'uniform2fv',
+    elem: '[1]',
+    numSrcValues: 3,
+    invalidSet: function(loc) {
+      gl.uniform1fv(loc, [2]);
+    },
+    illegalSet: function(loc) {
+      gl.uniform1fv(loc, 2);
+    },
+    srcValueAsString: function(index, srcValues) {
+      return "[" + srcValues[index * 2 + 0].toString() + ", " +
+                   srcValues[index * 2 + 1].toString() + "]";
+    },
+    returnValueAsString: function(value) {
+      return value === null ? 'null' : ("[" + value[0] + ", " + value[1] + "]");
+    },
+    checkType: function(value) {
+      return value &&
+             typeof value.length === 'number' &&
+             value.length == 2;
+    },
+    checkValue: function(typeInfo, index, value) {
+      return value !== null &&
+             typeInfo.srcValues[index * 2 + 0] == value[0] &&
+             typeInfo.srcValues[index * 2 + 1] == value[1];
+    },
+    srcValues: [16, 15, 14, 13, 12, 11],
+    srcValuesLess: [16],
+    srcValuesLessMultiple: [16, 15, 14, 13],
+    srcValuesMoreMultiple: [16, 15, 14, 13, 12, 11, 10, 9],
+    srcValuesNonMultiple: [16, 15, 14, 13, 12, 11, 10],
+  },
+  { type: 'vec3',
+    jsTypeOf: 'Float32Array',
+    setter: 'uniform3fv',
+    elem: '[2]',
+    numSrcValues: 3,
+    invalidSet: function(loc) {
+      gl.uniform1fv(loc, [2]);
+    },
+    illegalSet: function(loc) {
+      gl.uniform1fv(loc, 2);
+    },
+    srcValueAsString: function(index, srcValues) {
+      return "[" + srcValues[index * 3 + 0].toString() + ", " +
+                   srcValues[index * 3 + 1].toString() + ", " +
+                   srcValues[index * 3 + 2].toString() + "]";
+    },
+    returnValueAsString: function(value) {
+      return value === null ? 'null' :
+          ("[" + value[0] + ", " + value[1] + ", " + value[2] + "]");
+    },
+    checkType: function(value) {
+      return value &&
+             typeof value.length === 'number' &&
+             value.length == 3;
+    },
+    checkValue: function(typeInfo, index, value) {
+      return value !== null &&
+             typeInfo.srcValues[index * 3 + 0] == value[0] &&
+             typeInfo.srcValues[index * 3 + 1] == value[1] &&
+             typeInfo.srcValues[index * 3 + 2] == value[2];
+    },
+    srcValues: [16, 15, 14, 13, 12, 11, 10, 9, 8],
+    srcValuesLess: [16, 15],
+    srcValuesLessMultiple: [16, 15, 14, 13, 12, 11],
+    srcValuesMoreMultiple: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2],
+    srcValuesNonMultiple: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7],
+  },
+  { type: 'vec4',
+    jsTypeOf: 'Float32Array',
+    setter: 'uniform4fv',
+    elem: '[3]',
+    numSrcValues: 3,
+    invalidSet: function(loc) {
+      gl.uniform1fv(loc, [2]);
+    },
+    illegalSet: function(loc) {
+      gl.uniform1fv(loc, 2);
+    },
+    srcValueAsString: function(index, srcValues) {
+      return "[" + srcValues[index * 4 + 0].toString() + ", " +
+                   srcValues[index * 4 + 1].toString() + ", " +
+                   srcValues[index * 4 + 2].toString() + ", " +
+                   srcValues[index * 4 + 3].toString() + "]";
+    },
+    returnValueAsString: function(value) {
+      return value === null ? 'null' :
+          ("[" + value[0] + ", " + value[1] +
+           ", " + value[2] + ", " + value[3] + "]");
+    },
+    checkType: function(value) {
+      return value &&
+             typeof value.length === 'number' &&
+             value.length == 4;
+    },
+    checkValue: function(typeInfo, index, value) {
+      return value !== null &&
+             typeInfo.srcValues[index * 4 + 0] == value[0] &&
+             typeInfo.srcValues[index * 4 + 1] == value[1] &&
+             typeInfo.srcValues[index * 4 + 2] == value[2] &&
+             typeInfo.srcValues[index * 4 + 3] == value[3];
+    },
+    srcValues: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5],
+    srcValuesLess: [16, 15, 14],
+    srcValuesLessMultiple: [16, 15, 14, 13, 12, 11, 10, 9],
+    srcValuesMoreMultiple: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1],
+    srcValuesNonMultiple: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4],
+  }
+];
+
+if (contextVersion >= 2) {
+  const more = [
+    { type: 'int',
+      jsTypeOf: 'number',
+      setter: 'uniform1iv',
+      elem: '',
+      numSrcValues: 3,
+      invalidSet: function(loc) {
+        gl.uniform2iv(loc, [1, 2]);
+      },
+      srcValueAsString: function(index, srcValues) {
+        return srcValues[index].toString();
+      },
+      returnValueAsString: function(value) {
+        return value === null ? 'null' : value.toString();
+      },
+      checkType: function(value) {
+        return typeof value === 'number';
+      },
+      checkValue: function(typeInfo, index, value) {
+        return typeInfo.srcValues[index] == value;
+      },
+      srcValues: [16, 15, 14],
+      srcValuesLess: [],
+      srcValuesLessMultiple: [16],
+      srcValuesMoreMultiple: [16, 15, 14, 13],
+      srcValuesNonMultiple: null,
+    },
+    { type: 'ivec2',
+      jsTypeOf: 'Int32Array',
+      setter: 'uniform2iv',
+      elem: '[1]',
+      numSrcValues: 3,
+      invalidSet: function(loc) {
+        gl.uniform1iv(loc, [2]);
+      },
+      illegalSet: function(loc) {
+        gl.uniform1iv(loc, 2);
+      },
+      srcValueAsString: function(index, srcValues) {
+        return "[" + srcValues[index * 2 + 0].toString() + ", " +
+                     srcValues[index * 2 + 1].toString() + "]";
+      },
+      returnValueAsString: function(value) {
+        return value === null ? 'null' : ("[" + value[0] + ", " + value[1] + "]");
+      },
+      checkType: function(value) {
+        return value &&
+               typeof value.length === 'number' &&
+               value.length == 2;
+      },
+      checkValue: function(typeInfo, index, value) {
+        return value !== null &&
+               typeInfo.srcValues[index * 2 + 0] == value[0] &&
+               typeInfo.srcValues[index * 2 + 1] == value[1];
+      },
+      srcValues: [16, 15, 14, 13, 12, 11],
+      srcValuesLess: [16],
+      srcValuesLessMultiple: [16, 15, 14, 13],
+      srcValuesMoreMultiple: [16, 15, 14, 13, 12, 11, 10, 9],
+      srcValuesNonMultiple: [16, 15, 14, 13, 12, 11, 10],
+    },
+    { type: 'ivec3',
+      jsTypeOf: 'Int32Array',
+      setter: 'uniform3iv',
+      elem: '[2]',
+      numSrcValues: 3,
+      invalidSet: function(loc) {
+        gl.uniform1iv(loc, [2]);
+      },
+      illegalSet: function(loc) {
+        gl.uniform1iv(loc, 2);
+      },
+      srcValueAsString: function(index, srcValues) {
+        return "[" + srcValues[index * 3 + 0].toString() + ", " +
+                     srcValues[index * 3 + 1].toString() + ", " +
+                     srcValues[index * 3 + 2].toString() + "]";
+      },
+      returnValueAsString: function(value) {
+        return value === null ? 'null' :
+            ("[" + value[0] + ", " + value[1] + ", " + value[2] + "]");
+      },
+      checkType: function(value) {
+        return value &&
+               typeof value.length === 'number' &&
+               value.length == 3;
+      },
+      checkValue: function(typeInfo, index, value) {
+        return value !== null &&
+               typeInfo.srcValues[index * 3 + 0] == value[0] &&
+               typeInfo.srcValues[index * 3 + 1] == value[1] &&
+               typeInfo.srcValues[index * 3 + 2] == value[2];
+      },
+      srcValues: [16, 15, 14, 13, 12, 11, 10, 9, 8],
+      srcValuesLess: [16, 15],
+      srcValuesLessMultiple: [16, 15, 14, 13, 12, 11],
+      srcValuesMoreMultiple: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2],
+      srcValuesNonMultiple: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7],
+    },
+    { type: 'ivec4',
+      jsTypeOf: 'Int32Array',
+      setter: 'uniform4iv',
+      elem: '[3]',
+      numSrcValues: 3,
+      invalidSet: function(loc) {
+        gl.uniform1iv(loc, [2]);
+      },
+      illegalSet: function(loc) {
+        gl.uniform1iv(loc, 2);
+      },
+      srcValueAsString: function(index, srcValues) {
+        return "[" + srcValues[index * 4 + 0].toString() + ", " +
+                     srcValues[index * 4 + 1].toString() + ", " +
+                     srcValues[index * 4 + 2].toString() + ", " +
+                     srcValues[index * 4 + 3].toString() + "]";
+      },
+      returnValueAsString: function(value) {
+        return value === null ? 'null' :
+            ("[" + value[0] + ", " + value[1] +
+             ", " + value[2] + ", " + value[3] + "]");
+      },
+      checkType: function(value) {
+        return value &&
+               typeof value.length === 'number' &&
+               value.length == 4;
+      },
+      checkValue: function(typeInfo, index, value) {
+        return value !== null &&
+               typeInfo.srcValues[index * 4 + 0] == value[0] &&
+               typeInfo.srcValues[index * 4 + 1] == value[1] &&
+               typeInfo.srcValues[index * 4 + 2] == value[2] &&
+               typeInfo.srcValues[index * 4 + 3] == value[3];
+      },
+      srcValues: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5],
+      srcValuesLess: [16, 15, 14],
+      srcValuesLessMultiple: [16, 15, 14, 13, 12, 11, 10, 9],
+      srcValuesMoreMultiple: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1],
+      srcValuesNonMultiple: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4],
+    },
+
+
+    { type: 'uint',
+      jsTypeOf: 'number',
+      setter: 'uniform1uiv',
+      elem: '',
+      numSrcValues: 3,
+      invalidSet: function(loc) {
+        gl.uniform2uiv(loc, [1, 2]);
+      },
+      srcValueAsString: function(index, srcValues) {
+        return srcValues[index].toString();
+      },
+      returnValueAsString: function(value) {
+        return value === null ? 'null' : value.toString();
+      },
+      checkType: function(value) {
+        return typeof value === 'number';
+      },
+      checkValue: function(typeInfo, index, value) {
+        return typeInfo.srcValues[index] == value;
+      },
+      srcValues: [16, 15, 14],
+      srcValuesLess: [],
+      srcValuesLessMultiple: [16],
+      srcValuesMoreMultiple: [16, 15, 14, 13],
+      srcValuesNonMultiple: null,
+    },
+    { type: 'uvec2',
+      jsTypeOf: 'Uint32Array',
+      setter: 'uniform2uiv',
+      elem: '[1]',
+      numSrcValues: 3,
+      invalidSet: function(loc) {
+        gl.uniform1uiv(loc, [2]);
+      },
+      illegalSet: function(loc) {
+        gl.uniform1uiv(loc, 2);
+      },
+      srcValueAsString: function(index, srcValues) {
+        return "[" + srcValues[index * 2 + 0].toString() + ", " +
+                     srcValues[index * 2 + 1].toString() + "]";
+      },
+      returnValueAsString: function(value) {
+        return value === null ? 'null' : ("[" + value[0] + ", " + value[1] + "]");
+      },
+      checkType: function(value) {
+        return value &&
+               typeof value.length === 'number' &&
+               value.length == 2;
+      },
+      checkValue: function(typeInfo, index, value) {
+        return value !== null &&
+               typeInfo.srcValues[index * 2 + 0] == value[0] &&
+               typeInfo.srcValues[index * 2 + 1] == value[1];
+      },
+      srcValues: [16, 15, 14, 13, 12, 11],
+      srcValuesLess: [16],
+      srcValuesLessMultiple: [16, 15, 14, 13],
+      srcValuesMoreMultiple: [16, 15, 14, 13, 12, 11, 10, 9],
+      srcValuesNonMultiple: [16, 15, 14, 13, 12, 11, 10],
+    },
+    { type: 'uvec3',
+      jsTypeOf: 'Uint32Array',
+      setter: 'uniform3uiv',
+      elem: '[2]',
+      numSrcValues: 3,
+      invalidSet: function(loc) {
+        gl.uniform1uiv(loc, [2]);
+      },
+      illegalSet: function(loc) {
+        gl.uniform1uiv(loc, 2);
+      },
+      srcValueAsString: function(index, srcValues) {
+        return "[" + srcValues[index * 3 + 0].toString() + ", " +
+                     srcValues[index * 3 + 1].toString() + ", " +
+                     srcValues[index * 3 + 2].toString() + "]";
+      },
+      returnValueAsString: function(value) {
+        return value === null ? 'null' :
+            ("[" + value[0] + ", " + value[1] + ", " + value[2] + "]");
+      },
+      checkType: function(value) {
+        return value &&
+               typeof value.length === 'number' &&
+               value.length == 3;
+      },
+      checkValue: function(typeInfo, index, value) {
+        return value !== null &&
+               typeInfo.srcValues[index * 3 + 0] == value[0] &&
+               typeInfo.srcValues[index * 3 + 1] == value[1] &&
+               typeInfo.srcValues[index * 3 + 2] == value[2];
+      },
+      srcValues: [16, 15, 14, 13, 12, 11, 10, 9, 8],
+      srcValuesLess: [16, 15],
+      srcValuesLessMultiple: [16, 15, 14, 13, 12, 11],
+      srcValuesMoreMultiple: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2],
+      srcValuesNonMultiple: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7],
+    },
+    { type: 'uvec4',
+      jsTypeOf: 'Uint32Array',
+      setter: 'uniform4uiv',
+      elem: '[3]',
+      numSrcValues: 3,
+      invalidSet: function(loc) {
+        gl.uniform1uiv(loc, [2]);
+      },
+      illegalSet: function(loc) {
+        gl.uniform1uiv(loc, 2);
+      },
+      srcValueAsString: function(index, srcValues) {
+        return "[" + srcValues[index * 4 + 0].toString() + ", " +
+                     srcValues[index * 4 + 1].toString() + ", " +
+                     srcValues[index * 4 + 2].toString() + ", " +
+                     srcValues[index * 4 + 3].toString() + "]";
+      },
+      returnValueAsString: function(value) {
+        return value === null ? 'null' :
+            ("[" + value[0] + ", " + value[1] +
+             ", " + value[2] + ", " + value[3] + "]");
+      },
+      checkType: function(value) {
+        return value &&
+               typeof value.length === 'number' &&
+               value.length == 4;
+      },
+      checkValue: function(typeInfo, index, value) {
+        return value !== null &&
+               typeInfo.srcValues[index * 4 + 0] == value[0] &&
+               typeInfo.srcValues[index * 4 + 1] == value[1] &&
+               typeInfo.srcValues[index * 4 + 2] == value[2] &&
+               typeInfo.srcValues[index * 4 + 3] == value[3];
+      },
+      srcValues: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5],
+      srcValuesLess: [16, 15, 14],
+      srcValuesLessMultiple: [16, 15, 14, 13, 12, 11, 10, 9],
+      srcValuesMoreMultiple: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1],
+      srcValuesNonMultiple: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4],
+    },
+
+
+    { type: 'bool',
+      jsTypeOf: 'boolean',
+      setter: 'uniform1iv',
+      elem: '',
+      numSrcValues: 3,
+      invalidSet: function(loc) {
+        gl.uniform2iv(loc, [1, 2]);
+      },
+      srcValueAsString: function(index, srcValues) {
+        return srcValues[index].toString();
+      },
+      returnValueAsString: function(value) {
+        return value === null ? 'null' : value.toString();
+      },
+      checkType: function(value) {
+        return typeof value === 'boolean';
+      },
+      checkValue: function(typeInfo, index, value) {
+        return typeInfo.srcValues[index] == value;
+      },
+      srcValues: [true, true, true],
+      srcValuesLess: [],
+      srcValuesLessMultiple: [16],
+      srcValuesMoreMultiple: [16, 15, 14, 13],
+      srcValuesNonMultiple: null,
+    },
+    { type: 'bvec2',
+      jsTypeOf: 'Float32Array',
+      setter: 'uniform2fv',
+      elem: '[1]',
+      numSrcValues: 3,
+      invalidSet: function(loc) {
+        gl.uniform1iv(loc, [2]);
+      },
+      illegalSet: function(loc) {
+        gl.uniform1iv(loc, 2);
+      },
+      srcValueAsString: function(index, srcValues) {
+        return "[" + srcValues[index * 2 + 0].toString() + ", " +
+                     srcValues[index * 2 + 1].toString() + "]";
+      },
+      returnValueAsString: function(value) {
+        return value === null ? 'null' : ("[" + value[0] + ", " + value[1] + "]");
+      },
+      checkType: function(value) {
+        return value &&
+               typeof value.length === 'number' &&
+               value.length == 2;
+      },
+      checkValue: function(typeInfo, index, value) {
+        return value !== null &&
+               typeInfo.srcValues[index * 2 + 0] == value[0] &&
+               typeInfo.srcValues[index * 2 + 1] == value[1];
+      },
+      srcValues: [true, true, true, true, true, true],
+      srcValuesLess: [16],
+      srcValuesLessMultiple: [16, 15, 14, 13],
+      srcValuesMoreMultiple: [16, 15, 14, 13, 12, 11, 10, 9],
+      srcValuesNonMultiple: [16, 15, 14, 13, 12, 11, 10],
+    },
+    { type: 'bvec3',
+      jsTypeOf: 'Int32Array',
+      setter: 'uniform3iv',
+      elem: '[2]',
+      numSrcValues: 3,
+      invalidSet: function(loc) {
+        gl.uniform1iv(loc, [2]);
+      },
+      illegalSet: function(loc) {
+        gl.uniform1iv(loc, 2);
+      },
+      srcValueAsString: function(index, srcValues) {
+        return "[" + srcValues[index * 3 + 0].toString() + ", " +
+                     srcValues[index * 3 + 1].toString() + ", " +
+                     srcValues[index * 3 + 2].toString() + "]";
+      },
+      returnValueAsString: function(value) {
+        return value === null ? 'null' :
+            ("[" + value[0] + ", " + value[1] + ", " + value[2] + "]");
+      },
+      checkType: function(value) {
+        return value &&
+               typeof value.length === 'number' &&
+               value.length == 3;
+      },
+      checkValue: function(typeInfo, index, value) {
+        return value !== null &&
+               typeInfo.srcValues[index * 3 + 0] == value[0] &&
+               typeInfo.srcValues[index * 3 + 1] == value[1] &&
+               typeInfo.srcValues[index * 3 + 2] == value[2];
+      },
+      srcValues: [true, true, true, true, true, true, true, true, true],
+      srcValuesLess: [16, 15],
+      srcValuesLessMultiple: [16, 15, 14, 13, 12, 11],
+      srcValuesMoreMultiple: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2],
+      srcValuesNonMultiple: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7],
+    },
+    { type: 'bvec4',
+      jsTypeOf: 'Uint32Array',
+      setter: 'uniform4uiv',
+      elem: '[3]',
+      numSrcValues: 3,
+      invalidSet: function(loc) {
+        gl.uniform1iv(loc, [2]);
+      },
+      illegalSet: function(loc) {
+        gl.uniform1iv(loc, 2);
+      },
+      srcValueAsString: function(index, srcValues) {
+        return "[" + srcValues[index * 4 + 0].toString() + ", " +
+                     srcValues[index * 4 + 1].toString() + ", " +
+                     srcValues[index * 4 + 2].toString() + ", " +
+                     srcValues[index * 4 + 3].toString() + "]";
+      },
+      returnValueAsString: function(value) {
+        return value === null ? 'null' :
+            ("[" + value[0] + ", " + value[1] +
+             ", " + value[2] + ", " + value[3] + "]");
+      },
+      checkType: function(value) {
+        return value &&
+               typeof value.length === 'number' &&
+               value.length == 4;
+      },
+      checkValue: function(typeInfo, index, value) {
+        return value !== null &&
+               typeInfo.srcValues[index * 4 + 0] == value[0] &&
+               typeInfo.srcValues[index * 4 + 1] == value[1] &&
+               typeInfo.srcValues[index * 4 + 2] == value[2] &&
+               typeInfo.srcValues[index * 4 + 3] == value[3];
+      },
+      srcValues: [true, true, true, true, true, true, true, true, true, true, true, true],
+      srcValuesLess: [16, 15, 14],
+      srcValuesLessMultiple: [16, 15, 14, 13, 12, 11, 10, 9],
+      srcValuesMoreMultiple: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1],
+      srcValuesNonMultiple: [16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4],
+    }
+  ];
+  typeInfos.push(...more);
+}
+
+let loc;
+for (var tt = 0; tt < typeInfos.length; ++tt) {
+  var typeInfo = typeInfos[tt];
+  debug("");
+  debug("check " + typeInfo.type);
+  var fSrc = wtu.replaceParams(fTemplate, typeInfo);
+  //debug("fSrc: " + fSrc);
+  var program = wtu.loadProgram(gl, vSrc, fSrc);
+
+  var numUniforms = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
+  assertMsg(numUniforms == 1, "1 uniform found");
+  var info = gl.getActiveUniform(program, 0);
+  assertMsg(info.name == "color[0]",
+            "uniform name is 'color[0]' not 'color' as per OpenGL ES 2.0.24 section 2.10");
+  shouldBeNull("gl.getUniformLocation(program, 'color[" + MaxInt32PlusOne + "]');");
+  loc = gl.getUniformLocation(program, "color[0]");
+  if (!loc) throw 'Missing loc';
+  var srcValues = typeInfo.srcValues;
+  var srcValuesLess = typeInfo.srcValuesLess;
+  var srcValuesLessMultiple = typeInfo.srcValuesLessMultiple;
+  var srcValuesMoreMultiple = typeInfo.srcValuesMoreMultiple;
+  var srcValuesNonMultiple = typeInfo.srcValuesNonMultiple;
+
+  // Try setting the value before using the program
+  gl[typeInfo.setter](loc, srcValues);
+  wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION,
+                  "should fail if there is no current program");
+
+  gl.useProgram(program);
+  gl[typeInfo.setter](loc, srcValuesLess);
+  wtu.glErrorShouldBe(gl, gl.INVALID_VALUE,
+                  "should fail with insufficient array size with gl." + typeInfo.setter);
+  if (srcValuesNonMultiple) {
+    gl[typeInfo.setter](loc, srcValuesNonMultiple);
+    wtu.glErrorShouldBe(gl, gl.INVALID_VALUE,
+                    "should fail with non-multiple array size with gl." + typeInfo.setter);
+  }
+
+  const validDatas = [
+    `new Float32Array(${srcValues.length})`,
+    `new Float32Array(new ArrayBuffer(4*${srcValues.length}))`,
+  ];
+  if (window.SharedArrayBuffer) {
+    validDatas.push(
+      `new Float32Array(new SharedArrayBuffer(4*${srcValues.length}))`
+    );
+  }
+  for (const x of validDatas) {
+    shouldNotThrow(`gl.${typeInfo.setter}(loc, ${x});`);
+  }
+
+  gl[typeInfo.setter](loc, srcValues);
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR,
+                  "can set an array of uniforms with gl." + typeInfo.setter);
+  gl[typeInfo.setter](loc, srcValuesLessMultiple);
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR,
+                  "can partially set an array of uniforms with gl." + typeInfo.setter + " with a smaller array");
+  gl[typeInfo.setter](loc, srcValuesMoreMultiple);
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR,
+                  "can set an array of uniforms with gl." + typeInfo.setter + " with a larger array");
+
+  var values = gl.getUniform(program, loc);
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR,
+                  "can call gl.getUniform");
+  assertMsg(typeInfo.checkType(values),
+            "gl.getUniform returns the correct type. " + `(was ${values.constructor.name})`);
+  for (var ii = 0; ii < typeInfo.numSrcValues; ++ii) {
+    shouldBeNull("gl.getUniformLocation(program, 'color[" + (MaxInt32PlusOne + ii) + "]')");
+    var elemLoc = gl.getUniformLocation(program, "color[" + ii + "]");
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR,
+                    "can get location of element " + ii +
+                    " of array from gl.getUniformLocation");
+    var value = gl.getUniform(program, elemLoc);
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR,
+                    "can get value of element " + ii + " of array from gl.getUniform");
+    assertMsg(typeInfo.checkValue(typeInfo, ii, value),
+              "value put in (" + typeInfo.srcValueAsString(ii, srcValues) +
+              ") matches value pulled out (" +
+              typeInfo.returnValueAsString(value) + ")");
+  }
+  typeInfo.invalidSet(loc);
+  wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION,
+                  "using the wrong size of gl.Uniform fails");
+  var exceptionCaught = false;
+  if (typeInfo.illegalSet) {
+    try {
+      typeInfo.illegalSet(loc);
+    } catch (e) {
+      exceptionCaught = true;
+    }
+    assertMsg(exceptionCaught, "passing non-array to glUniform*fv should throw TypeError");
+  }
+
+  gl.useProgram(null);
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR,
+                  "can call gl.useProgram(null)");
+}
+
+var successfullyParsed = true;
+
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniform-bool.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniform-bool.html
new file mode 100644
index 0000000000..4f23cb4cf4
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniform-bool.html
@@ -0,0 +1,59 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniformMatrix Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+    <script id="vshader" type="x-shader/x-vertex">
+        attribute vec4 vPosition;
+        void main()
+        {
+            gl_Position = vPosition;
+        }
+    </script>
+
+    <script id="fshader" type="x-shader/x-fragment">
+        uniform bool color;
+        void main()
+        {
+            gl_FragColor = vec4(float(color),0.0,0.0,1.0);
+        }
+    </script>
+<script>
+"use strict";
+description("This test ensures WebGL implementations handle bool uniforms in a OpenGL ES 2.0 spec compliant way");
+
+debug("");
+debug("NOTE: Some OpenGL drivers do not handle this correctly");
+debug("");
+debug("Checking gl.uniform1f with bool.");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var program = wtu.setupProgram(gl, ["vshader", "fshader"], ["vPosition"]);
+var loc = gl.getUniformLocation(program, "color");
+gl.uniform1f(loc, 1);
+wtu.glErrorShouldBe(gl, gl.NO_ERROR,
+                "should be able to set bool with gl.uniform1f");
+
+debug("");
+var successfullyParsed = true;
+
+</script>
+<script src="../../js/js-test-post.js"></script>
+
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniform-struct-unused.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniform-struct-unused.html
new file mode 100644
index 0000000000..b755e59ee2
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniform-struct-unused.html
@@ -0,0 +1,83 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform struct Conformance Test</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+
+<script id="vshader" type="x-shader/x-vertex">
+attribute vec4 vPosition;
+uniform vec4 u0;
+struct MyStruct {
+  vec4 var1;
+  vec4 var2;
+  vec4 var3;
+  vec4 var4;
+};
+uniform MyStruct u1;
+uniform vec4 u2;
+varying vec4 v_color;
+void main()
+{
+  gl_Position = vPosition;
+  v_color = (u0 + u2 + u1.var1) - vec4(2.0);
+}
+</script>
+
+<script id="fshader" type="x-shader/x-fragment">
+precision mediump float;
+varying vec4 v_color;
+void main()
+{
+  gl_FragColor = v_color;
+}
+</script>
+
+<script>
+"use strict";
+description("This test ensures WebGL implementations handle unused members at the end of structs correctly.");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext();
+var c = document.getElementById("console");
+program = wtu.setupProgram(gl, ["vshader", "fshader"], [ "vPosition"]);
+
+wtu.setupUnitQuad(gl, [0, 1]);
+var white = [1.0, 1.0, 1.0, 1.0];
+var black = [0.0, 0.0, 0.0, 0.0];
+gl.uniform4fv(gl.getUniformLocation(program, "u0"), white);
+gl.uniform4fv(gl.getUniformLocation(program, "u1.var1"), white);
+gl.uniform4fv(gl.getUniformLocation(program, "u1.var2"), black);
+gl.uniform4fv(gl.getUniformLocation(program, "u1.var3"), black);
+gl.uniform4fv(gl.getUniformLocation(program, "u1.var4"), black);
+gl.uniform4fv(gl.getUniformLocation(program, "u2"), white);
+wtu.clearAndDrawUnitQuad(gl);
+wtu.checkCanvas(gl, [255, 255, 255, 255], "should be white", 0);
+gl.uniform4fv(gl.getUniformLocation(program, "u1.var2"), black);
+gl.uniform4fv(gl.getUniformLocation(program, "u1.var3"), black);
+gl.uniform4fv(gl.getUniformLocation(program, "u1.var4"), black);
+wtu.clearAndDrawUnitQuad(gl, [0, 0, 0, 0]);
+wtu.checkCanvas(gl, [255, 255, 255, 255], "should still be white", 0);
+
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no GL errors");
+debug("");
+var successfullyParsed = true;
+
+</script>
+<script src="../../js/js-test-post.js"></script>
+
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniform-unused-array-elements-get-truncated.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniform-unused-array-elements-get-truncated.html
new file mode 100644
index 0000000000..f8322cca01
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniform-unused-array-elements-get-truncated.html
@@ -0,0 +1,114 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform unused array elements get truncated Conformance Test</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script id="vshader" type="x-shader/x-vertex">
+    attribute vec4 a_position;
+    void main()
+    {
+        gl_Position = a_position;
+    }
+</script>
+<script id="fshader-max" type="x-shader/x-fragment">
+    precision mediump float;
+    uniform vec4 colora[$(numUniformVectors)];
+    void main()
+    {
+        gl_FragColor = vec4(colora[$(usedUniformVector)]);
+    }
+</script>
+<script>
+"use strict";
+description();
+debug("");
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var vSrc = wtu.getScript("vshader");
+var uniforms;
+// This test is to test drivers the have bugs related to optimizing
+// an array of uniforms when only 1 of those uniforms is used.
+debug("");
+var maxUniformVectors = gl.getParameter(gl.MAX_FRAGMENT_UNIFORM_VECTORS);
+var tests = [
+ { desc: "using 5th element",
+   maxUniformVectors: maxUniformVectors,
+   numUniformVectors: maxUniformVectors * 2,
+   usedUniformVector: 5,
+   shader: "fshader-max",
+   color: [0, 1, 0, 1],
+   arrayName: "colora",
+ },
+];
+
+// According to the spec unused array elements must be truncated.
+var requiredUniformLocationsExist;
+function testUniformIssues(testIndex) {
+  var test = tests[testIndex];
+  debug("");
+  debug(test.desc);
+  var fSrc = test.source;
+  if (!fSrc) {
+    fSrc = wtu.replaceParams(wtu.getScript(test.shader), test);
+  }
+
+  var consoleElem = document.getElementById("console");
+  wtu.addShaderSource(
+      consoleElem, "vertex shader", vSrc);
+  wtu.addShaderSource(
+      consoleElem, "fragment shader", fSrc);
+
+  var program = wtu.loadProgram(gl, vSrc, fSrc);
+  gl.useProgram(program);
+  uniforms = wtu.getUniformMap(gl, program);
+  shouldBe('uniforms["' + test.arrayName + '[0]"].size', (test.usedUniformVector + 1).toString());
+
+  requiredUniformLocationsExist = true;
+  for (var ii = 0; ii <= test.usedUniformVector + 1; ++ii) {
+    var name = test.arrayName + "[" + ii + "]";
+    var colorLocation = gl.getUniformLocation(program, name);
+    if (ii <= test.usedUniformVector) {
+      if (!colorLocation) {
+        requiredUniformLocationsExist = false
+      }
+    } else {
+      if (colorLocation) {
+        testFailed("uniform array was not truncated as specified in OpenGL ES 2.0.25 section 2.10.4");
+      }
+    }
+  }
+  shouldBeTrue("requiredUniformLocationsExist");
+}
+
+var testIndex = 0;
+function runNextTest() {
+  testUniformIssues(testIndex++);
+  if (testIndex < tests.length) {
+    setTimeout(runNextTest, 0);
+  } else {
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+    debug("");
+    finishTest();
+  }
+}
+runNextTest();
+
+var successfullyParsed = true;
+
+</script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniformmatrix4fv.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniformmatrix4fv.html
new file mode 100644
index 0000000000..eb4977a6fd
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-uniformmatrix4fv.html
@@ -0,0 +1,149 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniformMatrix Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+
+<script id="vshader" type="x-shader/x-vertex">
+uniform mat2 world2x2;
+uniform mat3 world3x3;
+uniform mat4 world4x4;
+void main() {
+  gl_Position.x += world2x2[0][0];
+  gl_Position.x += world3x3[0][0];
+  gl_Position.x += world4x4[0][0];
+}
+</script>
+
+<script id="fshader" type="x-shader/x-fragment">
+void main() {}
+</script>
+
+<script id="vshader300" type="x-shader/x-vertex">
+#version 300 es
+uniform mat2   world2x2;
+uniform mat2x3 world2x3;
+uniform mat2x4 world2x4;
+uniform mat3x2 world3x2;
+uniform mat3   world3x3;
+uniform mat3x4 world3x4;
+uniform mat4x2 world4x2;
+uniform mat4x3 world4x3;
+uniform mat4   world4x4;
+void main() {
+  gl_Position.x += world2x2[0][0];
+  gl_Position.x += world2x3[0][0];
+  gl_Position.x += world2x4[0][0];
+  gl_Position.x += world3x2[0][0];
+  gl_Position.x += world3x3[0][0];
+  gl_Position.x += world3x4[0][0];
+  gl_Position.x += world4x2[0][0];
+  gl_Position.x += world4x3[0][0];
+  gl_Position.x += world4x4[0][0];
+}
+</script>
+
+<script id="fshader300" type="x-shader/x-fragment">
+#version 300 es
+void main() {}
+</script>
+
+<script>
+"use strict";
+description("This test ensures WebGL implementations handle uniformMatrix in a OpenGL ES 2.0 spec compliant way");
+
+debug("");
+debug("Checking gl.uniformMatrix.");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var contextVersion = wtu.getDefault3DContextVersion();
+
+let shaders = ["vshader", "fshader"];
+const dims = [
+  [2, 2, 'uniformMatrix2fv'],
+  [3, 3, 'uniformMatrix3fv'],
+  [4, 4, 'uniformMatrix4fv'],
+];
+
+if (contextVersion >= 2) {
+  shaders = ["vshader300", "fshader300"];
+  dims.push(
+    [2, 3, 'uniformMatrix2x3fv'],
+    [2, 4, 'uniformMatrix2x4fv'],
+    [3, 2, 'uniformMatrix3x2fv'],
+    [3, 4, 'uniformMatrix3x4fv'],
+    [4, 2, 'uniformMatrix4x2fv'],
+    [4, 3, 'uniformMatrix4x3fv']
+  );
+}
+
+const program = wtu.setupProgram(gl, shaders);
+let loc;
+
+for (const [A, B, name] of dims) {
+  loc = gl.getUniformLocation(program, `world${A}x${B}`);
+  if (!loc) throw 'missing loc';
+
+  const mat = [];
+  for (let a = 0; a < A; ++a) {
+    for (let b = 0; b < B; ++b) {
+      mat.push((a == b) ? 1 : 0);
+    }
+  }
+  const matLess = mat.slice(0, mat.length-2);
+  const matMore = mat.concat([1]);
+
+  gl[name](loc, false, matLess);
+  wtu.glErrorShouldBe(gl, gl.INVALID_VALUE, "should fail with insufficient array size for " + name);
+  gl[name](loc, false, mat);
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should succeed with correct array size for " + name);
+  gl[name](loc, false, matMore);
+  wtu.glErrorShouldBe(gl, gl.INVALID_VALUE, "should fail with more than 1 array size for " + name);
+
+  const validDatas = [
+    `new Float32Array(${mat.length})`,
+    `new Float32Array(new ArrayBuffer(4*${mat.length}))`,
+  ];
+  if (window.SharedArrayBuffer) {
+    validDatas.push(
+      `new Float32Array(new SharedArrayBuffer(4*${mat.length}))`
+    );
+  }
+  for (const x of validDatas) {
+    shouldNotThrow(`gl.${name}(loc, false, ${x});`);
+  }
+
+  gl[name](loc, false, mat);
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR, "can call " + name + "with transpose = false");
+  if (contextVersion <= 1) {
+    gl[name](loc, true, mat);
+    wtu.glErrorShouldBe(gl, gl.INVALID_VALUE, name + " should return INVALID_VALUE with transpose = true");
+  } else {
+    gl[name](loc, true, mat);
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "can call " + name + "with transpose = true");
+  }
+}
+
+debug("");
+var successfullyParsed = true;
+
+</script>
+<script src="../../js/js-test-post.js"></script>
+
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-unknown-uniform.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-unknown-uniform.html
new file mode 100644
index 0000000000..825fd23831
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/gl-unknown-uniform.html
@@ -0,0 +1,67 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL Unknown Uniform Conformance Test</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="canvas" width="2" height="2"> </canvas>
+<script id="vshader" type="x-shader/x-vertex">
+attribute vec4 vPosition;
+void main()
+{
+    gl_Position = vPosition;
+}
+</script>
+
+<script id="fshader" type="x-shader/x-fragment">
+void main()
+{
+    gl_FragColor = vec4(1.0,0.0,0.0,1.0);
+}
+</script>
+<script>
+"use strict";
+description("Tests that unknown uniforms don't cause errors.");
+
+debug("");
+debug("Canvas.getContext");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("canvas");
+if (!gl) {
+  testFailed("context does not exist");
+} else {
+  testPassed("context exists");
+
+  debug("");
+
+  var program = wtu.setupProgram(gl, ["vshader", "fshader"], ["vPosition"]);
+  // Get the location of an unknown uniform.
+  var loc = gl.getUniformLocation(program, "someUnknownUniform");
+  assertMsg(loc === null, "location of unknown uniform should be null");
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR,
+      "there should be no error from getting an unknown uniform");
+  gl.uniform1f(loc, 1);
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR,
+      "there should be no error from trying to set an unknown uniform");
+}
+
+debug("");
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-00.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-00.html
new file mode 100644
index 0000000000..d331fa9299
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-00.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 0;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-01.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-01.html
new file mode 100644
index 0000000000..a60c1af473
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-01.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 1;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-02.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-02.html
new file mode 100644
index 0000000000..670d553802
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-02.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 2;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-03.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-03.html
new file mode 100644
index 0000000000..5702b78033
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-03.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 3;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-04.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-04.html
new file mode 100644
index 0000000000..b46e8915e1
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-04.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 4;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-05.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-05.html
new file mode 100644
index 0000000000..43caca6c9f
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-05.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 5;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-06.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-06.html
new file mode 100644
index 0000000000..e18b69ea5e
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-06.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 6;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-07.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-07.html
new file mode 100644
index 0000000000..365890dc90
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-07.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 7;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-08.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-08.html
new file mode 100644
index 0000000000..442cea6bed
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-08.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 8;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-09.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-09.html
new file mode 100644
index 0000000000..4543434e77
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-09.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 9;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-10.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-10.html
new file mode 100644
index 0000000000..dd4827f5f9
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-10.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 10;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-11.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-11.html
new file mode 100644
index 0000000000..93b34b906b
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-11.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 11;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-12.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-12.html
new file mode 100644
index 0000000000..e802600741
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-12.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 12;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-13.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-13.html
new file mode 100644
index 0000000000..0606ef5a28
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-13.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 13;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-14.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-14.html
new file mode 100644
index 0000000000..7e33adce4f
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-14.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 14;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-15.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-15.html
new file mode 100644
index 0000000000..46b50679b7
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-15.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 15;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-16.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-16.html
new file mode 100644
index 0000000000..881b76b560
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-16.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 16;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-17.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-17.html
new file mode 100644
index 0000000000..9dcb8ae9b8
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/no-over-optimization-on-uniform-array-17.html
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform array Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/no-over-optimizations-on-uniform-array.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script>
+"use strict";
+description();
+debug("");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext("example");
+var testIndex = 17;
+var testSet = NoOverOptimizeOnUniformArrayTester.setupTests(gl);
+var testCases = [testSet[testIndex]];
+
+NoOverOptimizeOnUniformArrayTester.runTests(gl, testCases)
+wtu.glErrorShouldBe(gl, gl.NO_ERROR, "there should be no errors");
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/null-uniform-location.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/null-uniform-location.html
new file mode 100644
index 0000000000..0c49bdb2f0
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/null-uniform-location.html
@@ -0,0 +1,81 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+
+<script>
+"use strict";
+description("Tests calling the various uniform[Matrix]* APIs with a null uniform location");
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext();
+var program = wtu.loadStandardProgram(gl);
+
+wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+shouldBeUndefined("gl.useProgram(program)");
+var floatArray = new Float32Array([1, 2, 3, 4]);
+var intArray = new Int32Array([1, 2, 3, 4]);
+
+function callUniformFunction(name) {
+  var isArrayVariant = (name.charAt(name.length - 1) == 'v');
+  var isMatrix = (name.indexOf("Matrix") != -1);
+  var isFloat =
+      (name.charAt(name.length - 1) == 'f' ||
+       name.charAt(name.length - 2) == 'f');
+  var sizeIndex = (isArrayVariant ? name.length - 3 : name.length - 2);
+  var size = parseInt(name.substring(sizeIndex, sizeIndex + 1));
+  // Initialize argument list with null uniform location
+  var args = [ null ];
+  if (isArrayVariant) {
+    // Call variant which takes values as array
+    if (isMatrix) {
+      size = size * size;
+      args.push(false);
+    }
+    var array = (isFloat ? new Float32Array(size) : new Int32Array(size));
+    for (var i = 0; i < size; i++) {
+      array[i] = i;
+    }
+    args.push(array);
+  } else {
+    // Call variant which takes values as parameters
+    for (var i = 0; i < size; i++) {
+      args.push(i);
+    }
+  }
+  var func = gl[name];
+  return func.apply(gl, args);
+}
+
+var funcs = [ "uniform1f", "uniform1fv", "uniform1i", "uniform1iv",
+              "uniform2f", "uniform2fv", "uniform2i", "uniform2iv",
+              "uniform3f", "uniform3fv", "uniform3i", "uniform3iv",
+              "uniform4f", "uniform4fv", "uniform4i", "uniform4iv",
+              "uniformMatrix2fv", "uniformMatrix3fv", "uniformMatrix4fv" ];
+var callString;
+
+for (var i = 0; i < funcs.length; i++) {
+  callString = "callUniformFunction('" + funcs[i] + "')";
+  shouldBeUndefined(callString);
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR);
+}
+
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/out-of-bounds-uniform-array-access.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/out-of-bounds-uniform-array-access.html
new file mode 100644
index 0000000000..1defc8ee0e
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/out-of-bounds-uniform-array-access.html
@@ -0,0 +1,168 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL out of bounds uniform array access.</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"> </script>
+</head>
+<body>
+<div id="description"></div>
+<canvas id="example" width="128" height="128" style="background: black;">
+</canvas>
+<div id="console"></div>
+<script id="vshader" type="x-shader/x-vertex">
+attribute vec4 vPosition;
+varying vec4 v_color;
+uniform float lineWidth;
+uniform int elemMult;
+uniform vec4 colorArray[6];
+void main()
+{
+    vec2 texcoord = vec2(vPosition.xy * 0.5 + vec2(0.5, 0.5));
+    int index = int(texcoord.x + texcoord.y * lineWidth) * elemMult;
+    v_color = colorArray[index];
+    gl_Position = vPosition;
+    gl_PointSize = 1.0;
+}
+</script>
+
+<script id="fshader" type="x-shader/x-fragment">
+precision mediump float;
+varying vec4 v_color;
+void main()
+{
+  gl_FragColor = v_color;
+}
+</script>
+<script>
+"use strict";
+debug("Tests a WebGL program that accesses out of bounds uniform array elements");
+
+var gl;
+var gridRes = 127;
+var lineWidthLoc;
+var elemMultLoc;
+var width = 128;
+var height = 128;
+var pixels = new Uint8Array(width * height * 4);
+
+var lineWidth = 0;
+var elemMult = 0;
+
+var knownColors = [
+  1.0, 0.0, 0.0, 1.0,  // Red
+  0.0, 1.0, 0.0, 1.0,  // Green
+  0.0, 0.0, 1.0, 1.0,  // Blue
+  0.0, 1.0, 1.0, 1.0,  // Cyan
+  1.0, 0.0, 1.0, 1.0,  // Magenta
+  1.0, 1.0, 0.0, 1.0   // Yellow
+];
+
+function main() {
+  var wtu = WebGLTestUtils;
+  gl = wtu.create3DContext("example");
+  var program = wtu.setupProgram(
+      gl,
+      ['vshader', 'fshader'],
+      ['vPosition'], [0]);
+
+  // setupQuad produces the geometry we want for a gridRes x gridRes grid
+  // of points. No interpolation will be performed across the points, so
+  // according to the WebGL specification for out-of-bounds array accesses,
+  // we will get exactly the input colors from the uniform colorArray, or
+  // zero, for each pixel on the canvas.
+  wtu.setupIndexedQuad(gl, gridRes, 0);
+  var colorArrayLoc = gl.getUniformLocation(program, "colorArray[0]");
+  assertMsg(colorArrayLoc != null, "color array uniform should be found");
+  var colors = new Float32Array(knownColors);
+  gl.uniform4fv(colorArrayLoc, colors);
+  lineWidthLoc = gl.getUniformLocation(program, "lineWidth");
+  elemMultLoc = gl.getUniformLocation(program, "elemMult");
+  assertMsg(gl.getError() == gl.NO_ERROR, "Should be no errors from setup.");
+  runOneIteration();
+}
+
+function withinEpsilon(val1, val2) {
+  return Math.abs(val1 - val2) < 0.0001;
+}
+
+function isKnownColor(r, g, b) {
+  if (r == 0 && g == 0 && b == 0)
+    return true;
+  for (var ii = 0; ii < knownColors.length; ii += 4) {
+    if (withinEpsilon(r / 255.0, knownColors[ii + 0]) &&
+        withinEpsilon(g / 255.0, knownColors[ii + 1]) &&
+        withinEpsilon(b / 255.0, knownColors[ii + 2]))
+      return true;
+  }
+  return false;
+}
+
+function runOneIteration() {
+  if (elemMult < 2048) {
+    var ok = true;
+    var startingLineWidth = lineWidth;
+    var firstFailingPixel = null;
+    var firstFailingValue = null;
+    for (; lineWidth < 2540; lineWidth += 31) {
+      // Draw
+      gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+      gl.uniform1f(lineWidthLoc, lineWidth);
+      gl.uniform1i(elemMultLoc, elemMult);
+      gl.drawArrays(gl.POINTS, 0, gridRes * gridRes);
+
+      // Read back
+      gl.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+
+      // Verify
+      for (var y = 0; y < height; ++y) {
+        for (var x = 0; x < width; ++x) {
+          if (!isKnownColor(pixels[4 * (width * y + x) + 0],
+                            pixels[4 * (width * y + x) + 1],
+                            pixels[4 * (width * y + x) + 2])) {
+            ok = false;
+            if (firstFailingPixel == null) {
+              firstFailingPixel = [x, y];
+              firstFailingValue = [pixels[4 * (width * y + x) + 0],
+                                   pixels[4 * (width * y + x) + 1],
+                                   pixels[4 * (width * y + x) + 2]];
+            }
+          }
+        }
+      }
+    }
+    var endingLineWidth = lineWidth - 31;
+    lineWidth -= 2540;
+    if (ok) {
+      testPassed("Good rendering results for lineWidths " +
+                 startingLineWidth + "..." + endingLineWidth +
+                 " at elemMult=" + elemMult);
+    } else {
+      testFailed("for lineWidth=" + lineWidth + ", elemMult=" + elemMult +
+                 ": first failing pixel (" + firstFailingPixel[0] + ", " + firstFailingPixel[1] + ") was (" +
+                 firstFailingValue[0] + ", " +
+                 firstFailingValue[1] + ", " +
+                 firstFailingValue[2] + "), should be (0, 0, 0) or one of known colors");
+    }
+    elemMult += 73;
+    setTimeout(runOneIteration, 0);
+  } else {
+    finishTest();
+  }
+}
+
+main();
+
+var successfullyParsed = true;
+
+</script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/uniform-default-values.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/uniform-default-values.html
new file mode 100644
index 0000000000..862182c272
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/uniform-default-values.html
@@ -0,0 +1,339 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform default values</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/test-eval.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+<canvas id="example" width="2" height="2"> </canvas>
+<script id="vshader0" type="x-shader/x-vertex">
+attribute vec4 vPosition;
+void main()
+{
+    gl_Position = vPosition;
+}
+</script>
+<script id="fshader0" type="x-shader/x-fragment">
+precision mediump float;
+uniform $(type) u_uniform;
+
+bool isZero($(type) value) {
+ $(check);
+}
+
+void main()
+{
+  gl_FragColor = isZero(u_uniform) ? vec4(0,1,0,1) : vec4(1,0,0,1);
+}
+</script>
+<script id="vshader1" type="x-shader/x-vertex">
+attribute vec4 vPosition;
+varying vec4 v_color;
+uniform $(type) u_uniform;
+
+bool isZero($(type) value) {
+   $(check);
+}
+
+void main()
+{
+    gl_Position = vPosition;
+    v_color = isZero(u_uniform) ? vec4(0,1,0,1) : vec4(1,0,0,1);
+}
+</script>
+<script id="fshader1" type="x-shader/x-fragment">
+precision mediump float;
+varying vec4 v_color;
+void main()
+{
+    gl_FragColor = v_color;
+}
+</script>
+<script id="vshader2" type="x-shader/x-vertex">
+attribute vec4 vPosition;
+void main()
+{
+    gl_Position = vPosition;
+}
+</script>
+<script id="fshader2" type="x-shader/x-fragment">
+precision mediump float;
+uniform $(type) u_uniform[2];
+
+bool isZero($(type) value) {
+  $(check);
+}
+
+void main()
+{
+  gl_FragColor = isZero(u_uniform[1]) ? vec4(0,1,0,1) : vec4(1,0,0,1);
+}
+</script>
+<script id="vshader3" type="x-shader/x-vertex">
+attribute vec4 vPosition;
+varying vec4 v_color;
+uniform $(type) u_uniform[2];
+
+bool isZero($(type) value) {
+   $(check);
+}
+
+void main()
+{
+    gl_Position = vPosition;
+    v_color = isZero(u_uniform[1]) ? vec4(0,1,0,1) : vec4(1,0,0,1);
+}
+</script>
+<script id="fshader3" type="x-shader/x-fragment">
+precision mediump float;
+varying vec4 v_color;
+void main()
+{
+    gl_FragColor = v_color;
+}
+</script>
+<script>
+"use strict";
+description();
+
+var tests = [
+{ type: 'float',
+  check: "return value == 0.0",
+  setFn: function(gl, loc) { gl.uniform1f(loc, 3.0); }
+},
+{ type: 'int',
+  check: "return value == 0",
+  setFn: function(gl, loc) { gl.uniform1i(loc, 3.0); }
+},
+{ type: 'bool',
+  check: "return value == false",
+  setFn: function(gl, loc) { gl.uniform1i(loc, 1); }
+},
+{ type: 'vec2',
+  check: "return value[0] == 0.0 && value[1] == 0.0",
+  setFn: function(gl, loc) { gl.uniform2f(loc, 3.0, 3.0); }
+},
+{ type: 'vec3',
+  check: "return value[0] == 0.0 && value[1] == 0.0 && value[2] == 0.0",
+  setFn: function(gl, loc) { gl.uniform3f(loc, 3.0, 3.0, 3.0); }
+},
+{ type: 'vec4',
+  check: "return value[0] == 0.0 && value[1] == 0.0 && value[2] == 0.0 && value[3] == 0.0",
+  setFn: function(gl, loc) { gl.uniform4f(loc, 3.0, 3.0, 3.0, 3.0); }
+},
+{ type: 'ivec2',
+  check: "return value[0] == 0 && value[1] == 0",
+  setFn: function(gl, loc) { gl.uniform2i(loc, 3, 3); }
+},
+{ type: 'ivec3',
+  check: "return value[0] == 0 && value[1] == 0 && value[2] == 0",
+  setFn: function(gl, loc) { gl.uniform3i(loc, 3, 3, 3); }
+},
+{ type: 'ivec4',
+  check: "return value[0] == 0 && value[1] == 0 && value[2] == 0 && value[3] == 0",
+  setFn: function(gl, loc) { gl.uniform4i(loc, 3, 3, 3, 3); }
+},
+{ type: 'bvec2',
+  check: "return value[0] == false && value[1] == false",
+  setFn: function(gl, loc) { gl.uniform2i(loc, 1, 1); }
+},
+{ type: 'bvec3',
+  check: "return value[0] == false && value[1] == false && value[2] == false",
+  setFn: function(gl, loc) { gl.uniform3i(loc, 1, 1, 1); }
+},
+{ type: 'bvec4',
+  check: "return value[0] == false && value[1] == false && value[2] == false && value[3] == false",
+  setFn: function(gl, loc) { gl.uniform4i(loc, 1, 1, 1, 1); }
+},
+{ type: 'mat2',
+  check:
+    "return " +
+    "value[0][0] == 0.0 && value[0][1] == 0.0 && " +
+    "value[1][0] == 0.0 && value[1][0] == 0.0",
+  valueCheck:
+    "return " +
+    "value[0] == 0.0 && value[1] == 0.0 && " +
+    "value[2] == 0.0 && value[3] == 0.0",
+  setFn: function(gl, loc) { gl.uniformMatrix2fv(loc, false, [1, 1, 1, 1]); }
+},
+{ type: 'mat3',
+  check:
+    "return " +
+    "value[0][0] == 0.0 && value[1][0] == 0.0 && value[2][0] == 0.0 && " +
+    "value[0][1] == 0.0 && value[1][1] == 0.0 && value[2][1] == 0.0 && " +
+    "value[0][2] == 0.0 && value[1][2] == 0.0 && value[2][2] == 0.0",
+  valueCheck:
+    "return " +
+    "value[0] == 0.0 && value[1] == 0.0 && value[2] == 0.0 && " +
+    "value[3] == 0.0 && value[4] == 0.0 && value[5] == 0.0 && " +
+    "value[6] == 0.0 && value[7] == 0.0 && value[8] == 0.0",
+  setFn: function(gl, loc) { gl.uniformMatrix3fv(loc, false, [1, 1, 1, 1, 1, 1, 1, 1, 1]); }
+},
+{ type: 'mat4',
+  check:
+    "return " +
+    "value[0][0] == 0.0 && value[1][0] == 0.0 && value[2][0] == 0.0 && value[3][0] == 0.0 && " +
+    "value[0][1] == 0.0 && value[1][1] == 0.0 && value[2][1] == 0.0 && value[3][1] == 0.0 && " +
+    "value[0][2] == 0.0 && value[1][2] == 0.0 && value[2][2] == 0.0 && value[3][2] == 0.0 && " +
+    "value[0][3] == 0.0 && value[1][3] == 0.0 && value[2][3] == 0.0 && value[3][3] == 0.0",
+  valueCheck:
+    "return " +
+    "value[ 0] == 0.0 && value[ 1] == 0.0 && value[ 2] == 0.0 && value[ 3] == 0.0 && " +
+    "value[ 4] == 0.0 && value[ 5] == 0.0 && value[ 6] == 0.0 && value[ 7] == 0.0 && " +
+    "value[ 8] == 0.0 && value[ 9] == 0.0 && value[10] == 0.0 && value[11] == 0.0 && " +
+    "value[12] == 0.0 && value[13] == 0.0 && value[14] == 0.0 && value[15] == 0.0",
+  setFn: function(gl, loc) { gl.uniformMatrix4fv(loc, false, [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]); }
+},
+{ type: 'sampler2D',
+  check:
+    "vec4 v = texture2D(value, vec2(0, 0));" +
+    "return v.x == 1.0 && v.y == 1.0 && v.z == 1.0 && v.w == 1.0",
+  valueCheck:
+    "return value == 0",
+  setFn: function(gl, loc) { gl.uniform1i(loc, 1); }
+},
+{ type: 'samplerCube',
+  check:
+    "vec4 v = textureCube(value, vec3(0, 0, 0));" +
+    "return v.x == 1.0 && v.y == 1.0 && v.z == 1.0 && v.w == 1.0",
+  valueCheck:
+    "return value == 0",
+  setFn: function(gl, loc) { gl.uniform1i(loc, 1); }
+},
+];
+
+var wtu = WebGLTestUtils;
+var gl = wtu.create3DContext();
+var c = document.getElementById("console");
+var checkFn;
+
+wtu.setupUnitQuad(gl, [0, 1]);
+
+// Set unit 0 to a non-0 texture.
+var haveVertexTextureImageUnits =
+    gl.getParameter(gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS) >= 2;
+var tex2D = gl.createTexture();
+var texCube = gl.createTexture();
+gl.bindTexture(gl.TEXTURE_2D, tex2D);
+gl.bindTexture(gl.TEXTURE_CUBE_MAP, texCube);
+
+var pixel = new Uint8Array([255, 255, 255, 255]);
+var targets = [
+  gl.TEXTURE_2D,
+  gl.TEXTURE_CUBE_MAP_POSITIVE_X,
+  gl.TEXTURE_CUBE_MAP_NEGATIVE_X,
+  gl.TEXTURE_CUBE_MAP_POSITIVE_Y,
+  gl.TEXTURE_CUBE_MAP_NEGATIVE_Y,
+  gl.TEXTURE_CUBE_MAP_POSITIVE_Z,
+  gl.TEXTURE_CUBE_MAP_NEGATIVE_Z
+];
+for (var ii = 0; ii < targets.length; ++ii) {
+    gl.texImage2D(
+        targets[ii], 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, pixel);
+}
+
+var shaderTemplates = [
+{ vs: "vshader0", fs: "fshader0", type: 'f' },
+{ vs: "vshader1", fs: "fshader1", type: 'v' },
+{ vs: "vshader2", fs: "fshader2", type: 'f' },
+{ vs: "vshader3", fs: "fshader3", type: 'v' },
+];
+
+// Get shader templates
+for (var ii = 0; ii < shaderTemplates.length; ++ii) {
+  var template = shaderTemplates[ii];
+  template.vs = wtu.getScript(template.vs);
+  template.fs = wtu.getScript(template.fs);
+}
+
+function testType(test) {
+  debug("");
+  debug("testing: " + test.type);
+
+  for (var ii = 0; ii < shaderTemplates.length; ++ii) {
+    var template = shaderTemplates[ii];
+
+    if (test.type.substring(0, 7) == "sampler" &&
+        template.type == 'v' &&
+        !haveVertexTextureImageUnits) {
+      continue;
+    }
+
+    var vs = wtu.replaceParams(template.vs, test);
+    var fs = wtu.replaceParams(template.fs, test);
+
+    wtu.addShaderSource(c, "vertex shader", vs);
+    wtu.addShaderSource(c, "fragment shader", fs);
+
+    var vs = wtu.loadShader(gl, vs, gl.VERTEX_SHADER);
+    var fs = wtu.loadShader(gl, fs, gl.FRAGMENT_SHADER);
+    var program = wtu.createProgram(gl, vs, fs);
+
+    gl.useProgram(program);
+
+    var loc = gl.getUniformLocation(program, "u_uniform[1]");
+    if (!loc) {
+        var loc = gl.getUniformLocation(program, "u_uniform");
+    }
+
+    var value = gl.getUniform(program, loc);
+    TestEval("checkFn = function(value) {" + (test.valueCheck ? test.valueCheck : test.check) + ";}");
+    if (checkFn(value)) {
+        testPassed("uniform is zero");
+    } else {
+        testFailed("uniform is not zero");
+    }
+
+    debug("default value should be zero");
+    wtu.clearAndDrawUnitQuad(gl);
+    wtu.checkCanvas(gl, [0, 255, 0, 255], "should be green", 0);
+
+    debug("test test by setting value");
+    test.setFn(gl, loc);
+
+    wtu.clearAndDrawUnitQuad(gl);
+    wtu.checkCanvas(gl, [255, 0, 0, 255], "should be red", 0);
+
+    debug("re-linking should reset to defaults");
+    gl.linkProgram(program);
+
+    wtu.clearAndDrawUnitQuad(gl);
+    wtu.checkCanvas(gl, [0, 255, 0, 255], "should be green", 0);
+
+    gl.deleteProgram(program);
+    gl.deleteShader(vs);
+    gl.deleteShader(fs);
+
+    wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no GL errors");
+  }
+}
+
+var testNdx = 0;
+function runNextTest() {
+    testType(tests[testNdx++]);
+    if (testNdx >= tests.length) {
+        finishTest();
+    } else {
+        setTimeout(runNextTest, 0);
+    }
+}
+
+runNextTest();
+
+var successfullyParsed = true;
+
+</script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/uniform-location.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/uniform-location.html
new file mode 100644
index 0000000000..3b1c185caf
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/uniform-location.html
@@ -0,0 +1,96 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<div id="console"></div>
+
+<script>
+"use strict";
+description("Tests the WebGLUniformLocation API");
+
+var wtu = WebGLTestUtils;
+var contextA = wtu.create3DContext();
+var contextB = wtu.create3DContext();
+var programA1 = wtu.loadStandardProgram(contextA);
+var programA2 = wtu.loadStandardProgram(contextA);
+var programB = wtu.loadStandardProgram(contextB);
+var programS = wtu.loadProgramFromFile(contextA, "../../resources/structUniformShader.vert", "../../resources/fragmentShader.frag");
+var programV = wtu.loadProgramFromFile(contextA, "../../resources/floatUniformShader.vert", "../../resources/noopUniformShader.frag");
+var locationA = contextA.getUniformLocation(programA1, 'u_modelViewProjMatrix');
+var locationB = contextB.getUniformLocation(programB, 'u_modelViewProjMatrix');
+var locationSx = contextA.getUniformLocation(programS, "u_struct.x");
+var locationSx2;
+var locationArray0 = contextA.getUniformLocation(programS, "u_array[0]");
+var locationArray1 = contextA.getUniformLocation(programS, "u_array[1]");
+var locationVec4 = contextA.getUniformLocation(programV, "fval4");
+
+var vec = [1, 2, 3, 4];
+var mat = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
+
+wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.useProgram(programA2)");
+wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix4fv(locationA, false, mat)");
+wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.useProgram(programA1)");
+wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.uniformMatrix4fv(locationA, false, mat)");
+wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.uniformMatrix4fv(null, false, mat)");
+
+wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.useProgram(programS)");
+wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.uniform1i(locationSx, 333)");
+wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.uniform1f(locationArray0, 4.0)");
+wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.uniform1f(locationArray1, 5.0)");
+
+shouldBe("contextA.getUniform(programS, locationSx)", "333");
+shouldBe("contextA.getUniform(programS, locationArray0)", "4.0");
+shouldBe("contextA.getUniform(programS, locationArray1)", "5.0");
+
+wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.useProgram(programV)");
+wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.uniform4fv(locationVec4, vec)");
+shouldBe("contextA.getUniform(programV, locationVec4)", "vec");
+
+shouldBeNull("contextA.getUniformLocation(programV, \"IDontExist\")");
+wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.linkProgram(programA1)");
+// After linking all boxes are bad.
+wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix4fv(locationA, false, mat)");
+
+// after re-linking the same program, all uniform locations become invalid.
+wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.useProgram(programS)");
+contextA.stencilMask(1);
+wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.linkProgram(programS)");
+wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform1i(locationSx, 3)");
+wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.getUniform(programS, locationSx)");
+
+// Retrieve the locations again, and they should be good.
+locationSx = contextA.getUniformLocation(programS, "u_struct.x");
+locationArray0 = contextA.getUniformLocation(programS, "u_array[0]");
+debug("here");
+contextA.stencilMask(0);
+wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.uniform1i(locationSx, 3)");
+wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.uniform1f(locationArray0, 123)");
+shouldBe("contextA.getUniform(programS, locationSx)", "3");
+shouldBe("contextA.getUniform(programS, locationArray0)", "123");
+
+// getUniformLocation should return a different object everytime, should not cache and return the same object
+debug("Testing that getUniformLocation returns a different object everytime");
+locationSx  = contextA.getUniformLocation(programS, "u_struct.x");
+locationSx2 = contextA.getUniformLocation(programS, "u_struct.x");
+shouldBeFalse("locationSx === locationSx2");
+locationSx.foo  = {};
+locationSx2.foo = {};
+shouldBeFalse("locationSx.foo === locationSx2.foo");
+
+var successfullyParsed = true;
+</script>
+
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/uniform-samplers-test.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/uniform-samplers-test.html
new file mode 100644
index 0000000000..fc680c0eaa
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/uniform-samplers-test.html
@@ -0,0 +1,111 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL sampler uniforms conformance test.</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+</head>
+<body>
+<canvas id="example" width="2" height="2" style="width: 40px; height: 40px;"></canvas>
+<div id="description"></div>
+<div id="console"></div>
+
+<script>
+"use strict";
+function init()
+{
+  description(
+      "Tests that only Uniform1i and Uniform1iv can be used to set" +
+      "sampler uniforms.");
+
+  var canvas2d = document.getElementById("canvas2d");
+
+  var wtu = WebGLTestUtils;
+  var gl = wtu.create3DContext("example");
+  var program = wtu.setupTexturedQuad(gl);
+
+  var textureLoc = gl.getUniformLocation(program, "tex");
+
+  gl.uniform1i(textureLoc, 1);
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR,
+      "uniform1i can set a sampler uniform");
+  gl.uniform1iv(textureLoc, [1]);
+  wtu.glErrorShouldBe(gl, gl.NO_ERROR,
+      "uniform1iv can set a sampler uniform");
+  gl.uniform1f(textureLoc, 1);
+  wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION,
+      "uniform1f returns INVALID_OPERATION if attempting to set a sampler uniform");
+  gl.uniform1fv(textureLoc, [1]);
+  wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION,
+      "uniform1fv returns INVALID_OPERATION if attempting to set a sampler uniform");
+
+  var maxTextureUnits = gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS);
+
+  var testUniformi = function() {
+    var success = true;
+    for (var ii = 0; ii < maxTextureUnits; ++ii) {
+      gl.uniform1i(textureLoc, ii);
+      success = success && (gl.getError() == gl.NO_ERROR);
+    }
+    expectTrue(success, "uniform1i works for any valid texture unit");
+  };
+
+  var testUniformiv = function() {
+    var success = true;
+    for (var ii = 0; ii < maxTextureUnits; ++ii) {
+      gl.uniform1iv(textureLoc, [ii]);
+      success = success && (gl.getError() == gl.NO_ERROR);
+    }
+    expectTrue(success, "uniform1iv works for any valid texture unit");
+  };
+
+  var steps = [
+    testUniformi,
+    testUniformiv,
+  ];
+
+  var generateInvalidUniformiTests = function(start, end) {
+    return function() {
+      var success = true;
+      for (var ii = start; ii < end; ++ii) {
+        gl.uniform1i(textureLoc, ii);
+        success = success && (gl.getError() == gl.INVALID_VALUE);
+      }
+      expectTrue(success, "uniform1i generates INVALID_VALUE for invalid texture units 0x" + start.toString(16) + " to 0x" + end.toString(16));
+    };
+  };
+
+  var generateInvalidUniformivTests = function(start, end) {
+    return function() {
+      var success = true;
+      for (var ii = start; ii < end; ++ii) {
+        gl.uniform1iv(textureLoc, [ii]);
+        success = success && (gl.getError() == gl.INVALID_VALUE);
+      }
+      expectTrue(success, "uniform1iv generates INVALID_VALUE for invalid texture units 0x" + start.toString(16) + " to 0x" + end.toString(16));
+    };
+  };
+
+  var step = 0x1000;
+  for (var ii = maxTextureUnits; ii < 0x10000; ii += step) {
+    steps.push(generateInvalidUniformiTests(ii, ii + step));
+    steps.push(generateInvalidUniformivTests(ii, ii + step));
+  }
+
+  steps.push(finishTest);
+  wtu.runSteps(steps);
+}
+
+init();
+var successfullyParsed = true;
+</script>
+</body>
+</html>
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/uniform-values-per-program.html b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/uniform-values-per-program.html
new file mode 100644
index 0000000000..6ff693f347
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/conformance/uniforms/uniform-values-per-program.html
@@ -0,0 +1,179 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL uniform values are per program conformance test.</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+</head>
+<body>
+<script id="vshader" type="x-shader/x-vertex">
+attribute vec4 a_position;
+void main() {
+  gl_Position = a_position;
+}
+</script>
+<script id="fshader" type="x-shader/x-fragment">
+precision mediump float;
+varying vec4 v_color;
+void main() {
+  gl_FragColor = v_color;
+}
+</script>
+<script id="vshaderTest" type="x-shader/x-vertex">
+attribute vec4 a_position;
+uniform $(type) $(name1);
+uniform $(type) $(name2);
+uniform bool u_select;
+varying vec4 v_color;
+void main() {
+  $(type) value = u_select ? $(name2) : $(name1);
+  v_color = $(conversion);
+  gl_Position = a_position;
+}
+</script>
+<script id="fshaderTest" type="x-shader/x-fragment">
+precision mediump float;
+uniform $(type) $(name1);
+uniform $(type) $(name2);
+uniform bool u_select;
+void main() {
+  $(type) value = u_select ? $(name2) : $(name1);
+  gl_FragColor = $(conversion);
+}
+</script>
+<canvas id="example" width="2" height="2" style="width: 40px; height: 40px;"></canvas>
+<div id="description"></div>
+<div id="console"></div>
+<script>
+"use strict";
+function init() {
+  description();
+
+  var console = document.getElementById("console");
+  var wtu = WebGLTestUtils;
+  var gl = wtu.create3DContext("example");
+  wtu.setupUnitQuad(gl);
+  var vtemplate = wtu.getScript("vshader");
+  var ftemplate = wtu.getScript("fshader");
+  var vtemplateTest = wtu.getScript("vshaderTest");
+  var ftemplateTest = wtu.getScript("fshaderTest");
+
+  var shaders = [
+    [vtemplate, ftemplateTest],
+    [vtemplateTest, ftemplate],
+  ];
+
+  var names = [
+    ["u_value1", "u_value2"],
+    ["a", "b"],
+    ["x", "y"],
+    ["y", "z"],
+    ["y", "u"],
+    ["a00000", "a00001"],
+  ];
+  var testList = [
+    { type: "float",
+      conversion: "vec4(value, 0, 0, 0)",
+      values: [[64], [128]],
+      func: 'uniform1fv',
+    },
+    { type: "vec2",
+      conversion: "vec4(value, 0, 0)",
+      values: [[64, 128], [128, 64]],
+      func: 'uniform2fv',
+    },
+    { type: "vec3",
+      conversion: "vec4(value, 0)",
+      values: [[64, 128, 192], [192, 128, 64]],
+      func: 'uniform3fv',
+    },
+    { type: "vec4",
+      conversion: "vec4(value)",
+      values: [[64, 128, 192, 255], [255, 192, 128, 64]],
+      func: 'uniform4fv',
+    },
+  ];
+
+  var clone = function(obj) {
+    var n = { };
+    for (var $key in obj) {
+      n[$key] = obj[$key];
+    }
+    return n;
+  };
+
+  var tests = [];
+  names.forEach(function(namePair) {
+    testList.forEach(function(test) {
+      var t = clone(test);
+      t.name1 = namePair[0];
+      t.name2 = namePair[1];
+      tests.push(t);
+    });
+  });
+
+  var runTest = function(test) {
+    debug("");
+    debug("testing: " + test.type);
+    shaders.forEach(function(shaderPair) {
+      var progs = [];
+      for (var ii = 0; ii < 2; ++ii) {
+        var vsource = wtu.replaceParams(shaderPair[0], test);
+        var fsource = wtu.replaceParams(shaderPair[1], test);
+        if (!ii) {
+          wtu.addShaderSource(console, "vertex shader: type = " + test.type + " with names " + test.name1 + ", " + test.name2, vsource);
+          wtu.addShaderSource(console, "fragment shader: type = " + test.type + " with names " + test.name1 + ", " + test.name2, fsource);
+        }
+        var program = wtu.setupProgram(gl, [vsource, fsource], ["a_position"]);
+        var info = {
+          program: program,
+          valueLocs: [gl.getUniformLocation(program, test.name1),
+                      gl.getUniformLocation(program, test.name2)],
+          selectLoc: gl.getUniformLocation(program, "u_select"),
+        };
+        var v1 = test.values[0];
+        var v2 = test.values[1];
+        if (ii) {
+          var t = v1;
+          v1 = v2;
+          v2 = t;
+        }
+        info.expect = [v1, v2];
+        for (var jj = 0; jj < 2; ++jj) {
+          var input = info.expect[jj].map(function(v) { return v / 255; });
+          gl[test.func](info.valueLocs[jj], input);
+        }
+        progs.push(info);
+      }
+      for (var ii = 0; ii < 2; ++ii) {
+        progs.forEach(function(info) {
+          gl.useProgram(info.program);
+          gl.uniform1i(info.selectLoc, ii);
+          wtu.clearAndDrawUnitQuad(gl);
+          wtu.checkCanvas(gl, info.expect[ii], undefined, 1);
+        });
+      }
+      progs.forEach(function(info) {
+        gl.deleteProgram(info.program);
+      });
+    });
+  }
+  tests.forEach(function(test){
+    runTest(test);
+  });
+}
+init();
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>
+
-- 
cgit v1.2.3