Trace/Replay: Add uniform location type.

This is a large refactor that replaces instances of "GLint location"
for uniform locations with "UniformLocation location". This boxed type
is similar to the ResourceID types that we use to capture resource IDs
more easily. Eventually this will give us a more portable replay.

Bug: angleproject:4411
Change-Id: I848e861c3956d95b6b953f57f8b6a2c4a676766f
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2066117
Reviewed-by: Cody Northrop <cnorthrop@google.com>
Reviewed-by: Jonah Ryan-Davis <jonahr@google.com>
Commit-Queue: Jamie Madill <jmadill@chromium.org>
diff --git a/scripts/code_generation_hashes/GL_EGL_entry_points.json b/scripts/code_generation_hashes/GL_EGL_entry_points.json
index 5029f0f..13234f1 100644
--- a/scripts/code_generation_hashes/GL_EGL_entry_points.json
+++ b/scripts/code_generation_hashes/GL_EGL_entry_points.json
@@ -4,7 +4,7 @@
   "scripts/egl_angle_ext.xml":
     "63f18dc9b7183ead4ddd3dfd1571973a",
   "scripts/entry_point_packed_gl_enums.json":
-    "e956bcc16844701071dc1bcfde2b0c30",
+    "63f508a08611e75810daedb297dca0e9",
   "scripts/generate_entry_points.py":
     "2e6615919533b8ca9042093287589165",
   "scripts/gl.xml":
@@ -40,9 +40,9 @@
   "src/libANGLE/Context_gl_3_3_autogen.h":
     "6e8d776e94883ab254a5c37db1330754",
   "src/libANGLE/Context_gl_4_0_autogen.h":
-    "b2f75358fc3845026d670e4af4809688",
+    "22267e42b16a48f21dadfff565d2a6f3",
   "src/libANGLE/Context_gl_4_1_autogen.h":
-    "432580f798537a5ce77c57a075748ce1",
+    "fe1e928d27ec166a507d4a59a85c196c",
   "src/libANGLE/Context_gl_4_2_autogen.h":
     "6a77d507af0454802201ca553f06cc0b",
   "src/libANGLE/Context_gl_4_3_autogen.h":
@@ -50,67 +50,67 @@
   "src/libANGLE/Context_gl_4_4_autogen.h":
     "27b04d8d3b1f7a2804d49b85627e78a9",
   "src/libANGLE/Context_gl_4_5_autogen.h":
-    "5fca3d4373eae2cf930c33c479d719e6",
+    "f06e102c161b2804caaa943027f157ad",
   "src/libANGLE/Context_gl_4_6_autogen.h":
     "738e344919d9a867e8823cbf52d10394",
   "src/libANGLE/Context_gles_1_0_autogen.h":
     "51fce95acbf8de72d21255adbbe0e8cd",
   "src/libANGLE/Context_gles_2_0_autogen.h":
-    "bb7026f4e1c47e4975973041f70ff502",
+    "443d00d45de147d1d1e3b66846ea0c29",
   "src/libANGLE/Context_gles_3_0_autogen.h":
-    "9656c0f8c2c3e68544c686912f27befc",
+    "fe61c2c821816d9561dcb4fe1fef74e5",
   "src/libANGLE/Context_gles_3_1_autogen.h":
-    "edf174d417685c0d32a54e0aca65c29f",
+    "bb8198422232ca9ceaa06a5d37c3cd92",
   "src/libANGLE/Context_gles_3_2_autogen.h":
-    "46d2e77a9bfbe7a53970403ad65777d3",
+    "e26f7ee7b59a89a4f5337171816b8336",
   "src/libANGLE/Context_gles_ext_autogen.h":
-    "ef3e9641d30952c85df3f451f4ddf3dc",
+    "88b35bb1ca47f74d17f39e40bc6714cb",
   "src/libANGLE/capture_gles_1_0_autogen.cpp":
     "96fc0f501e2e696ab911dad8b400dfb2",
   "src/libANGLE/capture_gles_1_0_autogen.h":
     "546173090c85ad28a580ca76cd117484",
   "src/libANGLE/capture_gles_2_0_autogen.cpp":
-    "a638d95098d94dde3af767edaa731e11",
+    "9e47542f50b29581f5fcaf5a69f6b518",
   "src/libANGLE/capture_gles_2_0_autogen.h":
-    "1d5f8b8d281c0ba80eccd0be0590ea17",
+    "6985d5e3d0126bc8e02dd982267a904f",
   "src/libANGLE/capture_gles_3_0_autogen.cpp":
-    "109c08bb2247e5e293c1bb5259bd9724",
+    "a12c9470569b9d1d63ab0b8be910055f",
   "src/libANGLE/capture_gles_3_0_autogen.h":
-    "09cb8286a16d3fc2255cb9dcc0c16236",
+    "b963fec070e0becdcf4af69216cd1c7b",
   "src/libANGLE/capture_gles_3_1_autogen.cpp":
-    "92c3c9f7b62c937fd3595c2a1d1a9ce0",
+    "c7c4ee0fcebc9bd19f8f4a498f935ac1",
   "src/libANGLE/capture_gles_3_1_autogen.h":
-    "3ad016de2aad9095ad57073aa0fc9f9f",
+    "3d363f4de97b47ecff61e29939dcf11a",
   "src/libANGLE/capture_gles_3_2_autogen.cpp":
-    "939dfca1b423b56cc74260dc623eb0f5",
+    "f3497a63d27a30b9a10ffffd4c25c023",
   "src/libANGLE/capture_gles_3_2_autogen.h":
-    "a7fa951e9296e927cd9bb197c51dc9a2",
+    "2fbca7168541c2e9ff8a055c256f8531",
   "src/libANGLE/capture_gles_ext_autogen.cpp":
-    "54f3fcdea1388c0a3cfd3bb0aea4362f",
+    "dd0bfd07e2981b04a10a084979c4566a",
   "src/libANGLE/capture_gles_ext_autogen.h":
-    "c7c26bfb77cb19b72bdd86433d9ee92b",
+    "829ae7f3a6a36a747e1104b3a9f16f46",
   "src/libANGLE/entry_points_enum_autogen.cpp":
     "fe353457d091e15d9da24d50b4fee576",
   "src/libANGLE/entry_points_enum_autogen.h":
     "05310685f81d72ef44657923ac339061",
   "src/libANGLE/frame_capture_replay_autogen.cpp":
-    "bc3dc81d516e5eb3a331b4102d45f2a3",
+    "c0d57704c21e0032a486a6195ddb87e4",
   "src/libANGLE/frame_capture_utils_autogen.cpp":
-    "32f055ef063856f7ac8d7d292eda5a75",
+    "ef0545342e0458e55e17abf46a8cde60",
   "src/libANGLE/frame_capture_utils_autogen.h":
-    "aeaac3bbf5888b5c6663e488ee3fd35e",
+    "637125f7c18f05c17800e5da2516fd6b",
   "src/libANGLE/validationES1_autogen.h":
     "c8edb0a5b26303bf7c4692b9d0b05c1f",
   "src/libANGLE/validationES2_autogen.h":
-    "e6c06c5c666567eb0e070a65e205c458",
+    "1fc4c7017ae5949160ac2561e6d2e22e",
   "src/libANGLE/validationES31_autogen.h":
-    "ced6a2a8fe729bfb78e1e3bed2a356f8",
+    "ed9066cbf406b6f782c058019895c65e",
   "src/libANGLE/validationES32_autogen.h":
-    "99ba0e0a15334183de77fda0bd7b5e2f",
+    "7b4b5f9398a4c088feab8ba2c6bfc024",
   "src/libANGLE/validationES3_autogen.h":
-    "82d0cbfe111519c32773429fd6aaa682",
+    "86ba503835328438158d9a464943f3bd",
   "src/libANGLE/validationESEXT_autogen.h":
-    "601cd000adf34e4c4da645540f318971",
+    "679656b99ca7fe2f7fed4dc6f929a2f0",
   "src/libANGLE/validationGL11_autogen.h":
     "aadd145c1404de9c34d6b7c00404f10f",
   "src/libANGLE/validationGL12_autogen.h":
@@ -136,7 +136,7 @@
   "src/libANGLE/validationGL3_autogen.h":
     "7cefaa9e5568cb86df01371ad5390a29",
   "src/libANGLE/validationGL41_autogen.h":
-    "6c0072df06b845ff21a8df01cfa737be",
+    "f92033868e2a6ecf707b730c70d44f2c",
   "src/libANGLE/validationGL42_autogen.h":
     "9bbc3bc1a2b89ca62bf219bc15903ec9",
   "src/libANGLE/validationGL43_autogen.h":
@@ -144,11 +144,11 @@
   "src/libANGLE/validationGL44_autogen.h":
     "ee89bec1bf4eab31b3b653c0f1a88d33",
   "src/libANGLE/validationGL45_autogen.h":
-    "4861e80312b3050f7cbe68974e8fb26b",
+    "a0af5104f0d3949c9d945387d11e6302",
   "src/libANGLE/validationGL46_autogen.h":
     "46f74a3b19fd7e243ddd47a7478ae818",
   "src/libANGLE/validationGL4_autogen.h":
-    "085b3f1153a23a03560d74ab2f0b407a",
+    "cbe3f917024a93a3adcbd2806f3e951f",
   "src/libGL/entry_points_gl_1_0_autogen.cpp":
     "e984e675dab9624214609fc86f1330a8",
   "src/libGL/entry_points_gl_1_0_autogen.h":
@@ -174,15 +174,15 @@
   "src/libGL/entry_points_gl_1_5_autogen.h":
     "978457aa9a40e427846b6dea24608903",
   "src/libGL/entry_points_gl_2_0_autogen.cpp":
-    "84159251135f9ff63ab46b0d44717e8c",
+    "68fbf332b51401391978bc4bb3ece654",
   "src/libGL/entry_points_gl_2_0_autogen.h":
     "41b0cd064167fac84bcdb1896a275b1b",
   "src/libGL/entry_points_gl_2_1_autogen.cpp":
-    "fb873cf58c85b5f7bb3806723bb9cc7d",
+    "4e31b9d8a88dc69a9f1f07b0adb98965",
   "src/libGL/entry_points_gl_2_1_autogen.h":
     "1da48dec560ea5ff8cadf4d0b6bfde1c",
   "src/libGL/entry_points_gl_3_0_autogen.cpp":
-    "b0f24eb8d41ed4e74f344310ae5cae58",
+    "6decc6494c9acdfb63d5379b0bb7e767",
   "src/libGL/entry_points_gl_3_0_autogen.h":
     "0fad8005f23815beb8ee9b3797c00b83",
   "src/libGL/entry_points_gl_3_1_autogen.cpp":
@@ -198,11 +198,11 @@
   "src/libGL/entry_points_gl_3_3_autogen.h":
     "51c0e4f074c85447f5d910c63b9ea61c",
   "src/libGL/entry_points_gl_4_0_autogen.cpp":
-    "bd045ed365a4221b687a5165ed19ebd1",
+    "4e4c098104082451d2b1c450d48bca72",
   "src/libGL/entry_points_gl_4_0_autogen.h":
     "35d611138951cebc29db99c9bf3a9e5f",
   "src/libGL/entry_points_gl_4_1_autogen.cpp":
-    "3e222566ead25c7502759f9791e046a7",
+    "af2ffeafdee8535470bc8fb4ee9e62fd",
   "src/libGL/entry_points_gl_4_1_autogen.h":
     "beec6659a3a77695dad66df90717c6ba",
   "src/libGL/entry_points_gl_4_2_autogen.cpp":
@@ -218,7 +218,7 @@
   "src/libGL/entry_points_gl_4_4_autogen.h":
     "cdf1651f00d26db547b153afc09acc1c",
   "src/libGL/entry_points_gl_4_5_autogen.cpp":
-    "edcdb0812eb93bb326206ed36e926fd2",
+    "506e903d618ca6039eafe639a0d358f4",
   "src/libGL/entry_points_gl_4_5_autogen.h":
     "9f5de9513c06b82aca60856860f7b716",
   "src/libGL/entry_points_gl_4_6_autogen.cpp":
@@ -234,23 +234,23 @@
   "src/libGLESv2/entry_points_gles_1_0_autogen.h":
     "899dcff9383465380f94fbdfe5bcf0a0",
   "src/libGLESv2/entry_points_gles_2_0_autogen.cpp":
-    "6691602981aa499d9f161fad9e29dc97",
+    "5a54d106e1196795ab9bb22d24f32dc4",
   "src/libGLESv2/entry_points_gles_2_0_autogen.h":
     "26387e27cbddf5e34d6cd9f850cb8b64",
   "src/libGLESv2/entry_points_gles_3_0_autogen.cpp":
-    "ef0c7e4e95e4a24df1a5444e73bd9546",
+    "bce7650df5a83ae9c6b080b1a4a9164b",
   "src/libGLESv2/entry_points_gles_3_0_autogen.h":
     "0d246024379fbf55b87204db5d6a37e3",
   "src/libGLESv2/entry_points_gles_3_1_autogen.cpp":
-    "25e9c5b7fe2ff636900b58bcc85d988e",
+    "f449340852be3a389f52fb10ddd29d94",
   "src/libGLESv2/entry_points_gles_3_1_autogen.h":
     "69bae5c94ed4665836a8464b6c353f9a",
   "src/libGLESv2/entry_points_gles_3_2_autogen.cpp":
-    "af1667dfdb02f265ff1cee8d3631081c",
+    "9a99b15122eb73daff955cea097185ea",
   "src/libGLESv2/entry_points_gles_3_2_autogen.h":
     "5798aa0a73af1d4ba5dfe99b6217a247",
   "src/libGLESv2/entry_points_gles_ext_autogen.cpp":
-    "2d846467e92f74e42c9262a3b34a5b6b",
+    "b30524b202b51f61d6fa673158cc19b5",
   "src/libGLESv2/entry_points_gles_ext_autogen.h":
     "d14fb18d0a56513c7e5602032455273e",
   "src/libGLESv2/libGLESv2_autogen.cpp":
diff --git a/scripts/entry_point_packed_gl_enums.json b/scripts/entry_point_packed_gl_enums.json
index 328b681..819c9c8 100644
--- a/scripts/entry_point_packed_gl_enums.json
+++ b/scripts/entry_point_packed_gl_enums.json
@@ -89,7 +89,8 @@
         "id": "TransformFeedbackID"
     },
     "glBindUniformLocation": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glBindVertexArray": {
         "array": "VertexArrayID"
@@ -574,25 +575,32 @@
         "renderbuffer": "RenderbufferID"
     },
     "glGetnUniformdv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glGetnUniformfv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glGetnUniformfvRobust": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glGetnUniformiv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glGetnUniformivRobust": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glGetnUniformuiv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glGetnUniformuivRobust": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glGetPathCommands": {
         "path": "PathID"
@@ -839,31 +847,38 @@
         "program": "ShaderProgramID"
     },
     "glGetUniformdv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glGetUniformfv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glGetUniformfvRobust": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glGetUniformIndices": {
         "program": "ShaderProgramID"
     },
     "glGetUniformiv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glGetUniformivRobust": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glGetUniformLocation": {
         "program": "ShaderProgramID"
     },
     "glGetUniformuiv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glGetUniformuivRobust": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glGetVertexArrayIndexed64iv": {
         "vaobj": "VertexArrayID"
@@ -1158,154 +1173,204 @@
         "program": "ShaderProgramID"
     },
     "glProgramUniform1d": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform1dv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform1f": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform1fv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform1i": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform1iv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform1ui": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform1uiv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform2d": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform2dv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform2f": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform2fv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform2i": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform2iv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform2ui": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform2uiv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform3d": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform3dv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform3f": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform3fv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform3i": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform3iv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform3ui": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform3uiv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform4d": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform4dv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform4f": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform4fv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform4i": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform4iv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform4ui": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniform4uiv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix2dv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix2fv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix2x3dv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix2x3fv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix2x4dv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix2x4fv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix3dv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix3fv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix3x2dv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix3x2fv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix3x4dv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix3x4fv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix4dv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix4fv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix4x2dv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix4x2fv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix4x3dv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProgramUniformMatrix4x3fv": {
-        "program": "ShaderProgramID"
+        "program": "ShaderProgramID",
+        "location": "UniformLocation"
     },
     "glProvokingVertex": {
         "mode": "ProvokingVertexConvention"
@@ -1580,6 +1645,156 @@
     "glTransformFeedbackVaryings": {
         "program": "ShaderProgramID"
     },
+    "glUniform1f": {
+        "location": "UniformLocation"
+    },
+    "glUniform1fv": {
+        "location": "UniformLocation"
+    },
+    "glUniform1i": {
+        "location": "UniformLocation"
+    },
+    "glUniform1iv": {
+        "location": "UniformLocation"
+    },
+    "glUniform1ui": {
+        "location": "UniformLocation"
+    },
+    "glUniform1uiv": {
+        "location": "UniformLocation"
+    },
+    "glUniform2f": {
+        "location": "UniformLocation"
+    },
+    "glUniform2fv": {
+        "location": "UniformLocation"
+    },
+    "glUniform2i": {
+        "location": "UniformLocation"
+    },
+    "glUniform2iv": {
+        "location": "UniformLocation"
+    },
+    "glUniform2ui": {
+        "location": "UniformLocation"
+    },
+    "glUniform2uiv": {
+        "location": "UniformLocation"
+    },
+    "glUniform3f": {
+        "location": "UniformLocation"
+    },
+    "glUniform3fv": {
+        "location": "UniformLocation"
+    },
+    "glUniform3i": {
+        "location": "UniformLocation"
+    },
+    "glUniform3iv": {
+        "location": "UniformLocation"
+    },
+    "glUniform3ui": {
+        "location": "UniformLocation"
+    },
+    "glUniform3uiv": {
+        "location": "UniformLocation"
+    },
+    "glUniform4f": {
+        "location": "UniformLocation"
+    },
+    "glUniform4fv": {
+        "location": "UniformLocation"
+    },
+    "glUniform4i": {
+        "location": "UniformLocation"
+    },
+    "glUniform4iv": {
+        "location": "UniformLocation"
+    },
+    "glUniform4ui": {
+        "location": "UniformLocation"
+    },
+    "glUniform4uiv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix2fv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix3fv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix4fv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix2x3fv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix2x4fv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix3x2fv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix3x4fv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix4x2fv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix4x3fv": {
+        "location": "UniformLocation"
+    },
+    "glUniform1d": {
+        "location": "UniformLocation"
+    },
+    "glUniform1dv": {
+        "location": "UniformLocation"
+    },
+    "glUniform2d": {
+        "location": "UniformLocation"
+    },
+    "glUniform2dv": {
+        "location": "UniformLocation"
+    },
+    "glUniform3d": {
+        "location": "UniformLocation"
+    },
+    "glUniform3dv": {
+        "location": "UniformLocation"
+    },
+    "glUniform4d": {
+        "location": "UniformLocation"
+    },
+    "glUniform4dv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix2dv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix2x3dv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix2x4dv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix3dv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix3x2dv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix3x4dv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix4dv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix4x2dv": {
+        "location": "UniformLocation"
+    },
+    "glUniformMatrix4x3dv": {
+        "location": "UniformLocation"
+    },
     "glUniformBlockBinding": {
         "program": "ShaderProgramID"
     },
diff --git a/src/common/PackedEnums.h b/src/common/PackedEnums.h
index bd5fc34..2331ab4 100644
--- a/src/common/PackedEnums.h
+++ b/src/common/PackedEnums.h
@@ -548,6 +548,11 @@
 {
     return reinterpret_cast<EnumT>(from);
 }
+
+struct UniformLocation
+{
+    int value;
+};
 }  // namespace gl
 
 namespace egl
diff --git a/src/libANGLE/Context.cpp b/src/libANGLE/Context.cpp
index 6640956..8acecea 100644
--- a/src/libANGLE/Context.cpp
+++ b/src/libANGLE/Context.cpp
@@ -2471,7 +2471,9 @@
     ANGLE_CONTEXT_TRY(mImplementation->popGroupMarker());
 }
 
-void Context::bindUniformLocation(ShaderProgramID program, GLint location, const GLchar *name)
+void Context::bindUniformLocation(ShaderProgramID program,
+                                  UniformLocation location,
+                                  const GLchar *name)
 {
     Program *programObject = getProgramResolveLink(program);
     ASSERT(programObject);
@@ -6645,7 +6647,7 @@
     shaderObject->getSource(bufsize, length, source);
 }
 
-void Context::getUniformfv(ShaderProgramID program, GLint location, GLfloat *params)
+void Context::getUniformfv(ShaderProgramID program, UniformLocation location, GLfloat *params)
 {
     Program *programObject = getProgramResolveLink(program);
     ASSERT(programObject);
@@ -6653,7 +6655,7 @@
 }
 
 void Context::getUniformfvRobust(ShaderProgramID program,
-                                 GLint location,
+                                 UniformLocation location,
                                  GLsizei bufSize,
                                  GLsizei *length,
                                  GLfloat *params)
@@ -6661,7 +6663,7 @@
     getUniformfv(program, location, params);
 }
 
-void Context::getUniformiv(ShaderProgramID program, GLint location, GLint *params)
+void Context::getUniformiv(ShaderProgramID program, UniformLocation location, GLint *params)
 {
     Program *programObject = getProgramResolveLink(program);
     ASSERT(programObject);
@@ -6669,7 +6671,7 @@
 }
 
 void Context::getUniformivRobust(ShaderProgramID program,
-                                 GLint location,
+                                 UniformLocation location,
                                  GLsizei bufSize,
                                  GLsizei *length,
                                  GLint *params)
@@ -6681,7 +6683,7 @@
 {
     Program *programObject = getProgramResolveLink(program);
     ASSERT(programObject);
-    return programObject->getUniformLocation(name);
+    return programObject->getUniformLocation(name).value;
 }
 
 GLboolean Context::isBuffer(BufferID buffer) const
@@ -6838,19 +6840,22 @@
     UNIMPLEMENTED();
 }
 
-void Context::uniform1f(GLint location, GLfloat x)
+void Context::uniform1f(UniformLocation location, GLfloat x)
 {
     Program *program = mState.getProgram();
     program->setUniform1fv(location, 1, &x);
 }
 
-void Context::uniform1fv(GLint location, GLsizei count, const GLfloat *v)
+void Context::uniform1fv(UniformLocation location, GLsizei count, const GLfloat *v)
 {
     Program *program = mState.getProgram();
     program->setUniform1fv(location, count, v);
 }
 
-void Context::setUniform1iImpl(Program *program, GLint location, GLsizei count, const GLint *v)
+void Context::setUniform1iImpl(Program *program,
+                               UniformLocation location,
+                               GLsizei count,
+                               const GLint *v)
 {
     program->setUniform1iv(this, location, count, v);
 }
@@ -6861,95 +6866,95 @@
     mStateCache.onActiveTextureChange(this);
 }
 
-void Context::uniform1i(GLint location, GLint x)
+void Context::uniform1i(UniformLocation location, GLint x)
 {
     setUniform1iImpl(mState.getProgram(), location, 1, &x);
 }
 
-void Context::uniform1iv(GLint location, GLsizei count, const GLint *v)
+void Context::uniform1iv(UniformLocation location, GLsizei count, const GLint *v)
 {
     setUniform1iImpl(mState.getProgram(), location, count, v);
 }
 
-void Context::uniform2f(GLint location, GLfloat x, GLfloat y)
+void Context::uniform2f(UniformLocation location, GLfloat x, GLfloat y)
 {
     GLfloat xy[2]    = {x, y};
     Program *program = mState.getProgram();
     program->setUniform2fv(location, 1, xy);
 }
 
-void Context::uniform2fv(GLint location, GLsizei count, const GLfloat *v)
+void Context::uniform2fv(UniformLocation location, GLsizei count, const GLfloat *v)
 {
     Program *program = mState.getProgram();
     program->setUniform2fv(location, count, v);
 }
 
-void Context::uniform2i(GLint location, GLint x, GLint y)
+void Context::uniform2i(UniformLocation location, GLint x, GLint y)
 {
     GLint xy[2]      = {x, y};
     Program *program = mState.getProgram();
     program->setUniform2iv(location, 1, xy);
 }
 
-void Context::uniform2iv(GLint location, GLsizei count, const GLint *v)
+void Context::uniform2iv(UniformLocation location, GLsizei count, const GLint *v)
 {
     Program *program = mState.getProgram();
     program->setUniform2iv(location, count, v);
 }
 
-void Context::uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
+void Context::uniform3f(UniformLocation location, GLfloat x, GLfloat y, GLfloat z)
 {
     GLfloat xyz[3]   = {x, y, z};
     Program *program = mState.getProgram();
     program->setUniform3fv(location, 1, xyz);
 }
 
-void Context::uniform3fv(GLint location, GLsizei count, const GLfloat *v)
+void Context::uniform3fv(UniformLocation location, GLsizei count, const GLfloat *v)
 {
     Program *program = mState.getProgram();
     program->setUniform3fv(location, count, v);
 }
 
-void Context::uniform3i(GLint location, GLint x, GLint y, GLint z)
+void Context::uniform3i(UniformLocation location, GLint x, GLint y, GLint z)
 {
     GLint xyz[3]     = {x, y, z};
     Program *program = mState.getProgram();
     program->setUniform3iv(location, 1, xyz);
 }
 
-void Context::uniform3iv(GLint location, GLsizei count, const GLint *v)
+void Context::uniform3iv(UniformLocation location, GLsizei count, const GLint *v)
 {
     Program *program = mState.getProgram();
     program->setUniform3iv(location, count, v);
 }
 
-void Context::uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+void Context::uniform4f(UniformLocation location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
     GLfloat xyzw[4]  = {x, y, z, w};
     Program *program = mState.getProgram();
     program->setUniform4fv(location, 1, xyzw);
 }
 
-void Context::uniform4fv(GLint location, GLsizei count, const GLfloat *v)
+void Context::uniform4fv(UniformLocation location, GLsizei count, const GLfloat *v)
 {
     Program *program = mState.getProgram();
     program->setUniform4fv(location, count, v);
 }
 
-void Context::uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
+void Context::uniform4i(UniformLocation location, GLint x, GLint y, GLint z, GLint w)
 {
     GLint xyzw[4]    = {x, y, z, w};
     Program *program = mState.getProgram();
     program->setUniform4iv(location, 1, xyzw);
 }
 
-void Context::uniform4iv(GLint location, GLsizei count, const GLint *v)
+void Context::uniform4iv(UniformLocation location, GLsizei count, const GLint *v)
 {
     Program *program = mState.getProgram();
     program->setUniform4iv(location, count, v);
 }
 
-void Context::uniformMatrix2fv(GLint location,
+void Context::uniformMatrix2fv(UniformLocation location,
                                GLsizei count,
                                GLboolean transpose,
                                const GLfloat *value)
@@ -6958,7 +6963,7 @@
     program->setUniformMatrix2fv(location, count, transpose, value);
 }
 
-void Context::uniformMatrix3fv(GLint location,
+void Context::uniformMatrix3fv(UniformLocation location,
                                GLsizei count,
                                GLboolean transpose,
                                const GLfloat *value)
@@ -6967,7 +6972,7 @@
     program->setUniformMatrix3fv(location, count, transpose, value);
 }
 
-void Context::uniformMatrix4fv(GLint location,
+void Context::uniformMatrix4fv(UniformLocation location,
                                GLsizei count,
                                GLboolean transpose,
                                const GLfloat *value)
@@ -7012,51 +7017,51 @@
     ANGLE_CONTEXT_TRY(onProgramLink(programObject));
 }
 
-void Context::uniform1ui(GLint location, GLuint v0)
+void Context::uniform1ui(UniformLocation location, GLuint v0)
 {
     Program *program = mState.getProgram();
     program->setUniform1uiv(location, 1, &v0);
 }
 
-void Context::uniform2ui(GLint location, GLuint v0, GLuint v1)
+void Context::uniform2ui(UniformLocation location, GLuint v0, GLuint v1)
 {
     Program *program  = mState.getProgram();
     const GLuint xy[] = {v0, v1};
     program->setUniform2uiv(location, 1, xy);
 }
 
-void Context::uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
+void Context::uniform3ui(UniformLocation location, GLuint v0, GLuint v1, GLuint v2)
 {
     Program *program   = mState.getProgram();
     const GLuint xyz[] = {v0, v1, v2};
     program->setUniform3uiv(location, 1, xyz);
 }
 
-void Context::uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
+void Context::uniform4ui(UniformLocation location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
     Program *program    = mState.getProgram();
     const GLuint xyzw[] = {v0, v1, v2, v3};
     program->setUniform4uiv(location, 1, xyzw);
 }
 
-void Context::uniform1uiv(GLint location, GLsizei count, const GLuint *value)
+void Context::uniform1uiv(UniformLocation location, GLsizei count, const GLuint *value)
 {
     Program *program = mState.getProgram();
     program->setUniform1uiv(location, count, value);
 }
-void Context::uniform2uiv(GLint location, GLsizei count, const GLuint *value)
+void Context::uniform2uiv(UniformLocation location, GLsizei count, const GLuint *value)
 {
     Program *program = mState.getProgram();
     program->setUniform2uiv(location, count, value);
 }
 
-void Context::uniform3uiv(GLint location, GLsizei count, const GLuint *value)
+void Context::uniform3uiv(UniformLocation location, GLsizei count, const GLuint *value)
 {
     Program *program = mState.getProgram();
     program->setUniform3uiv(location, count, value);
 }
 
-void Context::uniform4uiv(GLint location, GLsizei count, const GLuint *value)
+void Context::uniform4uiv(UniformLocation location, GLsizei count, const GLuint *value)
 {
     Program *program = mState.getProgram();
     program->setUniform4uiv(location, count, value);
@@ -7100,7 +7105,7 @@
     return ConvertToGLBoolean(getQuery(id) != nullptr);
 }
 
-void Context::uniformMatrix2x3fv(GLint location,
+void Context::uniformMatrix2x3fv(UniformLocation location,
                                  GLsizei count,
                                  GLboolean transpose,
                                  const GLfloat *value)
@@ -7109,7 +7114,7 @@
     program->setUniformMatrix2x3fv(location, count, transpose, value);
 }
 
-void Context::uniformMatrix3x2fv(GLint location,
+void Context::uniformMatrix3x2fv(UniformLocation location,
                                  GLsizei count,
                                  GLboolean transpose,
                                  const GLfloat *value)
@@ -7118,7 +7123,7 @@
     program->setUniformMatrix3x2fv(location, count, transpose, value);
 }
 
-void Context::uniformMatrix2x4fv(GLint location,
+void Context::uniformMatrix2x4fv(UniformLocation location,
                                  GLsizei count,
                                  GLboolean transpose,
                                  const GLfloat *value)
@@ -7127,7 +7132,7 @@
     program->setUniformMatrix2x4fv(location, count, transpose, value);
 }
 
-void Context::uniformMatrix4x2fv(GLint location,
+void Context::uniformMatrix4x2fv(UniformLocation location,
                                  GLsizei count,
                                  GLboolean transpose,
                                  const GLfloat *value)
@@ -7136,7 +7141,7 @@
     program->setUniformMatrix4x2fv(location, count, transpose, value);
 }
 
-void Context::uniformMatrix3x4fv(GLint location,
+void Context::uniformMatrix3x4fv(UniformLocation location,
                                  GLsizei count,
                                  GLboolean transpose,
                                  const GLfloat *value)
@@ -7145,7 +7150,7 @@
     program->setUniformMatrix3x4fv(location, count, transpose, value);
 }
 
-void Context::uniformMatrix4x3fv(GLint location,
+void Context::uniformMatrix4x3fv(UniformLocation location,
                                  GLsizei count,
                                  GLboolean transpose,
                                  const GLfloat *value)
@@ -7289,14 +7294,14 @@
     mStateCache.onActiveTransformFeedbackChange(this);
 }
 
-void Context::getUniformuiv(ShaderProgramID program, GLint location, GLuint *params)
+void Context::getUniformuiv(ShaderProgramID program, UniformLocation location, GLuint *params)
 {
     const Program *programObject = getProgramResolveLink(program);
     programObject->getUniformuiv(this, location, params);
 }
 
 void Context::getUniformuivRobust(ShaderProgramID program,
-                                  GLint location,
+                                  UniformLocation location,
                                   GLsizei bufSize,
                                   GLsizei *length,
                                   GLuint *params)
@@ -7518,19 +7523,22 @@
     getInternalformativ(target, internalformat, pname, bufSize, params);
 }
 
-void Context::programUniform1i(ShaderProgramID program, GLint location, GLint v0)
+void Context::programUniform1i(ShaderProgramID program, UniformLocation location, GLint v0)
 {
     programUniform1iv(program, location, 1, &v0);
 }
 
-void Context::programUniform2i(ShaderProgramID program, GLint location, GLint v0, GLint v1)
+void Context::programUniform2i(ShaderProgramID program,
+                               UniformLocation location,
+                               GLint v0,
+                               GLint v1)
 {
     GLint xy[2] = {v0, v1};
     programUniform2iv(program, location, 1, xy);
 }
 
 void Context::programUniform3i(ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLint v0,
                                GLint v1,
                                GLint v2)
@@ -7540,7 +7548,7 @@
 }
 
 void Context::programUniform4i(ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLint v0,
                                GLint v1,
                                GLint v2,
@@ -7550,19 +7558,22 @@
     programUniform4iv(program, location, 1, xyzw);
 }
 
-void Context::programUniform1ui(ShaderProgramID program, GLint location, GLuint v0)
+void Context::programUniform1ui(ShaderProgramID program, UniformLocation location, GLuint v0)
 {
     programUniform1uiv(program, location, 1, &v0);
 }
 
-void Context::programUniform2ui(ShaderProgramID program, GLint location, GLuint v0, GLuint v1)
+void Context::programUniform2ui(ShaderProgramID program,
+                                UniformLocation location,
+                                GLuint v0,
+                                GLuint v1)
 {
     GLuint xy[2] = {v0, v1};
     programUniform2uiv(program, location, 1, xy);
 }
 
 void Context::programUniform3ui(ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLuint v0,
                                 GLuint v1,
                                 GLuint v2)
@@ -7572,7 +7583,7 @@
 }
 
 void Context::programUniform4ui(ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLuint v0,
                                 GLuint v1,
                                 GLuint v2,
@@ -7582,19 +7593,22 @@
     programUniform4uiv(program, location, 1, xyzw);
 }
 
-void Context::programUniform1f(ShaderProgramID program, GLint location, GLfloat v0)
+void Context::programUniform1f(ShaderProgramID program, UniformLocation location, GLfloat v0)
 {
     programUniform1fv(program, location, 1, &v0);
 }
 
-void Context::programUniform2f(ShaderProgramID program, GLint location, GLfloat v0, GLfloat v1)
+void Context::programUniform2f(ShaderProgramID program,
+                               UniformLocation location,
+                               GLfloat v0,
+                               GLfloat v1)
 {
     GLfloat xy[2] = {v0, v1};
     programUniform2fv(program, location, 1, xy);
 }
 
 void Context::programUniform3f(ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLfloat v0,
                                GLfloat v1,
                                GLfloat v2)
@@ -7604,7 +7618,7 @@
 }
 
 void Context::programUniform4f(ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLfloat v0,
                                GLfloat v1,
                                GLfloat v2,
@@ -7615,7 +7629,7 @@
 }
 
 void Context::programUniform1iv(ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 const GLint *value)
 {
@@ -7625,7 +7639,7 @@
 }
 
 void Context::programUniform2iv(ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 const GLint *value)
 {
@@ -7635,7 +7649,7 @@
 }
 
 void Context::programUniform3iv(ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 const GLint *value)
 {
@@ -7645,7 +7659,7 @@
 }
 
 void Context::programUniform4iv(ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 const GLint *value)
 {
@@ -7655,7 +7669,7 @@
 }
 
 void Context::programUniform1uiv(ShaderProgramID program,
-                                 GLint location,
+                                 UniformLocation location,
                                  GLsizei count,
                                  const GLuint *value)
 {
@@ -7665,7 +7679,7 @@
 }
 
 void Context::programUniform2uiv(ShaderProgramID program,
-                                 GLint location,
+                                 UniformLocation location,
                                  GLsizei count,
                                  const GLuint *value)
 {
@@ -7675,7 +7689,7 @@
 }
 
 void Context::programUniform3uiv(ShaderProgramID program,
-                                 GLint location,
+                                 UniformLocation location,
                                  GLsizei count,
                                  const GLuint *value)
 {
@@ -7685,7 +7699,7 @@
 }
 
 void Context::programUniform4uiv(ShaderProgramID program,
-                                 GLint location,
+                                 UniformLocation location,
                                  GLsizei count,
                                  const GLuint *value)
 {
@@ -7695,7 +7709,7 @@
 }
 
 void Context::programUniform1fv(ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 const GLfloat *value)
 {
@@ -7705,7 +7719,7 @@
 }
 
 void Context::programUniform2fv(ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 const GLfloat *value)
 {
@@ -7715,7 +7729,7 @@
 }
 
 void Context::programUniform3fv(ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 const GLfloat *value)
 {
@@ -7725,7 +7739,7 @@
 }
 
 void Context::programUniform4fv(ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 const GLfloat *value)
 {
@@ -7735,7 +7749,7 @@
 }
 
 void Context::programUniformMatrix2fv(ShaderProgramID program,
-                                      GLint location,
+                                      UniformLocation location,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
@@ -7746,7 +7760,7 @@
 }
 
 void Context::programUniformMatrix3fv(ShaderProgramID program,
-                                      GLint location,
+                                      UniformLocation location,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
@@ -7757,7 +7771,7 @@
 }
 
 void Context::programUniformMatrix4fv(ShaderProgramID program,
-                                      GLint location,
+                                      UniformLocation location,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
@@ -7768,7 +7782,7 @@
 }
 
 void Context::programUniformMatrix2x3fv(ShaderProgramID program,
-                                        GLint location,
+                                        UniformLocation location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLfloat *value)
@@ -7779,7 +7793,7 @@
 }
 
 void Context::programUniformMatrix3x2fv(ShaderProgramID program,
-                                        GLint location,
+                                        UniformLocation location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLfloat *value)
@@ -7790,7 +7804,7 @@
 }
 
 void Context::programUniformMatrix2x4fv(ShaderProgramID program,
-                                        GLint location,
+                                        UniformLocation location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLfloat *value)
@@ -7801,7 +7815,7 @@
 }
 
 void Context::programUniformMatrix4x2fv(ShaderProgramID program,
-                                        GLint location,
+                                        UniformLocation location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLfloat *value)
@@ -7812,7 +7826,7 @@
 }
 
 void Context::programUniformMatrix3x4fv(ShaderProgramID program,
-                                        GLint location,
+                                        UniformLocation location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLfloat *value)
@@ -7823,7 +7837,7 @@
 }
 
 void Context::programUniformMatrix4x3fv(ShaderProgramID program,
-                                        GLint location,
+                                        UniformLocation location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLfloat *value)
@@ -7920,7 +7934,7 @@
 }
 
 void Context::getnUniformfv(ShaderProgramID program,
-                            GLint location,
+                            UniformLocation location,
                             GLsizei bufSize,
                             GLfloat *params)
 {
@@ -7931,7 +7945,7 @@
 }
 
 void Context::getnUniformfvRobust(ShaderProgramID program,
-                                  GLint location,
+                                  UniformLocation location,
                                   GLsizei bufSize,
                                   GLsizei *length,
                                   GLfloat *params)
@@ -7939,7 +7953,10 @@
     UNIMPLEMENTED();
 }
 
-void Context::getnUniformiv(ShaderProgramID program, GLint location, GLsizei bufSize, GLint *params)
+void Context::getnUniformiv(ShaderProgramID program,
+                            UniformLocation location,
+                            GLsizei bufSize,
+                            GLint *params)
 {
     Program *programObject = getProgramResolveLink(program);
     ASSERT(programObject);
@@ -7948,7 +7965,7 @@
 }
 
 void Context::getnUniformivRobust(ShaderProgramID program,
-                                  GLint location,
+                                  UniformLocation location,
                                   GLsizei bufSize,
                                   GLsizei *length,
                                   GLint *params)
@@ -7957,7 +7974,7 @@
 }
 
 void Context::getnUniformuivRobust(ShaderProgramID program,
-                                   GLint location,
+                                   UniformLocation location,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLuint *params)
diff --git a/src/libANGLE/Context.h b/src/libANGLE/Context.h
index e2a372f..d699687 100644
--- a/src/libANGLE/Context.h
+++ b/src/libANGLE/Context.h
@@ -638,7 +638,10 @@
     gl::LabeledObject *getLabeledObject(GLenum identifier, GLuint name) const;
     gl::LabeledObject *getLabeledObjectFromPtr(const void *ptr) const;
 
-    void setUniform1iImpl(Program *program, GLint location, GLsizei count, const GLint *v);
+    void setUniform1iImpl(Program *program,
+                          UniformLocation location,
+                          GLsizei count,
+                          const GLint *v);
 
     State mState;
     bool mShared;
diff --git a/src/libANGLE/Context_gl.cpp b/src/libANGLE/Context_gl.cpp
index 48067c8..1dc5099 100644
--- a/src/libANGLE/Context_gl.cpp
+++ b/src/libANGLE/Context_gl.cpp
@@ -2283,7 +2283,7 @@
     UNIMPLEMENTED();
 }
 
-void Context::getUniformdv(ShaderProgramID program, GLint location, GLdouble *params)
+void Context::getUniformdv(ShaderProgramID program, UniformLocation location, GLdouble *params)
 {
     UNIMPLEMENTED();
 }
@@ -2293,47 +2293,47 @@
     UNIMPLEMENTED();
 }
 
-void Context::uniform1d(GLint location, GLdouble x)
+void Context::uniform1d(UniformLocation location, GLdouble x)
 {
     UNIMPLEMENTED();
 }
 
-void Context::uniform1dv(GLint location, GLsizei count, const GLdouble *value)
+void Context::uniform1dv(UniformLocation location, GLsizei count, const GLdouble *value)
 {
     UNIMPLEMENTED();
 }
 
-void Context::uniform2d(GLint location, GLdouble x, GLdouble y)
+void Context::uniform2d(UniformLocation location, GLdouble x, GLdouble y)
 {
     UNIMPLEMENTED();
 }
 
-void Context::uniform2dv(GLint location, GLsizei count, const GLdouble *value)
+void Context::uniform2dv(UniformLocation location, GLsizei count, const GLdouble *value)
 {
     UNIMPLEMENTED();
 }
 
-void Context::uniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
+void Context::uniform3d(UniformLocation location, GLdouble x, GLdouble y, GLdouble z)
 {
     UNIMPLEMENTED();
 }
 
-void Context::uniform3dv(GLint location, GLsizei count, const GLdouble *value)
+void Context::uniform3dv(UniformLocation location, GLsizei count, const GLdouble *value)
 {
     UNIMPLEMENTED();
 }
 
-void Context::uniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+void Context::uniform4d(UniformLocation location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
     UNIMPLEMENTED();
 }
 
-void Context::uniform4dv(GLint location, GLsizei count, const GLdouble *value)
+void Context::uniform4dv(UniformLocation location, GLsizei count, const GLdouble *value)
 {
     UNIMPLEMENTED();
 }
 
-void Context::uniformMatrix2dv(GLint location,
+void Context::uniformMatrix2dv(UniformLocation location,
                                GLsizei count,
                                GLboolean transpose,
                                const GLdouble *value)
@@ -2341,7 +2341,7 @@
     UNIMPLEMENTED();
 }
 
-void Context::uniformMatrix2x3dv(GLint location,
+void Context::uniformMatrix2x3dv(UniformLocation location,
                                  GLsizei count,
                                  GLboolean transpose,
                                  const GLdouble *value)
@@ -2349,7 +2349,7 @@
     UNIMPLEMENTED();
 }
 
-void Context::uniformMatrix2x4dv(GLint location,
+void Context::uniformMatrix2x4dv(UniformLocation location,
                                  GLsizei count,
                                  GLboolean transpose,
                                  const GLdouble *value)
@@ -2357,7 +2357,7 @@
     UNIMPLEMENTED();
 }
 
-void Context::uniformMatrix3dv(GLint location,
+void Context::uniformMatrix3dv(UniformLocation location,
                                GLsizei count,
                                GLboolean transpose,
                                const GLdouble *value)
@@ -2365,7 +2365,7 @@
     UNIMPLEMENTED();
 }
 
-void Context::uniformMatrix3x2dv(GLint location,
+void Context::uniformMatrix3x2dv(UniformLocation location,
                                  GLsizei count,
                                  GLboolean transpose,
                                  const GLdouble *value)
@@ -2373,7 +2373,7 @@
     UNIMPLEMENTED();
 }
 
-void Context::uniformMatrix3x4dv(GLint location,
+void Context::uniformMatrix3x4dv(UniformLocation location,
                                  GLsizei count,
                                  GLboolean transpose,
                                  const GLdouble *value)
@@ -2381,7 +2381,7 @@
     UNIMPLEMENTED();
 }
 
-void Context::uniformMatrix4dv(GLint location,
+void Context::uniformMatrix4dv(UniformLocation location,
                                GLsizei count,
                                GLboolean transpose,
                                const GLdouble *value)
@@ -2389,7 +2389,7 @@
     UNIMPLEMENTED();
 }
 
-void Context::uniformMatrix4x2dv(GLint location,
+void Context::uniformMatrix4x2dv(UniformLocation location,
                                  GLsizei count,
                                  GLboolean transpose,
                                  const GLdouble *value)
@@ -2397,7 +2397,7 @@
     UNIMPLEMENTED();
 }
 
-void Context::uniformMatrix4x3dv(GLint location,
+void Context::uniformMatrix4x3dv(UniformLocation location,
                                  GLsizei count,
                                  GLboolean transpose,
                                  const GLdouble *value)
@@ -2435,26 +2435,29 @@
     UNIMPLEMENTED();
 }
 
-void Context::programUniform1d(ShaderProgramID program, GLint location, GLdouble v0)
+void Context::programUniform1d(ShaderProgramID program, UniformLocation location, GLdouble v0)
 {
     UNIMPLEMENTED();
 }
 
 void Context::programUniform1dv(ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 const GLdouble *value)
 {
     UNIMPLEMENTED();
 }
 
-void Context::programUniform2d(ShaderProgramID program, GLint location, GLdouble v0, GLdouble v1)
+void Context::programUniform2d(ShaderProgramID program,
+                               UniformLocation location,
+                               GLdouble v0,
+                               GLdouble v1)
 {
     UNIMPLEMENTED();
 }
 
 void Context::programUniform2dv(ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 const GLdouble *value)
 {
@@ -2462,7 +2465,7 @@
 }
 
 void Context::programUniform3d(ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLdouble v0,
                                GLdouble v1,
                                GLdouble v2)
@@ -2471,7 +2474,7 @@
 }
 
 void Context::programUniform3dv(ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 const GLdouble *value)
 {
@@ -2479,7 +2482,7 @@
 }
 
 void Context::programUniform4d(ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLdouble v0,
                                GLdouble v1,
                                GLdouble v2,
@@ -2489,7 +2492,7 @@
 }
 
 void Context::programUniform4dv(ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 const GLdouble *value)
 {
@@ -2497,7 +2500,7 @@
 }
 
 void Context::programUniformMatrix2dv(ShaderProgramID program,
-                                      GLint location,
+                                      UniformLocation location,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLdouble *value)
@@ -2506,7 +2509,7 @@
 }
 
 void Context::programUniformMatrix2x3dv(ShaderProgramID program,
-                                        GLint location,
+                                        UniformLocation location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLdouble *value)
@@ -2515,7 +2518,7 @@
 }
 
 void Context::programUniformMatrix2x4dv(ShaderProgramID program,
-                                        GLint location,
+                                        UniformLocation location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLdouble *value)
@@ -2524,7 +2527,7 @@
 }
 
 void Context::programUniformMatrix3dv(ShaderProgramID program,
-                                      GLint location,
+                                      UniformLocation location,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLdouble *value)
@@ -2533,7 +2536,7 @@
 }
 
 void Context::programUniformMatrix3x2dv(ShaderProgramID program,
-                                        GLint location,
+                                        UniformLocation location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLdouble *value)
@@ -2542,7 +2545,7 @@
 }
 
 void Context::programUniformMatrix3x4dv(ShaderProgramID program,
-                                        GLint location,
+                                        UniformLocation location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLdouble *value)
@@ -2551,7 +2554,7 @@
 }
 
 void Context::programUniformMatrix4dv(ShaderProgramID program,
-                                      GLint location,
+                                      UniformLocation location,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLdouble *value)
@@ -2560,7 +2563,7 @@
 }
 
 void Context::programUniformMatrix4x2dv(ShaderProgramID program,
-                                        GLint location,
+                                        UniformLocation location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLdouble *value)
@@ -2569,7 +2572,7 @@
 }
 
 void Context::programUniformMatrix4x3dv(ShaderProgramID program,
-                                        GLint location,
+                                        UniformLocation location,
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLdouble *value)
@@ -3368,7 +3371,7 @@
 }
 
 void Context::getnUniformdv(ShaderProgramID program,
-                            GLint location,
+                            UniformLocation location,
                             GLsizei bufSize,
                             GLdouble *params)
 {
@@ -3376,7 +3379,7 @@
 }
 
 void Context::getnUniformuiv(ShaderProgramID program,
-                             GLint location,
+                             UniformLocation location,
                              GLsizei bufSize,
                              GLuint *params)
 {
diff --git a/src/libANGLE/Context_gl_4_0_autogen.h b/src/libANGLE/Context_gl_4_0_autogen.h
index 12bb94d..80fa17b 100644
--- a/src/libANGLE/Context_gl_4_0_autogen.h
+++ b/src/libANGLE/Context_gl_4_0_autogen.h
@@ -30,33 +30,35 @@
     GLint getSubroutineUniformLocation(ShaderProgramID programPacked, GLenum shadertype,         \
                                        const GLchar *name);                                      \
     void getUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params);             \
-    void getUniformdv(ShaderProgramID programPacked, GLint location, GLdouble *params);          \
+    void getUniformdv(ShaderProgramID programPacked, UniformLocation locationPacked,             \
+                      GLdouble *params);                                                         \
     void patchParameterfv(GLenum pname, const GLfloat *values);                                  \
-    void uniform1d(GLint location, GLdouble x);                                                  \
-    void uniform1dv(GLint location, GLsizei count, const GLdouble *value);                       \
-    void uniform2d(GLint location, GLdouble x, GLdouble y);                                      \
-    void uniform2dv(GLint location, GLsizei count, const GLdouble *value);                       \
-    void uniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z);                          \
-    void uniform3dv(GLint location, GLsizei count, const GLdouble *value);                       \
-    void uniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);              \
-    void uniform4dv(GLint location, GLsizei count, const GLdouble *value);                       \
-    void uniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose,                    \
+    void uniform1d(UniformLocation locationPacked, GLdouble x);                                  \
+    void uniform1dv(UniformLocation locationPacked, GLsizei count, const GLdouble *value);       \
+    void uniform2d(UniformLocation locationPacked, GLdouble x, GLdouble y);                      \
+    void uniform2dv(UniformLocation locationPacked, GLsizei count, const GLdouble *value);       \
+    void uniform3d(UniformLocation locationPacked, GLdouble x, GLdouble y, GLdouble z);          \
+    void uniform3dv(UniformLocation locationPacked, GLsizei count, const GLdouble *value);       \
+    void uniform4d(UniformLocation locationPacked, GLdouble x, GLdouble y, GLdouble z,           \
+                   GLdouble w);                                                                  \
+    void uniform4dv(UniformLocation locationPacked, GLsizei count, const GLdouble *value);       \
+    void uniformMatrix2dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,    \
                           const GLdouble *value);                                                \
-    void uniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose,                  \
+    void uniformMatrix2x3dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,  \
                             const GLdouble *value);                                              \
-    void uniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose,                  \
+    void uniformMatrix2x4dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,  \
                             const GLdouble *value);                                              \
-    void uniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose,                    \
+    void uniformMatrix3dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,    \
                           const GLdouble *value);                                                \
-    void uniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose,                  \
+    void uniformMatrix3x2dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,  \
                             const GLdouble *value);                                              \
-    void uniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose,                  \
+    void uniformMatrix3x4dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,  \
                             const GLdouble *value);                                              \
-    void uniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose,                    \
+    void uniformMatrix4dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,    \
                           const GLdouble *value);                                                \
-    void uniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose,                  \
+    void uniformMatrix4x2dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,  \
                             const GLdouble *value);                                              \
-    void uniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose,                  \
+    void uniformMatrix4x3dv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,  \
                             const GLdouble *value);                                              \
     void uniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices);
 
diff --git a/src/libANGLE/Context_gl_4_1_autogen.h b/src/libANGLE/Context_gl_4_1_autogen.h
index 1f9940f..0cca1c0 100644
--- a/src/libANGLE/Context_gl_4_1_autogen.h
+++ b/src/libANGLE/Context_gl_4_1_autogen.h
@@ -10,60 +10,61 @@
 #ifndef ANGLE_CONTEXT_GL_4_1_AUTOGEN_H_
 #define ANGLE_CONTEXT_GL_4_1_AUTOGEN_H_
 
-#define ANGLE_GL_4_1_CONTEXT_API                                                                   \
-    void depthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v);                         \
-    void depthRangeIndexed(GLuint index, GLdouble n, GLdouble f);                                  \
-    void getDoublei_v(GLenum target, GLuint index, GLdouble *data);                                \
-    void getFloati_v(GLenum target, GLuint index, GLfloat *data);                                  \
-    void getVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params);                         \
-    void programUniform1d(ShaderProgramID programPacked, GLint location, GLdouble v0);             \
-    void programUniform1dv(ShaderProgramID programPacked, GLint location, GLsizei count,           \
-                           const GLdouble *value);                                                 \
-    void programUniform2d(ShaderProgramID programPacked, GLint location, GLdouble v0,              \
-                          GLdouble v1);                                                            \
-    void programUniform2dv(ShaderProgramID programPacked, GLint location, GLsizei count,           \
-                           const GLdouble *value);                                                 \
-    void programUniform3d(ShaderProgramID programPacked, GLint location, GLdouble v0, GLdouble v1, \
-                          GLdouble v2);                                                            \
-    void programUniform3dv(ShaderProgramID programPacked, GLint location, GLsizei count,           \
-                           const GLdouble *value);                                                 \
-    void programUniform4d(ShaderProgramID programPacked, GLint location, GLdouble v0, GLdouble v1, \
-                          GLdouble v2, GLdouble v3);                                               \
-    void programUniform4dv(ShaderProgramID programPacked, GLint location, GLsizei count,           \
-                           const GLdouble *value);                                                 \
-    void programUniformMatrix2dv(ShaderProgramID programPacked, GLint location, GLsizei count,     \
-                                 GLboolean transpose, const GLdouble *value);                      \
-    void programUniformMatrix2x3dv(ShaderProgramID programPacked, GLint location, GLsizei count,   \
-                                   GLboolean transpose, const GLdouble *value);                    \
-    void programUniformMatrix2x4dv(ShaderProgramID programPacked, GLint location, GLsizei count,   \
-                                   GLboolean transpose, const GLdouble *value);                    \
-    void programUniformMatrix3dv(ShaderProgramID programPacked, GLint location, GLsizei count,     \
-                                 GLboolean transpose, const GLdouble *value);                      \
-    void programUniformMatrix3x2dv(ShaderProgramID programPacked, GLint location, GLsizei count,   \
-                                   GLboolean transpose, const GLdouble *value);                    \
-    void programUniformMatrix3x4dv(ShaderProgramID programPacked, GLint location, GLsizei count,   \
-                                   GLboolean transpose, const GLdouble *value);                    \
-    void programUniformMatrix4dv(ShaderProgramID programPacked, GLint location, GLsizei count,     \
-                                 GLboolean transpose, const GLdouble *value);                      \
-    void programUniformMatrix4x2dv(ShaderProgramID programPacked, GLint location, GLsizei count,   \
-                                   GLboolean transpose, const GLdouble *value);                    \
-    void programUniformMatrix4x3dv(ShaderProgramID programPacked, GLint location, GLsizei count,   \
-                                   GLboolean transpose, const GLdouble *value);                    \
-    void scissorArrayv(GLuint first, GLsizei count, const GLint *v);                               \
-    void scissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);    \
-    void scissorIndexedv(GLuint index, const GLint *v);                                            \
-    void vertexAttribL1d(GLuint index, GLdouble x);                                                \
-    void vertexAttribL1dv(GLuint index, const GLdouble *v);                                        \
-    void vertexAttribL2d(GLuint index, GLdouble x, GLdouble y);                                    \
-    void vertexAttribL2dv(GLuint index, const GLdouble *v);                                        \
-    void vertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);                        \
-    void vertexAttribL3dv(GLuint index, const GLdouble *v);                                        \
-    void vertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);            \
-    void vertexAttribL4dv(GLuint index, const GLdouble *v);                                        \
-    void vertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride,               \
-                              const void *pointer);                                                \
-    void viewportArrayv(GLuint first, GLsizei count, const GLfloat *v);                            \
-    void viewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);               \
+#define ANGLE_GL_4_1_CONTEXT_API                                                                  \
+    void depthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v);                        \
+    void depthRangeIndexed(GLuint index, GLdouble n, GLdouble f);                                 \
+    void getDoublei_v(GLenum target, GLuint index, GLdouble *data);                               \
+    void getFloati_v(GLenum target, GLuint index, GLfloat *data);                                 \
+    void getVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params);                        \
+    void programUniform1d(ShaderProgramID programPacked, UniformLocation locationPacked,          \
+                          GLdouble v0);                                                           \
+    void programUniform1dv(ShaderProgramID programPacked, UniformLocation locationPacked,         \
+                           GLsizei count, const GLdouble *value);                                 \
+    void programUniform2d(ShaderProgramID programPacked, UniformLocation locationPacked,          \
+                          GLdouble v0, GLdouble v1);                                              \
+    void programUniform2dv(ShaderProgramID programPacked, UniformLocation locationPacked,         \
+                           GLsizei count, const GLdouble *value);                                 \
+    void programUniform3d(ShaderProgramID programPacked, UniformLocation locationPacked,          \
+                          GLdouble v0, GLdouble v1, GLdouble v2);                                 \
+    void programUniform3dv(ShaderProgramID programPacked, UniformLocation locationPacked,         \
+                           GLsizei count, const GLdouble *value);                                 \
+    void programUniform4d(ShaderProgramID programPacked, UniformLocation locationPacked,          \
+                          GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);                    \
+    void programUniform4dv(ShaderProgramID programPacked, UniformLocation locationPacked,         \
+                           GLsizei count, const GLdouble *value);                                 \
+    void programUniformMatrix2dv(ShaderProgramID programPacked, UniformLocation locationPacked,   \
+                                 GLsizei count, GLboolean transpose, const GLdouble *value);      \
+    void programUniformMatrix2x3dv(ShaderProgramID programPacked, UniformLocation locationPacked, \
+                                   GLsizei count, GLboolean transpose, const GLdouble *value);    \
+    void programUniformMatrix2x4dv(ShaderProgramID programPacked, UniformLocation locationPacked, \
+                                   GLsizei count, GLboolean transpose, const GLdouble *value);    \
+    void programUniformMatrix3dv(ShaderProgramID programPacked, UniformLocation locationPacked,   \
+                                 GLsizei count, GLboolean transpose, const GLdouble *value);      \
+    void programUniformMatrix3x2dv(ShaderProgramID programPacked, UniformLocation locationPacked, \
+                                   GLsizei count, GLboolean transpose, const GLdouble *value);    \
+    void programUniformMatrix3x4dv(ShaderProgramID programPacked, UniformLocation locationPacked, \
+                                   GLsizei count, GLboolean transpose, const GLdouble *value);    \
+    void programUniformMatrix4dv(ShaderProgramID programPacked, UniformLocation locationPacked,   \
+                                 GLsizei count, GLboolean transpose, const GLdouble *value);      \
+    void programUniformMatrix4x2dv(ShaderProgramID programPacked, UniformLocation locationPacked, \
+                                   GLsizei count, GLboolean transpose, const GLdouble *value);    \
+    void programUniformMatrix4x3dv(ShaderProgramID programPacked, UniformLocation locationPacked, \
+                                   GLsizei count, GLboolean transpose, const GLdouble *value);    \
+    void scissorArrayv(GLuint first, GLsizei count, const GLint *v);                              \
+    void scissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);   \
+    void scissorIndexedv(GLuint index, const GLint *v);                                           \
+    void vertexAttribL1d(GLuint index, GLdouble x);                                               \
+    void vertexAttribL1dv(GLuint index, const GLdouble *v);                                       \
+    void vertexAttribL2d(GLuint index, GLdouble x, GLdouble y);                                   \
+    void vertexAttribL2dv(GLuint index, const GLdouble *v);                                       \
+    void vertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);                       \
+    void vertexAttribL3dv(GLuint index, const GLdouble *v);                                       \
+    void vertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);           \
+    void vertexAttribL4dv(GLuint index, const GLdouble *v);                                       \
+    void vertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride,              \
+                              const void *pointer);                                               \
+    void viewportArrayv(GLuint first, GLsizei count, const GLfloat *v);                           \
+    void viewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);              \
     void viewportIndexedfv(GLuint index, const GLfloat *v);
 
 #endif  // ANGLE_CONTEXT_API_4_1_AUTOGEN_H_
diff --git a/src/libANGLE/Context_gl_4_5_autogen.h b/src/libANGLE/Context_gl_4_5_autogen.h
index d8c2b78..a582c43 100644
--- a/src/libANGLE/Context_gl_4_5_autogen.h
+++ b/src/libANGLE/Context_gl_4_5_autogen.h
@@ -122,8 +122,8 @@
                              void *row, GLsizei columnBufSize, void *column, void *span);          \
     void getnTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize,     \
                       void *pixels);                                                               \
-    void getnUniformdv(ShaderProgramID programPacked, GLint location, GLsizei bufSize,             \
-                       GLdouble *params);                                                          \
+    void getnUniformdv(ShaderProgramID programPacked, UniformLocation locationPacked,              \
+                       GLsizei bufSize, GLdouble *params);                                         \
     void invalidateNamedFramebufferData(FramebufferID framebufferPacked, GLsizei numAttachments,   \
                                         const GLenum *attachments);                                \
     void invalidateNamedFramebufferSubData(FramebufferID framebufferPacked,                        \
diff --git a/src/libANGLE/Context_gles_2_0_autogen.h b/src/libANGLE/Context_gles_2_0_autogen.h
index 49cc31d..5336adb 100644
--- a/src/libANGLE/Context_gles_2_0_autogen.h
+++ b/src/libANGLE/Context_gles_2_0_autogen.h
@@ -106,8 +106,10 @@
     void getTexParameterfv(TextureType targetPacked, GLenum pname, GLfloat *params);               \
     void getTexParameteriv(TextureType targetPacked, GLenum pname, GLint *params);                 \
     GLint getUniformLocation(ShaderProgramID programPacked, const GLchar *name);                   \
-    void getUniformfv(ShaderProgramID programPacked, GLint location, GLfloat *params);             \
-    void getUniformiv(ShaderProgramID programPacked, GLint location, GLint *params);               \
+    void getUniformfv(ShaderProgramID programPacked, UniformLocation locationPacked,               \
+                      GLfloat *params);                                                            \
+    void getUniformiv(ShaderProgramID programPacked, UniformLocation locationPacked,               \
+                      GLint *params);                                                              \
     void getVertexAttribPointerv(GLuint index, GLenum pname, void **pointer);                      \
     void getVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);                           \
     void getVertexAttribiv(GLuint index, GLenum pname, GLint *params);                             \
@@ -148,27 +150,28 @@
     void texSubImage2D(TextureTarget targetPacked, GLint level, GLint xoffset, GLint yoffset,      \
                        GLsizei width, GLsizei height, GLenum format, GLenum type,                  \
                        const void *pixels);                                                        \
-    void uniform1f(GLint location, GLfloat v0);                                                    \
-    void uniform1fv(GLint location, GLsizei count, const GLfloat *value);                          \
-    void uniform1i(GLint location, GLint v0);                                                      \
-    void uniform1iv(GLint location, GLsizei count, const GLint *value);                            \
-    void uniform2f(GLint location, GLfloat v0, GLfloat v1);                                        \
-    void uniform2fv(GLint location, GLsizei count, const GLfloat *value);                          \
-    void uniform2i(GLint location, GLint v0, GLint v1);                                            \
-    void uniform2iv(GLint location, GLsizei count, const GLint *value);                            \
-    void uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);                            \
-    void uniform3fv(GLint location, GLsizei count, const GLfloat *value);                          \
-    void uniform3i(GLint location, GLint v0, GLint v1, GLint v2);                                  \
-    void uniform3iv(GLint location, GLsizei count, const GLint *value);                            \
-    void uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);                \
-    void uniform4fv(GLint location, GLsizei count, const GLfloat *value);                          \
-    void uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);                        \
-    void uniform4iv(GLint location, GLsizei count, const GLint *value);                            \
-    void uniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose,                      \
+    void uniform1f(UniformLocation locationPacked, GLfloat v0);                                    \
+    void uniform1fv(UniformLocation locationPacked, GLsizei count, const GLfloat *value);          \
+    void uniform1i(UniformLocation locationPacked, GLint v0);                                      \
+    void uniform1iv(UniformLocation locationPacked, GLsizei count, const GLint *value);            \
+    void uniform2f(UniformLocation locationPacked, GLfloat v0, GLfloat v1);                        \
+    void uniform2fv(UniformLocation locationPacked, GLsizei count, const GLfloat *value);          \
+    void uniform2i(UniformLocation locationPacked, GLint v0, GLint v1);                            \
+    void uniform2iv(UniformLocation locationPacked, GLsizei count, const GLint *value);            \
+    void uniform3f(UniformLocation locationPacked, GLfloat v0, GLfloat v1, GLfloat v2);            \
+    void uniform3fv(UniformLocation locationPacked, GLsizei count, const GLfloat *value);          \
+    void uniform3i(UniformLocation locationPacked, GLint v0, GLint v1, GLint v2);                  \
+    void uniform3iv(UniformLocation locationPacked, GLsizei count, const GLint *value);            \
+    void uniform4f(UniformLocation locationPacked, GLfloat v0, GLfloat v1, GLfloat v2,             \
+                   GLfloat v3);                                                                    \
+    void uniform4fv(UniformLocation locationPacked, GLsizei count, const GLfloat *value);          \
+    void uniform4i(UniformLocation locationPacked, GLint v0, GLint v1, GLint v2, GLint v3);        \
+    void uniform4iv(UniformLocation locationPacked, GLsizei count, const GLint *value);            \
+    void uniformMatrix2fv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,      \
                           const GLfloat *value);                                                   \
-    void uniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose,                      \
+    void uniformMatrix3fv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,      \
                           const GLfloat *value);                                                   \
-    void uniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose,                      \
+    void uniformMatrix4fv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,      \
                           const GLfloat *value);                                                   \
     void useProgram(ShaderProgramID programPacked);                                                \
     void validateProgram(ShaderProgramID programPacked);                                           \
diff --git a/src/libANGLE/Context_gles_3_0_autogen.h b/src/libANGLE/Context_gles_3_0_autogen.h
index 3db9b17..cf110bf 100644
--- a/src/libANGLE/Context_gles_3_0_autogen.h
+++ b/src/libANGLE/Context_gles_3_0_autogen.h
@@ -87,7 +87,8 @@
     GLuint getUniformBlockIndex(ShaderProgramID programPacked, const GLchar *uniformBlockName);    \
     void getUniformIndices(ShaderProgramID programPacked, GLsizei uniformCount,                    \
                            const GLchar *const *uniformNames, GLuint *uniformIndices);             \
-    void getUniformuiv(ShaderProgramID programPacked, GLint location, GLuint *params);             \
+    void getUniformuiv(ShaderProgramID programPacked, UniformLocation locationPacked,              \
+                       GLuint *params);                                                            \
     void getVertexAttribIiv(GLuint index, GLenum pname, GLint *params);                            \
     void getVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);                          \
     void invalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments);  \
@@ -125,27 +126,27 @@
                        GLenum type, const void *pixels);                                           \
     void transformFeedbackVaryings(ShaderProgramID programPacked, GLsizei count,                   \
                                    const GLchar *const *varyings, GLenum bufferMode);              \
-    void uniform1ui(GLint location, GLuint v0);                                                    \
-    void uniform1uiv(GLint location, GLsizei count, const GLuint *value);                          \
-    void uniform2ui(GLint location, GLuint v0, GLuint v1);                                         \
-    void uniform2uiv(GLint location, GLsizei count, const GLuint *value);                          \
-    void uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);                              \
-    void uniform3uiv(GLint location, GLsizei count, const GLuint *value);                          \
-    void uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);                   \
-    void uniform4uiv(GLint location, GLsizei count, const GLuint *value);                          \
+    void uniform1ui(UniformLocation locationPacked, GLuint v0);                                    \
+    void uniform1uiv(UniformLocation locationPacked, GLsizei count, const GLuint *value);          \
+    void uniform2ui(UniformLocation locationPacked, GLuint v0, GLuint v1);                         \
+    void uniform2uiv(UniformLocation locationPacked, GLsizei count, const GLuint *value);          \
+    void uniform3ui(UniformLocation locationPacked, GLuint v0, GLuint v1, GLuint v2);              \
+    void uniform3uiv(UniformLocation locationPacked, GLsizei count, const GLuint *value);          \
+    void uniform4ui(UniformLocation locationPacked, GLuint v0, GLuint v1, GLuint v2, GLuint v3);   \
+    void uniform4uiv(UniformLocation locationPacked, GLsizei count, const GLuint *value);          \
     void uniformBlockBinding(ShaderProgramID programPacked, GLuint uniformBlockIndex,              \
                              GLuint uniformBlockBinding);                                          \
-    void uniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,                    \
+    void uniformMatrix2x3fv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,    \
                             const GLfloat *value);                                                 \
-    void uniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,                    \
+    void uniformMatrix2x4fv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,    \
                             const GLfloat *value);                                                 \
-    void uniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,                    \
+    void uniformMatrix3x2fv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,    \
                             const GLfloat *value);                                                 \
-    void uniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,                    \
+    void uniformMatrix3x4fv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,    \
                             const GLfloat *value);                                                 \
-    void uniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,                    \
+    void uniformMatrix4x2fv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,    \
                             const GLfloat *value);                                                 \
-    void uniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,                    \
+    void uniformMatrix4x3fv(UniformLocation locationPacked, GLsizei count, GLboolean transpose,    \
                             const GLfloat *value);                                                 \
     GLboolean unmapBuffer(BufferBinding targetPacked);                                             \
     void vertexAttribDivisor(GLuint index, GLuint divisor);                                        \
diff --git a/src/libANGLE/Context_gles_3_1_autogen.h b/src/libANGLE/Context_gles_3_1_autogen.h
index 53130ea..3f6ede4 100644
--- a/src/libANGLE/Context_gles_3_1_autogen.h
+++ b/src/libANGLE/Context_gles_3_1_autogen.h
@@ -51,66 +51,72 @@
     GLboolean isProgramPipeline(ProgramPipelineID pipelinePacked) const;                           \
     void memoryBarrier(GLbitfield barriers);                                                       \
     void memoryBarrierByRegion(GLbitfield barriers);                                               \
-    void programUniform1f(ShaderProgramID programPacked, GLint location, GLfloat v0);              \
-    void programUniform1fv(ShaderProgramID programPacked, GLint location, GLsizei count,           \
-                           const GLfloat *value);                                                  \
-    void programUniform1i(ShaderProgramID programPacked, GLint location, GLint v0);                \
-    void programUniform1iv(ShaderProgramID programPacked, GLint location, GLsizei count,           \
-                           const GLint *value);                                                    \
-    void programUniform1ui(ShaderProgramID programPacked, GLint location, GLuint v0);              \
-    void programUniform1uiv(ShaderProgramID programPacked, GLint location, GLsizei count,          \
-                            const GLuint *value);                                                  \
-    void programUniform2f(ShaderProgramID programPacked, GLint location, GLfloat v0, GLfloat v1);  \
-    void programUniform2fv(ShaderProgramID programPacked, GLint location, GLsizei count,           \
-                           const GLfloat *value);                                                  \
-    void programUniform2i(ShaderProgramID programPacked, GLint location, GLint v0, GLint v1);      \
-    void programUniform2iv(ShaderProgramID programPacked, GLint location, GLsizei count,           \
-                           const GLint *value);                                                    \
-    void programUniform2ui(ShaderProgramID programPacked, GLint location, GLuint v0, GLuint v1);   \
-    void programUniform2uiv(ShaderProgramID programPacked, GLint location, GLsizei count,          \
-                            const GLuint *value);                                                  \
-    void programUniform3f(ShaderProgramID programPacked, GLint location, GLfloat v0, GLfloat v1,   \
-                          GLfloat v2);                                                             \
-    void programUniform3fv(ShaderProgramID programPacked, GLint location, GLsizei count,           \
-                           const GLfloat *value);                                                  \
-    void programUniform3i(ShaderProgramID programPacked, GLint location, GLint v0, GLint v1,       \
-                          GLint v2);                                                               \
-    void programUniform3iv(ShaderProgramID programPacked, GLint location, GLsizei count,           \
-                           const GLint *value);                                                    \
-    void programUniform3ui(ShaderProgramID programPacked, GLint location, GLuint v0, GLuint v1,    \
-                           GLuint v2);                                                             \
-    void programUniform3uiv(ShaderProgramID programPacked, GLint location, GLsizei count,          \
-                            const GLuint *value);                                                  \
-    void programUniform4f(ShaderProgramID programPacked, GLint location, GLfloat v0, GLfloat v1,   \
-                          GLfloat v2, GLfloat v3);                                                 \
-    void programUniform4fv(ShaderProgramID programPacked, GLint location, GLsizei count,           \
-                           const GLfloat *value);                                                  \
-    void programUniform4i(ShaderProgramID programPacked, GLint location, GLint v0, GLint v1,       \
-                          GLint v2, GLint v3);                                                     \
-    void programUniform4iv(ShaderProgramID programPacked, GLint location, GLsizei count,           \
-                           const GLint *value);                                                    \
-    void programUniform4ui(ShaderProgramID programPacked, GLint location, GLuint v0, GLuint v1,    \
-                           GLuint v2, GLuint v3);                                                  \
-    void programUniform4uiv(ShaderProgramID programPacked, GLint location, GLsizei count,          \
-                            const GLuint *value);                                                  \
-    void programUniformMatrix2fv(ShaderProgramID programPacked, GLint location, GLsizei count,     \
-                                 GLboolean transpose, const GLfloat *value);                       \
-    void programUniformMatrix2x3fv(ShaderProgramID programPacked, GLint location, GLsizei count,   \
-                                   GLboolean transpose, const GLfloat *value);                     \
-    void programUniformMatrix2x4fv(ShaderProgramID programPacked, GLint location, GLsizei count,   \
-                                   GLboolean transpose, const GLfloat *value);                     \
-    void programUniformMatrix3fv(ShaderProgramID programPacked, GLint location, GLsizei count,     \
-                                 GLboolean transpose, const GLfloat *value);                       \
-    void programUniformMatrix3x2fv(ShaderProgramID programPacked, GLint location, GLsizei count,   \
-                                   GLboolean transpose, const GLfloat *value);                     \
-    void programUniformMatrix3x4fv(ShaderProgramID programPacked, GLint location, GLsizei count,   \
-                                   GLboolean transpose, const GLfloat *value);                     \
-    void programUniformMatrix4fv(ShaderProgramID programPacked, GLint location, GLsizei count,     \
-                                 GLboolean transpose, const GLfloat *value);                       \
-    void programUniformMatrix4x2fv(ShaderProgramID programPacked, GLint location, GLsizei count,   \
-                                   GLboolean transpose, const GLfloat *value);                     \
-    void programUniformMatrix4x3fv(ShaderProgramID programPacked, GLint location, GLsizei count,   \
-                                   GLboolean transpose, const GLfloat *value);                     \
+    void programUniform1f(ShaderProgramID programPacked, UniformLocation locationPacked,           \
+                          GLfloat v0);                                                             \
+    void programUniform1fv(ShaderProgramID programPacked, UniformLocation locationPacked,          \
+                           GLsizei count, const GLfloat *value);                                   \
+    void programUniform1i(ShaderProgramID programPacked, UniformLocation locationPacked,           \
+                          GLint v0);                                                               \
+    void programUniform1iv(ShaderProgramID programPacked, UniformLocation locationPacked,          \
+                           GLsizei count, const GLint *value);                                     \
+    void programUniform1ui(ShaderProgramID programPacked, UniformLocation locationPacked,          \
+                           GLuint v0);                                                             \
+    void programUniform1uiv(ShaderProgramID programPacked, UniformLocation locationPacked,         \
+                            GLsizei count, const GLuint *value);                                   \
+    void programUniform2f(ShaderProgramID programPacked, UniformLocation locationPacked,           \
+                          GLfloat v0, GLfloat v1);                                                 \
+    void programUniform2fv(ShaderProgramID programPacked, UniformLocation locationPacked,          \
+                           GLsizei count, const GLfloat *value);                                   \
+    void programUniform2i(ShaderProgramID programPacked, UniformLocation locationPacked, GLint v0, \
+                          GLint v1);                                                               \
+    void programUniform2iv(ShaderProgramID programPacked, UniformLocation locationPacked,          \
+                           GLsizei count, const GLint *value);                                     \
+    void programUniform2ui(ShaderProgramID programPacked, UniformLocation locationPacked,          \
+                           GLuint v0, GLuint v1);                                                  \
+    void programUniform2uiv(ShaderProgramID programPacked, UniformLocation locationPacked,         \
+                            GLsizei count, const GLuint *value);                                   \
+    void programUniform3f(ShaderProgramID programPacked, UniformLocation locationPacked,           \
+                          GLfloat v0, GLfloat v1, GLfloat v2);                                     \
+    void programUniform3fv(ShaderProgramID programPacked, UniformLocation locationPacked,          \
+                           GLsizei count, const GLfloat *value);                                   \
+    void programUniform3i(ShaderProgramID programPacked, UniformLocation locationPacked, GLint v0, \
+                          GLint v1, GLint v2);                                                     \
+    void programUniform3iv(ShaderProgramID programPacked, UniformLocation locationPacked,          \
+                           GLsizei count, const GLint *value);                                     \
+    void programUniform3ui(ShaderProgramID programPacked, UniformLocation locationPacked,          \
+                           GLuint v0, GLuint v1, GLuint v2);                                       \
+    void programUniform3uiv(ShaderProgramID programPacked, UniformLocation locationPacked,         \
+                            GLsizei count, const GLuint *value);                                   \
+    void programUniform4f(ShaderProgramID programPacked, UniformLocation locationPacked,           \
+                          GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);                         \
+    void programUniform4fv(ShaderProgramID programPacked, UniformLocation locationPacked,          \
+                           GLsizei count, const GLfloat *value);                                   \
+    void programUniform4i(ShaderProgramID programPacked, UniformLocation locationPacked, GLint v0, \
+                          GLint v1, GLint v2, GLint v3);                                           \
+    void programUniform4iv(ShaderProgramID programPacked, UniformLocation locationPacked,          \
+                           GLsizei count, const GLint *value);                                     \
+    void programUniform4ui(ShaderProgramID programPacked, UniformLocation locationPacked,          \
+                           GLuint v0, GLuint v1, GLuint v2, GLuint v3);                            \
+    void programUniform4uiv(ShaderProgramID programPacked, UniformLocation locationPacked,         \
+                            GLsizei count, const GLuint *value);                                   \
+    void programUniformMatrix2fv(ShaderProgramID programPacked, UniformLocation locationPacked,    \
+                                 GLsizei count, GLboolean transpose, const GLfloat *value);        \
+    void programUniformMatrix2x3fv(ShaderProgramID programPacked, UniformLocation locationPacked,  \
+                                   GLsizei count, GLboolean transpose, const GLfloat *value);      \
+    void programUniformMatrix2x4fv(ShaderProgramID programPacked, UniformLocation locationPacked,  \
+                                   GLsizei count, GLboolean transpose, const GLfloat *value);      \
+    void programUniformMatrix3fv(ShaderProgramID programPacked, UniformLocation locationPacked,    \
+                                 GLsizei count, GLboolean transpose, const GLfloat *value);        \
+    void programUniformMatrix3x2fv(ShaderProgramID programPacked, UniformLocation locationPacked,  \
+                                   GLsizei count, GLboolean transpose, const GLfloat *value);      \
+    void programUniformMatrix3x4fv(ShaderProgramID programPacked, UniformLocation locationPacked,  \
+                                   GLsizei count, GLboolean transpose, const GLfloat *value);      \
+    void programUniformMatrix4fv(ShaderProgramID programPacked, UniformLocation locationPacked,    \
+                                 GLsizei count, GLboolean transpose, const GLfloat *value);        \
+    void programUniformMatrix4x2fv(ShaderProgramID programPacked, UniformLocation locationPacked,  \
+                                   GLsizei count, GLboolean transpose, const GLfloat *value);      \
+    void programUniformMatrix4x3fv(ShaderProgramID programPacked, UniformLocation locationPacked,  \
+                                   GLsizei count, GLboolean transpose, const GLfloat *value);      \
     void sampleMaski(GLuint maskNumber, GLbitfield mask);                                          \
     void texStorage2DMultisample(TextureType targetPacked, GLsizei samples, GLenum internalformat, \
                                  GLsizei width, GLsizei height, GLboolean fixedsamplelocations);   \
diff --git a/src/libANGLE/Context_gles_3_2_autogen.h b/src/libANGLE/Context_gles_3_2_autogen.h
index 455186d..f600d1a 100644
--- a/src/libANGLE/Context_gles_3_2_autogen.h
+++ b/src/libANGLE/Context_gles_3_2_autogen.h
@@ -52,12 +52,12 @@
     void getSamplerParameterIuiv(SamplerID samplerPacked, GLenum pname, GLuint *params);           \
     void getTexParameterIiv(TextureType targetPacked, GLenum pname, GLint *params);                \
     void getTexParameterIuiv(TextureType targetPacked, GLenum pname, GLuint *params);              \
-    void getnUniformfv(ShaderProgramID programPacked, GLint location, GLsizei bufSize,             \
-                       GLfloat *params);                                                           \
-    void getnUniformiv(ShaderProgramID programPacked, GLint location, GLsizei bufSize,             \
-                       GLint *params);                                                             \
-    void getnUniformuiv(ShaderProgramID programPacked, GLint location, GLsizei bufSize,            \
-                        GLuint *params);                                                           \
+    void getnUniformfv(ShaderProgramID programPacked, UniformLocation locationPacked,              \
+                       GLsizei bufSize, GLfloat *params);                                          \
+    void getnUniformiv(ShaderProgramID programPacked, UniformLocation locationPacked,              \
+                       GLsizei bufSize, GLint *params);                                            \
+    void getnUniformuiv(ShaderProgramID programPacked, UniformLocation locationPacked,             \
+                        GLsizei bufSize, GLuint *params);                                          \
     GLboolean isEnabledi(GLenum target, GLuint index) const;                                       \
     void minSampleShading(GLfloat value);                                                          \
     void objectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label);         \
diff --git a/src/libANGLE/Context_gles_ext_autogen.h b/src/libANGLE/Context_gles_ext_autogen.h
index eef879a..c918bf9 100644
--- a/src/libANGLE/Context_gles_ext_autogen.h
+++ b/src/libANGLE/Context_gles_ext_autogen.h
@@ -83,10 +83,10 @@
                                  GLsizei *length, GLfloat *params);                                \
     void getTexParameterivRobust(TextureType targetPacked, GLenum pname, GLsizei bufSize,          \
                                  GLsizei *length, GLint *params);                                  \
-    void getUniformfvRobust(ShaderProgramID programPacked, GLint location, GLsizei bufSize,        \
-                            GLsizei *length, GLfloat *params);                                     \
-    void getUniformivRobust(ShaderProgramID programPacked, GLint location, GLsizei bufSize,        \
-                            GLsizei *length, GLint *params);                                       \
+    void getUniformfvRobust(ShaderProgramID programPacked, UniformLocation locationPacked,         \
+                            GLsizei bufSize, GLsizei *length, GLfloat *params);                    \
+    void getUniformivRobust(ShaderProgramID programPacked, UniformLocation locationPacked,         \
+                            GLsizei bufSize, GLsizei *length, GLint *params);                      \
     void getVertexAttribfvRobust(GLuint index, GLenum pname, GLsizei bufSize, GLsizei *length,     \
                                  GLfloat *params);                                                 \
     void getVertexAttribivRobust(GLuint index, GLenum pname, GLsizei bufSize, GLsizei *length,     \
@@ -141,8 +141,8 @@
                                   GLint *params);                                                  \
     void getVertexAttribIuivRobust(GLuint index, GLenum pname, GLsizei bufSize, GLsizei *length,   \
                                    GLuint *params);                                                \
-    void getUniformuivRobust(ShaderProgramID programPacked, GLint location, GLsizei bufSize,       \
-                             GLsizei *length, GLuint *params);                                     \
+    void getUniformuivRobust(ShaderProgramID programPacked, UniformLocation locationPacked,        \
+                             GLsizei bufSize, GLsizei *length, GLuint *params);                    \
     void getActiveUniformBlockivRobust(ShaderProgramID programPacked, GLuint uniformBlockIndex,    \
                                        GLenum pname, GLsizei bufSize, GLsizei *length,             \
                                        GLint *params);                                             \
@@ -177,12 +177,12 @@
     void readnPixelsRobust(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,         \
                            GLenum type, GLsizei bufSize, GLsizei *length, GLsizei *columns,        \
                            GLsizei *rows, void *data);                                             \
-    void getnUniformfvRobust(ShaderProgramID programPacked, GLint location, GLsizei bufSize,       \
-                             GLsizei *length, GLfloat *params);                                    \
-    void getnUniformivRobust(ShaderProgramID programPacked, GLint location, GLsizei bufSize,       \
-                             GLsizei *length, GLint *params);                                      \
-    void getnUniformuivRobust(ShaderProgramID programPacked, GLint location, GLsizei bufSize,      \
-                              GLsizei *length, GLuint *params);                                    \
+    void getnUniformfvRobust(ShaderProgramID programPacked, UniformLocation locationPacked,        \
+                             GLsizei bufSize, GLsizei *length, GLfloat *params);                   \
+    void getnUniformivRobust(ShaderProgramID programPacked, UniformLocation locationPacked,        \
+                             GLsizei bufSize, GLsizei *length, GLint *params);                     \
+    void getnUniformuivRobust(ShaderProgramID programPacked, UniformLocation locationPacked,       \
+                              GLsizei bufSize, GLsizei *length, GLuint *params);                   \
     void texParameterIivRobust(TextureType targetPacked, GLenum pname, GLsizei bufSize,            \
                                const GLint *params);                                               \
     void texParameterIuivRobust(TextureType targetPacked, GLenum pname, GLsizei bufSize,           \
@@ -211,7 +211,8 @@
                             GLenum type);                                                          \
     void invalidateTexture(TextureType targetPacked);                                              \
     /* GL_CHROMIUM_bind_uniform_location */                                                        \
-    void bindUniformLocation(ShaderProgramID programPacked, GLint location, const GLchar *name);   \
+    void bindUniformLocation(ShaderProgramID programPacked, UniformLocation locationPacked,        \
+                             const GLchar *name);                                                  \
     /* GL_CHROMIUM_copy_compressed_texture */                                                      \
     void compressedCopyTexture(TextureID sourceIdPacked, TextureID destIdPacked);                  \
     /* GL_CHROMIUM_copy_texture */                                                                 \
diff --git a/src/libANGLE/FrameCapture.cpp b/src/libANGLE/FrameCapture.cpp
index 10a2458..fbedd60 100644
--- a/src/libANGLE/FrameCapture.cpp
+++ b/src/libANGLE/FrameCapture.cpp
@@ -2755,4 +2755,12 @@
 {
     os << "gVertexArrayMap[" << value.value << "]";
 }
+
+template <>
+void WriteParamValueToStream<ParamType::TUniformLocation>(std::ostream &os,
+                                                          gl::UniformLocation value)
+{
+    // TODO(jmadill): Uniform locations map. http://anglebug.com/4411
+    os << value.value;
+}
 }  // namespace angle
diff --git a/src/libANGLE/FrameCapture.h b/src/libANGLE/FrameCapture.h
index 52d8d70..1db6552 100644
--- a/src/libANGLE/FrameCapture.h
+++ b/src/libANGLE/FrameCapture.h
@@ -356,6 +356,10 @@
 template <>
 void WriteParamValueToStream<ParamType::TVertexArrayID>(std::ostream &os, gl::VertexArrayID value);
 
+template <>
+void WriteParamValueToStream<ParamType::TUniformLocation>(std::ostream &os,
+                                                          gl::UniformLocation value);
+
 // General fallback for any unspecific type.
 template <ParamType ParamT, typename T>
 void WriteParamValueToStream(std::ostream &os, T value)
diff --git a/src/libANGLE/GLES1Renderer.cpp b/src/libANGLE/GLES1Renderer.cpp
index 37025a5..d1b7533 100644
--- a/src/libANGLE/GLES1Renderer.cpp
+++ b/src/libANGLE/GLES1Renderer.cpp
@@ -761,80 +761,83 @@
     return angle::Result::Continue;
 }
 
-void GLES1Renderer::setUniform1i(Context *context, Program *programObject, GLint loc, GLint value)
+void GLES1Renderer::setUniform1i(Context *context,
+                                 Program *programObject,
+                                 UniformLocation location,
+                                 GLint value)
 {
-    if (loc == -1)
+    if (location.value == -1)
         return;
-    programObject->setUniform1iv(context, loc, 1, &value);
+    programObject->setUniform1iv(context, location, 1, &value);
 }
 
 void GLES1Renderer::setUniform1iv(Context *context,
                                   Program *programObject,
-                                  GLint loc,
+                                  UniformLocation location,
                                   GLint count,
                                   const GLint *value)
 {
-    if (loc == -1)
+    if (location.value == -1)
         return;
-    programObject->setUniform1iv(context, loc, count, value);
+    programObject->setUniform1iv(context, location, count, value);
 }
 
 void GLES1Renderer::setUniformMatrix4fv(Program *programObject,
-                                        GLint loc,
+                                        UniformLocation location,
                                         GLint count,
                                         GLboolean transpose,
                                         const GLfloat *value)
 {
-    if (loc == -1)
+    if (location.value == -1)
         return;
-    programObject->setUniformMatrix4fv(loc, count, transpose, value);
+    programObject->setUniformMatrix4fv(location, count, transpose, value);
 }
 
 void GLES1Renderer::setUniform4fv(Program *programObject,
-                                  GLint loc,
+                                  UniformLocation location,
                                   GLint count,
                                   const GLfloat *value)
 {
-    if (loc == -1)
+    if (location.value == -1)
         return;
-    programObject->setUniform4fv(loc, count, value);
+    programObject->setUniform4fv(location, count, value);
 }
 
 void GLES1Renderer::setUniform3fv(Program *programObject,
-                                  GLint loc,
+                                  UniformLocation location,
                                   GLint count,
                                   const GLfloat *value)
 {
-    if (loc == -1)
+    if (location.value == -1)
         return;
-    programObject->setUniform3fv(loc, count, value);
+    programObject->setUniform3fv(location, count, value);
 }
 
 void GLES1Renderer::setUniform2fv(Program *programObject,
-                                  GLint loc,
+                                  UniformLocation location,
                                   GLint count,
                                   const GLfloat *value)
 {
-    if (loc == -1)
+    if (location.value == -1)
         return;
-    programObject->setUniform2fv(loc, count, value);
+    programObject->setUniform2fv(location, count, value);
 }
 
-void GLES1Renderer::setUniform1f(Program *programObject, GLint loc, GLfloat value)
+void GLES1Renderer::setUniform1f(Program *programObject, UniformLocation location, GLfloat value)
 {
-    if (loc == -1)
+    if (location.value == -1)
         return;
-    programObject->setUniform1fv(loc, 1, &value);
+    programObject->setUniform1fv(location, 1, &value);
 }
 
 void GLES1Renderer::setUniform1fv(Program *programObject,
-                                  GLint loc,
+                                  UniformLocation location,
                                   GLint count,
                                   const GLfloat *value)
 {
-    if (loc == -1)
+    if (location.value == -1)
         return;
-    programObject->setUniform1fv(loc, count, value);
+    programObject->setUniform1fv(location, count, value);
 }
 
 void GLES1Renderer::setAttributesEnabled(Context *context, State *glState, AttributesMask mask)
diff --git a/src/libANGLE/GLES1Renderer.h b/src/libANGLE/GLES1Renderer.h
index f7b6a99..5fef075 100644
--- a/src/libANGLE/GLES1Renderer.h
+++ b/src/libANGLE/GLES1Renderer.h
@@ -70,22 +70,37 @@
                               ShaderProgramID *programOut);
     angle::Result initializeRendererProgram(Context *context, State *glState);
 
-    void setUniform1i(Context *context, Program *programObject, GLint loc, GLint value);
+    void setUniform1i(Context *context,
+                      Program *programObject,
+                      UniformLocation location,
+                      GLint value);
     void setUniform1iv(Context *context,
                        Program *programObject,
-                       GLint loc,
+                       UniformLocation location,
                        GLint count,
                        const GLint *value);
     void setUniformMatrix4fv(Program *programObject,
-                             GLint loc,
+                             UniformLocation location,
                              GLint count,
                              GLboolean transpose,
                              const GLfloat *value);
-    void setUniform4fv(Program *programObject, GLint loc, GLint count, const GLfloat *value);
-    void setUniform3fv(Program *programObject, GLint loc, GLint count, const GLfloat *value);
-    void setUniform2fv(Program *programObject, GLint loc, GLint count, const GLfloat *value);
-    void setUniform1f(Program *programObject, GLint loc, GLfloat value);
-    void setUniform1fv(Program *programObject, GLint loc, GLint count, const GLfloat *value);
+    void setUniform4fv(Program *programObject,
+                       UniformLocation location,
+                       GLint count,
+                       const GLfloat *value);
+    void setUniform3fv(Program *programObject,
+                       UniformLocation location,
+                       GLint count,
+                       const GLfloat *value);
+    void setUniform2fv(Program *programObject,
+                       UniformLocation location,
+                       GLint count,
+                       const GLfloat *value);
+    void setUniform1f(Program *programObject, UniformLocation location, GLfloat value);
+    void setUniform1fv(Program *programObject,
+                       UniformLocation location,
+                       GLint count,
+                       const GLfloat *value);
 
     void setAttributesEnabled(Context *context, State *glState, AttributesMask mask);
 
@@ -105,97 +120,97 @@
     {
         ShaderProgramID program;
 
-        GLint projMatrixLoc;
-        GLint modelviewMatrixLoc;
-        GLint textureMatrixLoc;
-        GLint modelviewInvTrLoc;
+        UniformLocation projMatrixLoc;
+        UniformLocation modelviewMatrixLoc;
+        UniformLocation textureMatrixLoc;
+        UniformLocation modelviewInvTrLoc;
 
         // Texturing
-        GLint enableTexture2DLoc;
-        GLint enableTextureCubeMapLoc;
-        std::array<GLint, kTexUnitCount> tex2DSamplerLocs;
-        std::array<GLint, kTexUnitCount> texCubeSamplerLocs;
+        UniformLocation enableTexture2DLoc;
+        UniformLocation enableTextureCubeMapLoc;
+        std::array<UniformLocation, kTexUnitCount> tex2DSamplerLocs;
+        std::array<UniformLocation, kTexUnitCount> texCubeSamplerLocs;
 
-        GLint textureFormatLoc;
+        UniformLocation textureFormatLoc;
 
-        GLint textureEnvModeLoc;
-        GLint combineRgbLoc;
-        GLint combineAlphaLoc;
-        GLint src0rgbLoc;
-        GLint src0alphaLoc;
-        GLint src1rgbLoc;
-        GLint src1alphaLoc;
-        GLint src2rgbLoc;
-        GLint src2alphaLoc;
-        GLint op0rgbLoc;
-        GLint op0alphaLoc;
-        GLint op1rgbLoc;
-        GLint op1alphaLoc;
-        GLint op2rgbLoc;
-        GLint op2alphaLoc;
-        GLint textureEnvColorLoc;
-        GLint rgbScaleLoc;
-        GLint alphaScaleLoc;
-        GLint pointSpriteCoordReplaceLoc;
+        UniformLocation textureEnvModeLoc;
+        UniformLocation combineRgbLoc;
+        UniformLocation combineAlphaLoc;
+        UniformLocation src0rgbLoc;
+        UniformLocation src0alphaLoc;
+        UniformLocation src1rgbLoc;
+        UniformLocation src1alphaLoc;
+        UniformLocation src2rgbLoc;
+        UniformLocation src2alphaLoc;
+        UniformLocation op0rgbLoc;
+        UniformLocation op0alphaLoc;
+        UniformLocation op1rgbLoc;
+        UniformLocation op1alphaLoc;
+        UniformLocation op2rgbLoc;
+        UniformLocation op2alphaLoc;
+        UniformLocation textureEnvColorLoc;
+        UniformLocation rgbScaleLoc;
+        UniformLocation alphaScaleLoc;
+        UniformLocation pointSpriteCoordReplaceLoc;
 
         // Alpha test
-        GLint enableAlphaTestLoc;
-        GLint alphaFuncLoc;
-        GLint alphaTestRefLoc;
+        UniformLocation enableAlphaTestLoc;
+        UniformLocation alphaFuncLoc;
+        UniformLocation alphaTestRefLoc;
 
         // Shading, materials, and lighting
-        GLint shadeModelFlatLoc;
-        GLint enableLightingLoc;
-        GLint enableRescaleNormalLoc;
-        GLint enableNormalizeLoc;
-        GLint enableColorMaterialLoc;
+        UniformLocation shadeModelFlatLoc;
+        UniformLocation enableLightingLoc;
+        UniformLocation enableRescaleNormalLoc;
+        UniformLocation enableNormalizeLoc;
+        UniformLocation enableColorMaterialLoc;
 
-        GLint materialAmbientLoc;
-        GLint materialDiffuseLoc;
-        GLint materialSpecularLoc;
-        GLint materialEmissiveLoc;
-        GLint materialSpecularExponentLoc;
+        UniformLocation materialAmbientLoc;
+        UniformLocation materialDiffuseLoc;
+        UniformLocation materialSpecularLoc;
+        UniformLocation materialEmissiveLoc;
+        UniformLocation materialSpecularExponentLoc;
 
-        GLint lightModelSceneAmbientLoc;
-        GLint lightModelTwoSidedLoc;
+        UniformLocation lightModelSceneAmbientLoc;
+        UniformLocation lightModelTwoSidedLoc;
 
-        GLint lightEnablesLoc;
-        GLint lightAmbientsLoc;
-        GLint lightDiffusesLoc;
-        GLint lightSpecularsLoc;
-        GLint lightPositionsLoc;
-        GLint lightDirectionsLoc;
-        GLint lightSpotlightExponentsLoc;
-        GLint lightSpotlightCutoffAnglesLoc;
-        GLint lightAttenuationConstsLoc;
-        GLint lightAttenuationLinearsLoc;
-        GLint lightAttenuationQuadraticsLoc;
+        UniformLocation lightEnablesLoc;
+        UniformLocation lightAmbientsLoc;
+        UniformLocation lightDiffusesLoc;
+        UniformLocation lightSpecularsLoc;
+        UniformLocation lightPositionsLoc;
+        UniformLocation lightDirectionsLoc;
+        UniformLocation lightSpotlightExponentsLoc;
+        UniformLocation lightSpotlightCutoffAnglesLoc;
+        UniformLocation lightAttenuationConstsLoc;
+        UniformLocation lightAttenuationLinearsLoc;
+        UniformLocation lightAttenuationQuadraticsLoc;
 
         // Fog
-        GLint fogEnableLoc;
-        GLint fogModeLoc;
-        GLint fogDensityLoc;
-        GLint fogStartLoc;
-        GLint fogEndLoc;
-        GLint fogColorLoc;
+        UniformLocation fogEnableLoc;
+        UniformLocation fogModeLoc;
+        UniformLocation fogDensityLoc;
+        UniformLocation fogStartLoc;
+        UniformLocation fogEndLoc;
+        UniformLocation fogColorLoc;
 
         // Clip planes
-        GLint enableClipPlanesLoc;
-        GLint clipPlaneEnablesLoc;
-        GLint clipPlanesLoc;
+        UniformLocation enableClipPlanesLoc;
+        UniformLocation clipPlaneEnablesLoc;
+        UniformLocation clipPlanesLoc;
 
         // Point rasterization
-        GLint pointRasterizationLoc;
-        GLint pointSizeMinLoc;
-        GLint pointSizeMaxLoc;
-        GLint pointDistanceAttenuationLoc;
-        GLint pointSpriteEnabledLoc;
+        UniformLocation pointRasterizationLoc;
+        UniformLocation pointSizeMinLoc;
+        UniformLocation pointSizeMaxLoc;
+        UniformLocation pointDistanceAttenuationLoc;
+        UniformLocation pointSpriteEnabledLoc;
 
         // Draw texture
-        GLint enableDrawTextureLoc;
-        GLint drawTextureCoordsLoc;
-        GLint drawTextureDimsLoc;
-        GLint drawTextureNormalizedCropRectLoc;
+        UniformLocation enableDrawTextureLoc;
+        UniformLocation drawTextureCoordsLoc;
+        UniformLocation drawTextureDimsLoc;
+        UniformLocation drawTextureNormalizedCropRectLoc;
     };
 
     struct GLES1UniformBuffers
diff --git a/src/libANGLE/Program.cpp b/src/libANGLE/Program.cpp
index e7cc270..9bf7a82 100644
--- a/src/libANGLE/Program.cpp
+++ b/src/libANGLE/Program.cpp
@@ -1138,13 +1138,13 @@
     return GetResourceIndexFromName(mBufferVariables, name);
 }
 
-GLuint ProgramState::getUniformIndexFromLocation(GLint location) const
+GLuint ProgramState::getUniformIndexFromLocation(UniformLocation location) const
 {
-    ASSERT(location >= 0 && static_cast<size_t>(location) < mUniformLocations.size());
-    return mUniformLocations[location].index;
+    ASSERT(location.value >= 0 && static_cast<size_t>(location.value) < mUniformLocations.size());
+    return mUniformLocations[location.value].index;
 }
 
-Optional<GLuint> ProgramState::getSamplerIndex(GLint location) const
+Optional<GLuint> ProgramState::getSamplerIndex(UniformLocation location) const
 {
     GLuint index = getUniformIndexFromLocation(location);
     if (!isSamplerUniformIndex(index))
@@ -1358,10 +1358,10 @@
     mAttributeBindings.bindLocation(index, name);
 }
 
-void Program::bindUniformLocation(GLuint index, const char *name)
+void Program::bindUniformLocation(UniformLocation location, const char *name)
 {
     ASSERT(mLinkResolved);
-    mState.mUniformLocationBindings.bindLocation(index, name);
+    mState.mUniformLocationBindings.bindLocation(location.value, name);
 }
 
 void Program::bindFragmentInputLocation(GLint index, const char *name)
@@ -2595,26 +2595,29 @@
     return static_cast<GLint>(maxLength);
 }
 
-bool Program::isValidUniformLocation(GLint location) const
+bool Program::isValidUniformLocation(UniformLocation location) const
 {
     ASSERT(mLinkResolved);
     ASSERT(angle::IsValueInRangeForNumericType<GLint>(mState.mUniformLocations.size()));
-    return (location >= 0 && static_cast<size_t>(location) < mState.mUniformLocations.size() &&
-            mState.mUniformLocations[static_cast<size_t>(location)].used());
+    return (location.value >= 0 &&
+            static_cast<size_t>(location.value) < mState.mUniformLocations.size() &&
+            mState.mUniformLocations[static_cast<size_t>(location.value)].used());
 }
 
-const LinkedUniform &Program::getUniformByLocation(GLint location) const
+const LinkedUniform &Program::getUniformByLocation(UniformLocation location) const
 {
     ASSERT(mLinkResolved);
-    ASSERT(location >= 0 && static_cast<size_t>(location) < mState.mUniformLocations.size());
+    ASSERT(location.value >= 0 &&
+           static_cast<size_t>(location.value) < mState.mUniformLocations.size());
     return mState.mUniforms[mState.getUniformIndexFromLocation(location)];
 }
 
-const VariableLocation &Program::getUniformLocation(GLint location) const
+const VariableLocation &Program::getUniformLocation(UniformLocation location) const
 {
     ASSERT(mLinkResolved);
-    ASSERT(location >= 0 && static_cast<size_t>(location) < mState.mUniformLocations.size());
-    return mState.mUniformLocations[location];
+    ASSERT(location.value >= 0 &&
+           static_cast<size_t>(location.value) < mState.mUniformLocations.size());
+    return mState.mUniformLocations[location.value];
 }
 
 const BufferVariable &Program::getBufferVariableByIndex(GLuint index) const
@@ -2624,10 +2627,10 @@
     return mState.mBufferVariables[index];
 }
 
-GLint Program::getUniformLocation(const std::string &name) const
+UniformLocation Program::getUniformLocation(const std::string &name) const
 {
     ASSERT(mLinkResolved);
-    return GetVariableLocation(mState.mUniforms, mState.mUniformLocations, name);
+    return {GetVariableLocation(mState.mUniforms, mState.mUniformLocations, name)};
 }
 
 GLuint Program::getUniformIndex(const std::string &name) const
@@ -2636,45 +2639,48 @@
     return mState.getUniformIndexFromName(name);
 }
 
-void Program::setUniform1fv(GLint location, GLsizei count, const GLfloat *v)
+void Program::setUniform1fv(UniformLocation location, GLsizei count, const GLfloat *v)
 {
     ASSERT(mLinkResolved);
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
+    const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
     GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 1, v);
-    mProgram->setUniform1fv(location, clampedCount, v);
+    mProgram->setUniform1fv(location.value, clampedCount, v);
 }
 
-void Program::setUniform2fv(GLint location, GLsizei count, const GLfloat *v)
+void Program::setUniform2fv(UniformLocation location, GLsizei count, const GLfloat *v)
 {
     ASSERT(mLinkResolved);
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
+    const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
     GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 2, v);
-    mProgram->setUniform2fv(location, clampedCount, v);
+    mProgram->setUniform2fv(location.value, clampedCount, v);
 }
 
-void Program::setUniform3fv(GLint location, GLsizei count, const GLfloat *v)
+void Program::setUniform3fv(UniformLocation location, GLsizei count, const GLfloat *v)
 {
     ASSERT(mLinkResolved);
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
+    const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
     GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 3, v);
-    mProgram->setUniform3fv(location, clampedCount, v);
+    mProgram->setUniform3fv(location.value, clampedCount, v);
 }
 
-void Program::setUniform4fv(GLint location, GLsizei count, const GLfloat *v)
+void Program::setUniform4fv(UniformLocation location, GLsizei count, const GLfloat *v)
 {
     ASSERT(mLinkResolved);
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
+    const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
     GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 4, v);
-    mProgram->setUniform4fv(location, clampedCount, v);
+    mProgram->setUniform4fv(location.value, clampedCount, v);
 }
 
-void Program::setUniform1iv(Context *context, GLint location, GLsizei count, const GLint *v)
+void Program::setUniform1iv(Context *context,
+                            UniformLocation location,
+                            GLsizei count,
+                            const GLint *v)
 {
     ASSERT(mLinkResolved);
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
+    const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
     GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 1, v);
 
-    mProgram->setUniform1iv(location, clampedCount, v);
+    mProgram->setUniform1iv(location.value, clampedCount, v);
 
     if (mState.isSamplerUniformIndex(locationInfo.index))
     {
@@ -2682,150 +2688,150 @@
     }
 }
 
-void Program::setUniform2iv(GLint location, GLsizei count, const GLint *v)
+void Program::setUniform2iv(UniformLocation location, GLsizei count, const GLint *v)
 {
     ASSERT(mLinkResolved);
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
+    const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
     GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 2, v);
-    mProgram->setUniform2iv(location, clampedCount, v);
+    mProgram->setUniform2iv(location.value, clampedCount, v);
 }
 
-void Program::setUniform3iv(GLint location, GLsizei count, const GLint *v)
+void Program::setUniform3iv(UniformLocation location, GLsizei count, const GLint *v)
 {
     ASSERT(mLinkResolved);
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
+    const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
     GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 3, v);
-    mProgram->setUniform3iv(location, clampedCount, v);
+    mProgram->setUniform3iv(location.value, clampedCount, v);
 }
 
-void Program::setUniform4iv(GLint location, GLsizei count, const GLint *v)
+void Program::setUniform4iv(UniformLocation location, GLsizei count, const GLint *v)
 {
     ASSERT(mLinkResolved);
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
+    const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
     GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 4, v);
-    mProgram->setUniform4iv(location, clampedCount, v);
+    mProgram->setUniform4iv(location.value, clampedCount, v);
 }
 
-void Program::setUniform1uiv(GLint location, GLsizei count, const GLuint *v)
+void Program::setUniform1uiv(UniformLocation location, GLsizei count, const GLuint *v)
 {
     ASSERT(mLinkResolved);
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
+    const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
     GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 1, v);
-    mProgram->setUniform1uiv(location, clampedCount, v);
+    mProgram->setUniform1uiv(location.value, clampedCount, v);
 }
 
-void Program::setUniform2uiv(GLint location, GLsizei count, const GLuint *v)
+void Program::setUniform2uiv(UniformLocation location, GLsizei count, const GLuint *v)
 {
     ASSERT(mLinkResolved);
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
+    const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
     GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 2, v);
-    mProgram->setUniform2uiv(location, clampedCount, v);
+    mProgram->setUniform2uiv(location.value, clampedCount, v);
 }
 
-void Program::setUniform3uiv(GLint location, GLsizei count, const GLuint *v)
+void Program::setUniform3uiv(UniformLocation location, GLsizei count, const GLuint *v)
 {
     ASSERT(mLinkResolved);
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
+    const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
     GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 3, v);
-    mProgram->setUniform3uiv(location, clampedCount, v);
+    mProgram->setUniform3uiv(location.value, clampedCount, v);
 }
 
-void Program::setUniform4uiv(GLint location, GLsizei count, const GLuint *v)
+void Program::setUniform4uiv(UniformLocation location, GLsizei count, const GLuint *v)
 {
     ASSERT(mLinkResolved);
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
+    const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
     GLsizei clampedCount                 = clampUniformCount(locationInfo, count, 4, v);
-    mProgram->setUniform4uiv(location, clampedCount, v);
+    mProgram->setUniform4uiv(location.value, clampedCount, v);
 }
 
-void Program::setUniformMatrix2fv(GLint location,
+void Program::setUniformMatrix2fv(UniformLocation location,
                                   GLsizei count,
                                   GLboolean transpose,
                                   const GLfloat *v)
 {
     ASSERT(mLinkResolved);
     GLsizei clampedCount = clampMatrixUniformCount<2, 2>(location, count, transpose, v);
-    mProgram->setUniformMatrix2fv(location, clampedCount, transpose, v);
+    mProgram->setUniformMatrix2fv(location.value, clampedCount, transpose, v);
 }
 
-void Program::setUniformMatrix3fv(GLint location,
+void Program::setUniformMatrix3fv(UniformLocation location,
                                   GLsizei count,
                                   GLboolean transpose,
                                   const GLfloat *v)
 {
     ASSERT(mLinkResolved);
     GLsizei clampedCount = clampMatrixUniformCount<3, 3>(location, count, transpose, v);
-    mProgram->setUniformMatrix3fv(location, clampedCount, transpose, v);
+    mProgram->setUniformMatrix3fv(location.value, clampedCount, transpose, v);
 }
 
-void Program::setUniformMatrix4fv(GLint location,
+void Program::setUniformMatrix4fv(UniformLocation location,
                                   GLsizei count,
                                   GLboolean transpose,
                                   const GLfloat *v)
 {
     ASSERT(mLinkResolved);
     GLsizei clampedCount = clampMatrixUniformCount<4, 4>(location, count, transpose, v);
-    mProgram->setUniformMatrix4fv(location, clampedCount, transpose, v);
+    mProgram->setUniformMatrix4fv(location.value, clampedCount, transpose, v);
 }
 
-void Program::setUniformMatrix2x3fv(GLint location,
+void Program::setUniformMatrix2x3fv(UniformLocation location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *v)
 {
     ASSERT(mLinkResolved);
     GLsizei clampedCount = clampMatrixUniformCount<2, 3>(location, count, transpose, v);
-    mProgram->setUniformMatrix2x3fv(location, clampedCount, transpose, v);
+    mProgram->setUniformMatrix2x3fv(location.value, clampedCount, transpose, v);
 }
 
-void Program::setUniformMatrix2x4fv(GLint location,
+void Program::setUniformMatrix2x4fv(UniformLocation location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *v)
 {
     ASSERT(mLinkResolved);
     GLsizei clampedCount = clampMatrixUniformCount<2, 4>(location, count, transpose, v);
-    mProgram->setUniformMatrix2x4fv(location, clampedCount, transpose, v);
+    mProgram->setUniformMatrix2x4fv(location.value, clampedCount, transpose, v);
 }
 
-void Program::setUniformMatrix3x2fv(GLint location,
+void Program::setUniformMatrix3x2fv(UniformLocation location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *v)
 {
     ASSERT(mLinkResolved);
     GLsizei clampedCount = clampMatrixUniformCount<3, 2>(location, count, transpose, v);
-    mProgram->setUniformMatrix3x2fv(location, clampedCount, transpose, v);
+    mProgram->setUniformMatrix3x2fv(location.value, clampedCount, transpose, v);
 }
 
-void Program::setUniformMatrix3x4fv(GLint location,
+void Program::setUniformMatrix3x4fv(UniformLocation location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *v)
 {
     ASSERT(mLinkResolved);
     GLsizei clampedCount = clampMatrixUniformCount<3, 4>(location, count, transpose, v);
-    mProgram->setUniformMatrix3x4fv(location, clampedCount, transpose, v);
+    mProgram->setUniformMatrix3x4fv(location.value, clampedCount, transpose, v);
 }
 
-void Program::setUniformMatrix4x2fv(GLint location,
+void Program::setUniformMatrix4x2fv(UniformLocation location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *v)
 {
     ASSERT(mLinkResolved);
     GLsizei clampedCount = clampMatrixUniformCount<4, 2>(location, count, transpose, v);
-    mProgram->setUniformMatrix4x2fv(location, clampedCount, transpose, v);
+    mProgram->setUniformMatrix4x2fv(location.value, clampedCount, transpose, v);
 }
 
-void Program::setUniformMatrix4x3fv(GLint location,
+void Program::setUniformMatrix4x3fv(UniformLocation location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *v)
 {
     ASSERT(mLinkResolved);
     GLsizei clampedCount = clampMatrixUniformCount<4, 3>(location, count, transpose, v);
-    mProgram->setUniformMatrix4x3fv(location, clampedCount, transpose, v);
+    mProgram->setUniformMatrix4x3fv(location.value, clampedCount, transpose, v);
 }
 
 GLuint Program::getSamplerUniformBinding(const VariableLocation &uniformLocation) const
@@ -2845,10 +2851,10 @@
     return boundImageUnits[uniformLocation.arrayIndex];
 }
 
-void Program::getUniformfv(const Context *context, GLint location, GLfloat *v) const
+void Program::getUniformfv(const Context *context, UniformLocation location, GLfloat *v) const
 {
     ASSERT(mLinkResolved);
-    const VariableLocation &uniformLocation = mState.getUniformLocations()[location];
+    const VariableLocation &uniformLocation = mState.getUniformLocations()[location.value];
     const LinkedUniform &uniform            = mState.getUniforms()[uniformLocation.index];
 
     if (uniform.isSampler())
@@ -2865,7 +2871,7 @@
     const GLenum nativeType = gl::VariableComponentType(uniform.type);
     if (nativeType == GL_FLOAT)
     {
-        mProgram->getUniformfv(context, location, v);
+        mProgram->getUniformfv(context, location.value, v);
     }
     else
     {
@@ -2873,10 +2879,10 @@
     }
 }
 
-void Program::getUniformiv(const Context *context, GLint location, GLint *v) const
+void Program::getUniformiv(const Context *context, UniformLocation location, GLint *v) const
 {
     ASSERT(mLinkResolved);
-    const VariableLocation &uniformLocation = mState.getUniformLocations()[location];
+    const VariableLocation &uniformLocation = mState.getUniformLocations()[location.value];
     const LinkedUniform &uniform            = mState.getUniforms()[uniformLocation.index];
 
     if (uniform.isSampler())
@@ -2893,7 +2899,7 @@
     const GLenum nativeType = gl::VariableComponentType(uniform.type);
     if (nativeType == GL_INT || nativeType == GL_BOOL)
     {
-        mProgram->getUniformiv(context, location, v);
+        mProgram->getUniformiv(context, location.value, v);
     }
     else
     {
@@ -2901,10 +2907,10 @@
     }
 }
 
-void Program::getUniformuiv(const Context *context, GLint location, GLuint *v) const
+void Program::getUniformuiv(const Context *context, UniformLocation location, GLuint *v) const
 {
     ASSERT(mLinkResolved);
-    const VariableLocation &uniformLocation = mState.getUniformLocations()[location];
+    const VariableLocation &uniformLocation = mState.getUniformLocations()[location.value];
     const LinkedUniform &uniform            = mState.getUniforms()[uniformLocation.index];
 
     if (uniform.isSampler())
@@ -2921,7 +2927,7 @@
     const GLenum nativeType = VariableComponentType(uniform.type);
     if (nativeType == GL_UNSIGNED_INT)
     {
-        mProgram->getUniformuiv(context, location, v);
+        mProgram->getUniformuiv(context, location.value, v);
     }
     else
     {
@@ -4863,8 +4869,8 @@
         const auto &samplerUniform = mState.mUniforms[samplerIndex];
         if (samplerUniform.binding != -1)
         {
-            GLint location = getUniformLocation(samplerUniform.name);
-            ASSERT(location != -1);
+            UniformLocation location = getUniformLocation(samplerUniform.name);
+            ASSERT(location.value != -1);
             std::vector<GLint> boundTextureUnits;
             for (unsigned int elementIndex = 0;
                  elementIndex < samplerUniform.getBasicTypeElementCount(); ++elementIndex)
@@ -5045,12 +5051,12 @@
 }
 
 template <size_t cols, size_t rows, typename T>
-GLsizei Program::clampMatrixUniformCount(GLint location,
+GLsizei Program::clampMatrixUniformCount(UniformLocation location,
                                          GLsizei count,
                                          GLboolean transpose,
                                          const T *v)
 {
-    const VariableLocation &locationInfo = mState.mUniformLocations[location];
+    const VariableLocation &locationInfo = mState.mUniformLocations[location.value];
 
     if (!transpose)
     {
@@ -5071,7 +5077,7 @@
 template <typename DestT>
 void Program::getUniformInternal(const Context *context,
                                  DestT *dataOut,
-                                 GLint location,
+                                 UniformLocation location,
                                  GLenum nativeType,
                                  int components) const
 {
@@ -5080,7 +5086,7 @@
         case GL_BOOL:
         {
             GLint tempValue[16] = {0};
-            mProgram->getUniformiv(context, location, tempValue);
+            mProgram->getUniformiv(context, location.value, tempValue);
             UniformStateQueryCastLoop<GLboolean>(
                 dataOut, reinterpret_cast<const uint8_t *>(tempValue), components);
             break;
@@ -5088,7 +5094,7 @@
         case GL_INT:
         {
             GLint tempValue[16] = {0};
-            mProgram->getUniformiv(context, location, tempValue);
+            mProgram->getUniformiv(context, location.value, tempValue);
             UniformStateQueryCastLoop<GLint>(dataOut, reinterpret_cast<const uint8_t *>(tempValue),
                                              components);
             break;
@@ -5096,7 +5102,7 @@
         case GL_UNSIGNED_INT:
         {
             GLuint tempValue[16] = {0};
-            mProgram->getUniformuiv(context, location, tempValue);
+            mProgram->getUniformuiv(context, location.value, tempValue);
             UniformStateQueryCastLoop<GLuint>(dataOut, reinterpret_cast<const uint8_t *>(tempValue),
                                               components);
             break;
@@ -5104,7 +5110,7 @@
         case GL_FLOAT:
         {
             GLfloat tempValue[16] = {0};
-            mProgram->getUniformfv(context, location, tempValue);
+            mProgram->getUniformfv(context, location.value, tempValue);
             UniformStateQueryCastLoop<GLfloat>(
                 dataOut, reinterpret_cast<const uint8_t *>(tempValue), components);
             break;
@@ -5585,13 +5591,13 @@
 
     if (context->getExtensions().multiDraw)
     {
-        mState.mDrawIDLocation = getUniformLocation("gl_DrawID");
+        mState.mDrawIDLocation = getUniformLocation("gl_DrawID").value;
     }
 
     if (context->getExtensions().baseVertexBaseInstance)
     {
-        mState.mBaseVertexLocation   = getUniformLocation("gl_BaseVertex");
-        mState.mBaseInstanceLocation = getUniformLocation("gl_BaseInstance");
+        mState.mBaseVertexLocation   = getUniformLocation("gl_BaseVertex").value;
+        mState.mBaseInstanceLocation = getUniformLocation("gl_BaseInstance").value;
     }
 }
 
diff --git a/src/libANGLE/Program.h b/src/libANGLE/Program.h
index 737e540..c92ab17 100644
--- a/src/libANGLE/Program.h
+++ b/src/libANGLE/Program.h
@@ -420,8 +420,8 @@
     size_t getUniqueStorageBlockCount() const;
 
     GLuint getUniformIndexFromName(const std::string &name) const;
-    GLuint getUniformIndexFromLocation(GLint location) const;
-    Optional<GLuint> getSamplerIndex(GLint location) const;
+    GLuint getUniformIndexFromLocation(UniformLocation location) const;
+    Optional<GLuint> getSamplerIndex(UniformLocation location) const;
     bool isSamplerUniformIndex(GLuint index) const;
     GLuint getSamplerIndexFromUniformIndex(GLuint uniformIndex) const;
     GLuint getUniformIndexFromSamplerIndex(GLuint samplerIndex) const;
@@ -618,7 +618,7 @@
     const Shader *getAttachedShader(ShaderType shaderType) const;
 
     void bindAttributeLocation(GLuint index, const char *name);
-    void bindUniformLocation(GLuint index, const char *name);
+    void bindUniformLocation(UniformLocation location, const char *name);
 
     // CHROMIUM_path_rendering
     BindingInfo getFragmentInputBindingInfo(GLint index) const;
@@ -704,9 +704,9 @@
     GLint getActiveUniformCount() const;
     size_t getActiveBufferVariableCount() const;
     GLint getActiveUniformMaxLength() const;
-    bool isValidUniformLocation(GLint location) const;
-    const LinkedUniform &getUniformByLocation(GLint location) const;
-    const VariableLocation &getUniformLocation(GLint location) const;
+    bool isValidUniformLocation(UniformLocation location) const;
+    const LinkedUniform &getUniformByLocation(UniformLocation location) const;
+    const VariableLocation &getUniformLocation(UniformLocation location) const;
 
     const std::vector<VariableLocation> &getUniformLocations() const
     {
@@ -729,60 +729,60 @@
         NoSamplerChange,
     };
 
-    GLint getUniformLocation(const std::string &name) const;
+    UniformLocation getUniformLocation(const std::string &name) const;
     GLuint getUniformIndex(const std::string &name) const;
-    void setUniform1fv(GLint location, GLsizei count, const GLfloat *v);
-    void setUniform2fv(GLint location, GLsizei count, const GLfloat *v);
-    void setUniform3fv(GLint location, GLsizei count, const GLfloat *v);
-    void setUniform4fv(GLint location, GLsizei count, const GLfloat *v);
-    void setUniform1iv(Context *context, GLint location, GLsizei count, const GLint *v);
-    void setUniform2iv(GLint location, GLsizei count, const GLint *v);
-    void setUniform3iv(GLint location, GLsizei count, const GLint *v);
-    void setUniform4iv(GLint location, GLsizei count, const GLint *v);
-    void setUniform1uiv(GLint location, GLsizei count, const GLuint *v);
-    void setUniform2uiv(GLint location, GLsizei count, const GLuint *v);
-    void setUniform3uiv(GLint location, GLsizei count, const GLuint *v);
-    void setUniform4uiv(GLint location, GLsizei count, const GLuint *v);
-    void setUniformMatrix2fv(GLint location,
+    void setUniform1fv(UniformLocation location, GLsizei count, const GLfloat *v);
+    void setUniform2fv(UniformLocation location, GLsizei count, const GLfloat *v);
+    void setUniform3fv(UniformLocation location, GLsizei count, const GLfloat *v);
+    void setUniform4fv(UniformLocation location, GLsizei count, const GLfloat *v);
+    void setUniform1iv(Context *context, UniformLocation location, GLsizei count, const GLint *v);
+    void setUniform2iv(UniformLocation location, GLsizei count, const GLint *v);
+    void setUniform3iv(UniformLocation location, GLsizei count, const GLint *v);
+    void setUniform4iv(UniformLocation location, GLsizei count, const GLint *v);
+    void setUniform1uiv(UniformLocation location, GLsizei count, const GLuint *v);
+    void setUniform2uiv(UniformLocation location, GLsizei count, const GLuint *v);
+    void setUniform3uiv(UniformLocation location, GLsizei count, const GLuint *v);
+    void setUniform4uiv(UniformLocation location, GLsizei count, const GLuint *v);
+    void setUniformMatrix2fv(UniformLocation location,
                              GLsizei count,
                              GLboolean transpose,
                              const GLfloat *value);
-    void setUniformMatrix3fv(GLint location,
+    void setUniformMatrix3fv(UniformLocation location,
                              GLsizei count,
                              GLboolean transpose,
                              const GLfloat *value);
-    void setUniformMatrix4fv(GLint location,
+    void setUniformMatrix4fv(UniformLocation location,
                              GLsizei count,
                              GLboolean transpose,
                              const GLfloat *value);
-    void setUniformMatrix2x3fv(GLint location,
+    void setUniformMatrix2x3fv(UniformLocation location,
                                GLsizei count,
                                GLboolean transpose,
                                const GLfloat *value);
-    void setUniformMatrix3x2fv(GLint location,
+    void setUniformMatrix3x2fv(UniformLocation location,
                                GLsizei count,
                                GLboolean transpose,
                                const GLfloat *value);
-    void setUniformMatrix2x4fv(GLint location,
+    void setUniformMatrix2x4fv(UniformLocation location,
                                GLsizei count,
                                GLboolean transpose,
                                const GLfloat *value);
-    void setUniformMatrix4x2fv(GLint location,
+    void setUniformMatrix4x2fv(UniformLocation location,
                                GLsizei count,
                                GLboolean transpose,
                                const GLfloat *value);
-    void setUniformMatrix3x4fv(GLint location,
+    void setUniformMatrix3x4fv(UniformLocation location,
                                GLsizei count,
                                GLboolean transpose,
                                const GLfloat *value);
-    void setUniformMatrix4x3fv(GLint location,
+    void setUniformMatrix4x3fv(UniformLocation location,
                                GLsizei count,
                                GLboolean transpose,
                                const GLfloat *value);
 
-    void getUniformfv(const Context *context, GLint location, GLfloat *params) const;
-    void getUniformiv(const Context *context, GLint location, GLint *params) const;
-    void getUniformuiv(const Context *context, GLint location, GLuint *params) const;
+    void getUniformfv(const Context *context, UniformLocation location, GLfloat *params) const;
+    void getUniformiv(const Context *context, UniformLocation location, GLint *params) const;
+    void getUniformuiv(const Context *context, UniformLocation location, GLuint *params) const;
 
     void getActiveUniformBlockName(const GLuint blockIndex,
                                    GLsizei bufSize,
@@ -1068,7 +1068,10 @@
                               int vectorSize,
                               const T *v);
     template <size_t cols, size_t rows, typename T>
-    GLsizei clampMatrixUniformCount(GLint location, GLsizei count, GLboolean transpose, const T *v);
+    GLsizei clampMatrixUniformCount(UniformLocation location,
+                                    GLsizei count,
+                                    GLboolean transpose,
+                                    const T *v);
 
     void updateSamplerUniform(Context *context,
                               const VariableLocation &locationInfo,
@@ -1078,7 +1081,7 @@
     template <typename DestT>
     void getUniformInternal(const Context *context,
                             DestT *dataOut,
-                            GLint location,
+                            UniformLocation location,
                             GLenum nativeType,
                             int components) const;
 
diff --git a/src/libANGLE/capture_gles_2_0_autogen.cpp b/src/libANGLE/capture_gles_2_0_autogen.cpp
index 1c30a8a..b842b89 100644
--- a/src/libANGLE/capture_gles_2_0_autogen.cpp
+++ b/src/libANGLE/capture_gles_2_0_autogen.cpp
@@ -1305,17 +1305,18 @@
 CallCapture CaptureGetUniformfv(const State &glState,
                                 bool isCallValid,
                                 ShaderProgramID programPacked,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLfloat *params)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
 
     ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
     InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
-    CaptureGetUniformfv_params(glState, isCallValid, programPacked, location, params, &paramsParam);
+    CaptureGetUniformfv_params(glState, isCallValid, programPacked, locationPacked, params,
+                               &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
     return CallCapture(gl::EntryPoint::GetUniformfv, std::move(paramBuffer));
@@ -1324,17 +1325,18 @@
 CallCapture CaptureGetUniformiv(const State &glState,
                                 bool isCallValid,
                                 ShaderProgramID programPacked,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLint *params)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
 
     ParamCapture paramsParam("params", ParamType::TGLintPointer);
     InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
-    CaptureGetUniformiv_params(glState, isCallValid, programPacked, location, params, &paramsParam);
+    CaptureGetUniformiv_params(glState, isCallValid, programPacked, locationPacked, params,
+                               &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
     return CallCapture(gl::EntryPoint::GetUniformiv, std::move(paramBuffer));
@@ -1924,11 +1926,14 @@
     return CallCapture(gl::EntryPoint::TexSubImage2D, std::move(paramBuffer));
 }
 
-CallCapture CaptureUniform1f(const State &glState, bool isCallValid, GLint location, GLfloat v0)
+CallCapture CaptureUniform1f(const State &glState,
+                             bool isCallValid,
+                             UniformLocation locationPacked,
+                             GLfloat v0)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
 
     return CallCapture(gl::EntryPoint::Uniform1f, std::move(paramBuffer));
@@ -1936,28 +1941,31 @@
 
 CallCapture CaptureUniform1fv(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               const GLfloat *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureUniform1fv_value(glState, isCallValid, location, count, value, &valueParam);
+    CaptureUniform1fv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::Uniform1fv, std::move(paramBuffer));
 }
 
-CallCapture CaptureUniform1i(const State &glState, bool isCallValid, GLint location, GLint v0)
+CallCapture CaptureUniform1i(const State &glState,
+                             bool isCallValid,
+                             UniformLocation locationPacked,
+                             GLint v0)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
 
     return CallCapture(gl::EntryPoint::Uniform1i, std::move(paramBuffer));
@@ -1965,18 +1973,18 @@
 
 CallCapture CaptureUniform1iv(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               const GLint *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLintConstPointer);
     InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
-    CaptureUniform1iv_value(glState, isCallValid, location, count, value, &valueParam);
+    CaptureUniform1iv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::Uniform1iv, std::move(paramBuffer));
@@ -1984,13 +1992,13 @@
 
 CallCapture CaptureUniform2f(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation locationPacked,
                              GLfloat v0,
                              GLfloat v1)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
 
@@ -1999,18 +2007,18 @@
 
 CallCapture CaptureUniform2fv(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               const GLfloat *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureUniform2fv_value(glState, isCallValid, location, count, value, &valueParam);
+    CaptureUniform2fv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::Uniform2fv, std::move(paramBuffer));
@@ -2018,13 +2026,13 @@
 
 CallCapture CaptureUniform2i(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation locationPacked,
                              GLint v0,
                              GLint v1)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
 
@@ -2033,18 +2041,18 @@
 
 CallCapture CaptureUniform2iv(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               const GLint *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLintConstPointer);
     InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
-    CaptureUniform2iv_value(glState, isCallValid, location, count, value, &valueParam);
+    CaptureUniform2iv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::Uniform2iv, std::move(paramBuffer));
@@ -2052,14 +2060,14 @@
 
 CallCapture CaptureUniform3f(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation locationPacked,
                              GLfloat v0,
                              GLfloat v1,
                              GLfloat v2)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLfloat, v2);
@@ -2069,18 +2077,18 @@
 
 CallCapture CaptureUniform3fv(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               const GLfloat *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureUniform3fv_value(glState, isCallValid, location, count, value, &valueParam);
+    CaptureUniform3fv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::Uniform3fv, std::move(paramBuffer));
@@ -2088,14 +2096,14 @@
 
 CallCapture CaptureUniform3i(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation locationPacked,
                              GLint v0,
                              GLint v1,
                              GLint v2)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLint, v2);
@@ -2105,18 +2113,18 @@
 
 CallCapture CaptureUniform3iv(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               const GLint *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLintConstPointer);
     InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
-    CaptureUniform3iv_value(glState, isCallValid, location, count, value, &valueParam);
+    CaptureUniform3iv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::Uniform3iv, std::move(paramBuffer));
@@ -2124,7 +2132,7 @@
 
 CallCapture CaptureUniform4f(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation locationPacked,
                              GLfloat v0,
                              GLfloat v1,
                              GLfloat v2,
@@ -2132,7 +2140,7 @@
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLfloat, v2);
@@ -2143,18 +2151,18 @@
 
 CallCapture CaptureUniform4fv(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               const GLfloat *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureUniform4fv_value(glState, isCallValid, location, count, value, &valueParam);
+    CaptureUniform4fv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::Uniform4fv, std::move(paramBuffer));
@@ -2162,7 +2170,7 @@
 
 CallCapture CaptureUniform4i(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation locationPacked,
                              GLint v0,
                              GLint v1,
                              GLint v2,
@@ -2170,7 +2178,7 @@
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLint, v2);
@@ -2181,18 +2189,18 @@
 
 CallCapture CaptureUniform4iv(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               const GLint *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLintConstPointer);
     InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
-    CaptureUniform4iv_value(glState, isCallValid, location, count, value, &valueParam);
+    CaptureUniform4iv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::Uniform4iv, std::move(paramBuffer));
@@ -2200,20 +2208,20 @@
 
 CallCapture CaptureUniformMatrix2fv(const State &glState,
                                     bool isCallValid,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureUniformMatrix2fv_value(glState, isCallValid, location, count, transpose, value,
+    CaptureUniformMatrix2fv_value(glState, isCallValid, locationPacked, count, transpose, value,
                                   &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
@@ -2222,20 +2230,20 @@
 
 CallCapture CaptureUniformMatrix3fv(const State &glState,
                                     bool isCallValid,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureUniformMatrix3fv_value(glState, isCallValid, location, count, transpose, value,
+    CaptureUniformMatrix3fv_value(glState, isCallValid, locationPacked, count, transpose, value,
                                   &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
@@ -2244,20 +2252,20 @@
 
 CallCapture CaptureUniformMatrix4fv(const State &glState,
                                     bool isCallValid,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureUniformMatrix4fv_value(glState, isCallValid, location, count, transpose, value,
+    CaptureUniformMatrix4fv_value(glState, isCallValid, locationPacked, count, transpose, value,
                                   &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
diff --git a/src/libANGLE/capture_gles_2_0_autogen.h b/src/libANGLE/capture_gles_2_0_autogen.h
index cbf6970..2e8bb31 100644
--- a/src/libANGLE/capture_gles_2_0_autogen.h
+++ b/src/libANGLE/capture_gles_2_0_autogen.h
@@ -344,12 +344,12 @@
 angle::CallCapture CaptureGetUniformfv(const State &glState,
                                        bool isCallValid,
                                        ShaderProgramID programPacked,
-                                       GLint location,
+                                       UniformLocation locationPacked,
                                        GLfloat *params);
 angle::CallCapture CaptureGetUniformiv(const State &glState,
                                        bool isCallValid,
                                        ShaderProgramID programPacked,
-                                       GLint location,
+                                       UniformLocation locationPacked,
                                        GLint *params);
 angle::CallCapture CaptureGetVertexAttribPointerv(const State &glState,
                                                   bool isCallValid,
@@ -517,103 +517,103 @@
                                         const void *pixels);
 angle::CallCapture CaptureUniform1f(const State &glState,
                                     bool isCallValid,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLfloat v0);
 angle::CallCapture CaptureUniform1fv(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLfloat *value);
 angle::CallCapture CaptureUniform1i(const State &glState,
                                     bool isCallValid,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLint v0);
 angle::CallCapture CaptureUniform1iv(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLint *value);
 angle::CallCapture CaptureUniform2f(const State &glState,
                                     bool isCallValid,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLfloat v0,
                                     GLfloat v1);
 angle::CallCapture CaptureUniform2fv(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLfloat *value);
 angle::CallCapture CaptureUniform2i(const State &glState,
                                     bool isCallValid,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLint v0,
                                     GLint v1);
 angle::CallCapture CaptureUniform2iv(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLint *value);
 angle::CallCapture CaptureUniform3f(const State &glState,
                                     bool isCallValid,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLfloat v0,
                                     GLfloat v1,
                                     GLfloat v2);
 angle::CallCapture CaptureUniform3fv(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLfloat *value);
 angle::CallCapture CaptureUniform3i(const State &glState,
                                     bool isCallValid,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLint v0,
                                     GLint v1,
                                     GLint v2);
 angle::CallCapture CaptureUniform3iv(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLint *value);
 angle::CallCapture CaptureUniform4f(const State &glState,
                                     bool isCallValid,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLfloat v0,
                                     GLfloat v1,
                                     GLfloat v2,
                                     GLfloat v3);
 angle::CallCapture CaptureUniform4fv(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLfloat *value);
 angle::CallCapture CaptureUniform4i(const State &glState,
                                     bool isCallValid,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLint v0,
                                     GLint v1,
                                     GLint v2,
                                     GLint v3);
 angle::CallCapture CaptureUniform4iv(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLint *value);
 angle::CallCapture CaptureUniformMatrix2fv(const State &glState,
                                            bool isCallValid,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLsizei count,
                                            GLboolean transpose,
                                            const GLfloat *value);
 angle::CallCapture CaptureUniformMatrix3fv(const State &glState,
                                            bool isCallValid,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLsizei count,
                                            GLboolean transpose,
                                            const GLfloat *value);
 angle::CallCapture CaptureUniformMatrix4fv(const State &glState,
                                            bool isCallValid,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLsizei count,
                                            GLboolean transpose,
                                            const GLfloat *value);
@@ -989,13 +989,13 @@
 void CaptureGetUniformfv_params(const State &glState,
                                 bool isCallValid,
                                 ShaderProgramID programPacked,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLfloat *params,
                                 angle::ParamCapture *paramCapture);
 void CaptureGetUniformiv_params(const State &glState,
                                 bool isCallValid,
                                 ShaderProgramID programPacked,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLint *params,
                                 angle::ParamCapture *paramCapture);
 void CaptureGetVertexAttribPointerv_pointer(const State &glState,
@@ -1094,69 +1094,69 @@
                                  angle::ParamCapture *paramCapture);
 void CaptureUniform1fv_value(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation locationPacked,
                              GLsizei count,
                              const GLfloat *value,
                              angle::ParamCapture *paramCapture);
 void CaptureUniform1iv_value(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation locationPacked,
                              GLsizei count,
                              const GLint *value,
                              angle::ParamCapture *paramCapture);
 void CaptureUniform2fv_value(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation locationPacked,
                              GLsizei count,
                              const GLfloat *value,
                              angle::ParamCapture *paramCapture);
 void CaptureUniform2iv_value(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation locationPacked,
                              GLsizei count,
                              const GLint *value,
                              angle::ParamCapture *paramCapture);
 void CaptureUniform3fv_value(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation locationPacked,
                              GLsizei count,
                              const GLfloat *value,
                              angle::ParamCapture *paramCapture);
 void CaptureUniform3iv_value(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation locationPacked,
                              GLsizei count,
                              const GLint *value,
                              angle::ParamCapture *paramCapture);
 void CaptureUniform4fv_value(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation locationPacked,
                              GLsizei count,
                              const GLfloat *value,
                              angle::ParamCapture *paramCapture);
 void CaptureUniform4iv_value(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation locationPacked,
                              GLsizei count,
                              const GLint *value,
                              angle::ParamCapture *paramCapture);
 void CaptureUniformMatrix2fv_value(const State &glState,
                                    bool isCallValid,
-                                   GLint location,
+                                   UniformLocation locationPacked,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLfloat *value,
                                    angle::ParamCapture *paramCapture);
 void CaptureUniformMatrix3fv_value(const State &glState,
                                    bool isCallValid,
-                                   GLint location,
+                                   UniformLocation locationPacked,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLfloat *value,
                                    angle::ParamCapture *paramCapture);
 void CaptureUniformMatrix4fv_value(const State &glState,
                                    bool isCallValid,
-                                   GLint location,
+                                   UniformLocation locationPacked,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLfloat *value,
diff --git a/src/libANGLE/capture_gles_2_0_params.cpp b/src/libANGLE/capture_gles_2_0_params.cpp
index 9180568..380988a 100644
--- a/src/libANGLE/capture_gles_2_0_params.cpp
+++ b/src/libANGLE/capture_gles_2_0_params.cpp
@@ -539,7 +539,7 @@
 void CaptureGetUniformfv_params(const State &glState,
                                 bool isCallValid,
                                 ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLfloat *params,
                                 ParamCapture *paramCapture)
 {
@@ -549,7 +549,7 @@
 void CaptureGetUniformiv_params(const State &glState,
                                 bool isCallValid,
                                 ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLint *params,
                                 ParamCapture *paramCapture)
 {
@@ -742,7 +742,7 @@
 
 void CaptureUniform1fv_value(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation location,
                              GLsizei count,
                              const GLfloat *value,
                              ParamCapture *paramCapture)
@@ -752,7 +752,7 @@
 
 void CaptureUniform1iv_value(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation location,
                              GLsizei count,
                              const GLint *value,
                              ParamCapture *paramCapture)
@@ -762,7 +762,7 @@
 
 void CaptureUniform2fv_value(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation location,
                              GLsizei count,
                              const GLfloat *value,
                              ParamCapture *paramCapture)
@@ -772,7 +772,7 @@
 
 void CaptureUniform2iv_value(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation location,
                              GLsizei count,
                              const GLint *value,
                              ParamCapture *paramCapture)
@@ -782,7 +782,7 @@
 
 void CaptureUniform3fv_value(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation location,
                              GLsizei count,
                              const GLfloat *value,
                              ParamCapture *paramCapture)
@@ -792,7 +792,7 @@
 
 void CaptureUniform3iv_value(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation location,
                              GLsizei count,
                              const GLint *value,
                              ParamCapture *paramCapture)
@@ -802,7 +802,7 @@
 
 void CaptureUniform4fv_value(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation location,
                              GLsizei count,
                              const GLfloat *value,
                              ParamCapture *paramCapture)
@@ -812,7 +812,7 @@
 
 void CaptureUniform4iv_value(const State &glState,
                              bool isCallValid,
-                             GLint location,
+                             UniformLocation location,
                              GLsizei count,
                              const GLint *value,
                              ParamCapture *paramCapture)
@@ -822,7 +822,7 @@
 
 void CaptureUniformMatrix2fv_value(const State &glState,
                                    bool isCallValid,
-                                   GLint location,
+                                   UniformLocation location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLfloat *value,
@@ -833,7 +833,7 @@
 
 void CaptureUniformMatrix3fv_value(const State &glState,
                                    bool isCallValid,
-                                   GLint location,
+                                   UniformLocation location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLfloat *value,
@@ -844,7 +844,7 @@
 
 void CaptureUniformMatrix4fv_value(const State &glState,
                                    bool isCallValid,
-                                   GLint location,
+                                   UniformLocation location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLfloat *value,
diff --git a/src/libANGLE/capture_gles_3_0_autogen.cpp b/src/libANGLE/capture_gles_3_0_autogen.cpp
index d9bf969..66ff21f 100644
--- a/src/libANGLE/capture_gles_3_0_autogen.cpp
+++ b/src/libANGLE/capture_gles_3_0_autogen.cpp
@@ -1137,17 +1137,17 @@
 CallCapture CaptureGetUniformuiv(const State &glState,
                                  bool isCallValid,
                                  ShaderProgramID programPacked,
-                                 GLint location,
+                                 UniformLocation locationPacked,
                                  GLuint *params)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
 
     ParamCapture paramsParam("params", ParamType::TGLuintPointer);
     InitParamValue(ParamType::TGLuintPointer, params, &paramsParam.value);
-    CaptureGetUniformuiv_params(glState, isCallValid, programPacked, location, params,
+    CaptureGetUniformuiv_params(glState, isCallValid, programPacked, locationPacked, params,
                                 &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
@@ -1632,11 +1632,14 @@
     return CallCapture(gl::EntryPoint::TransformFeedbackVaryings, std::move(paramBuffer));
 }
 
-CallCapture CaptureUniform1ui(const State &glState, bool isCallValid, GLint location, GLuint v0)
+CallCapture CaptureUniform1ui(const State &glState,
+                              bool isCallValid,
+                              UniformLocation locationPacked,
+                              GLuint v0)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
 
     return CallCapture(gl::EntryPoint::Uniform1ui, std::move(paramBuffer));
@@ -1644,18 +1647,18 @@
 
 CallCapture CaptureUniform1uiv(const State &glState,
                                bool isCallValid,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLsizei count,
                                const GLuint *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
     InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
-    CaptureUniform1uiv_value(glState, isCallValid, location, count, value, &valueParam);
+    CaptureUniform1uiv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::Uniform1uiv, std::move(paramBuffer));
@@ -1663,13 +1666,13 @@
 
 CallCapture CaptureUniform2ui(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLuint v0,
                               GLuint v1)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
 
@@ -1678,18 +1681,18 @@
 
 CallCapture CaptureUniform2uiv(const State &glState,
                                bool isCallValid,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLsizei count,
                                const GLuint *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
     InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
-    CaptureUniform2uiv_value(glState, isCallValid, location, count, value, &valueParam);
+    CaptureUniform2uiv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::Uniform2uiv, std::move(paramBuffer));
@@ -1697,14 +1700,14 @@
 
 CallCapture CaptureUniform3ui(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLuint v0,
                               GLuint v1,
                               GLuint v2)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLuint, v2);
@@ -1714,18 +1717,18 @@
 
 CallCapture CaptureUniform3uiv(const State &glState,
                                bool isCallValid,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLsizei count,
                                const GLuint *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
     InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
-    CaptureUniform3uiv_value(glState, isCallValid, location, count, value, &valueParam);
+    CaptureUniform3uiv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::Uniform3uiv, std::move(paramBuffer));
@@ -1733,7 +1736,7 @@
 
 CallCapture CaptureUniform4ui(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLuint v0,
                               GLuint v1,
                               GLuint v2,
@@ -1741,7 +1744,7 @@
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLuint, v2);
@@ -1752,18 +1755,18 @@
 
 CallCapture CaptureUniform4uiv(const State &glState,
                                bool isCallValid,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLsizei count,
                                const GLuint *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
     InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
-    CaptureUniform4uiv_value(glState, isCallValid, location, count, value, &valueParam);
+    CaptureUniform4uiv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::Uniform4uiv, std::move(paramBuffer));
@@ -1786,20 +1789,20 @@
 
 CallCapture CaptureUniformMatrix2x3fv(const State &glState,
                                       bool isCallValid,
-                                      GLint location,
+                                      UniformLocation locationPacked,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureUniformMatrix2x3fv_value(glState, isCallValid, location, count, transpose, value,
+    CaptureUniformMatrix2x3fv_value(glState, isCallValid, locationPacked, count, transpose, value,
                                     &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
@@ -1808,20 +1811,20 @@
 
 CallCapture CaptureUniformMatrix2x4fv(const State &glState,
                                       bool isCallValid,
-                                      GLint location,
+                                      UniformLocation locationPacked,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureUniformMatrix2x4fv_value(glState, isCallValid, location, count, transpose, value,
+    CaptureUniformMatrix2x4fv_value(glState, isCallValid, locationPacked, count, transpose, value,
                                     &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
@@ -1830,20 +1833,20 @@
 
 CallCapture CaptureUniformMatrix3x2fv(const State &glState,
                                       bool isCallValid,
-                                      GLint location,
+                                      UniformLocation locationPacked,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureUniformMatrix3x2fv_value(glState, isCallValid, location, count, transpose, value,
+    CaptureUniformMatrix3x2fv_value(glState, isCallValid, locationPacked, count, transpose, value,
                                     &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
@@ -1852,20 +1855,20 @@
 
 CallCapture CaptureUniformMatrix3x4fv(const State &glState,
                                       bool isCallValid,
-                                      GLint location,
+                                      UniformLocation locationPacked,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureUniformMatrix3x4fv_value(glState, isCallValid, location, count, transpose, value,
+    CaptureUniformMatrix3x4fv_value(glState, isCallValid, locationPacked, count, transpose, value,
                                     &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
@@ -1874,20 +1877,20 @@
 
 CallCapture CaptureUniformMatrix4x2fv(const State &glState,
                                       bool isCallValid,
-                                      GLint location,
+                                      UniformLocation locationPacked,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureUniformMatrix4x2fv_value(glState, isCallValid, location, count, transpose, value,
+    CaptureUniformMatrix4x2fv_value(glState, isCallValid, locationPacked, count, transpose, value,
                                     &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
@@ -1896,20 +1899,20 @@
 
 CallCapture CaptureUniformMatrix4x3fv(const State &glState,
                                       bool isCallValid,
-                                      GLint location,
+                                      UniformLocation locationPacked,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
 {
     ParamBuffer paramBuffer;
 
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureUniformMatrix4x3fv_value(glState, isCallValid, location, count, transpose, value,
+    CaptureUniformMatrix4x3fv_value(glState, isCallValid, locationPacked, count, transpose, value,
                                     &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
diff --git a/src/libANGLE/capture_gles_3_0_autogen.h b/src/libANGLE/capture_gles_3_0_autogen.h
index ab99bbc..da0ff3b 100644
--- a/src/libANGLE/capture_gles_3_0_autogen.h
+++ b/src/libANGLE/capture_gles_3_0_autogen.h
@@ -325,7 +325,7 @@
 angle::CallCapture CaptureGetUniformuiv(const State &glState,
                                         bool isCallValid,
                                         ShaderProgramID programPacked,
-                                        GLint location,
+                                        UniformLocation locationPacked,
                                         GLuint *params);
 angle::CallCapture CaptureGetVertexAttribIiv(const State &glState,
                                              bool isCallValid,
@@ -467,44 +467,44 @@
                                                     GLenum bufferMode);
 angle::CallCapture CaptureUniform1ui(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLuint v0);
 angle::CallCapture CaptureUniform1uiv(const State &glState,
                                       bool isCallValid,
-                                      GLint location,
+                                      UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLuint *value);
 angle::CallCapture CaptureUniform2ui(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLuint v0,
                                      GLuint v1);
 angle::CallCapture CaptureUniform2uiv(const State &glState,
                                       bool isCallValid,
-                                      GLint location,
+                                      UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLuint *value);
 angle::CallCapture CaptureUniform3ui(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLuint v0,
                                      GLuint v1,
                                      GLuint v2);
 angle::CallCapture CaptureUniform3uiv(const State &glState,
                                       bool isCallValid,
-                                      GLint location,
+                                      UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLuint *value);
 angle::CallCapture CaptureUniform4ui(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLuint v0,
                                      GLuint v1,
                                      GLuint v2,
                                      GLuint v3);
 angle::CallCapture CaptureUniform4uiv(const State &glState,
                                       bool isCallValid,
-                                      GLint location,
+                                      UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLuint *value);
 angle::CallCapture CaptureUniformBlockBinding(const State &glState,
@@ -514,37 +514,37 @@
                                               GLuint uniformBlockBinding);
 angle::CallCapture CaptureUniformMatrix2x3fv(const State &glState,
                                              bool isCallValid,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value);
 angle::CallCapture CaptureUniformMatrix2x4fv(const State &glState,
                                              bool isCallValid,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value);
 angle::CallCapture CaptureUniformMatrix3x2fv(const State &glState,
                                              bool isCallValid,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value);
 angle::CallCapture CaptureUniformMatrix3x4fv(const State &glState,
                                              bool isCallValid,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value);
 angle::CallCapture CaptureUniformMatrix4x2fv(const State &glState,
                                              bool isCallValid,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value);
 angle::CallCapture CaptureUniformMatrix4x3fv(const State &glState,
                                              bool isCallValid,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value);
@@ -906,7 +906,7 @@
 void CaptureGetUniformuiv_params(const State &glState,
                                  bool isCallValid,
                                  ShaderProgramID programPacked,
-                                 GLint location,
+                                 UniformLocation locationPacked,
                                  GLuint *params,
                                  angle::ParamCapture *paramCapture);
 void CaptureGetVertexAttribIiv_params(const State &glState,
@@ -992,66 +992,66 @@
                                                angle::ParamCapture *paramCapture);
 void CaptureUniform1uiv_value(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               const GLuint *value,
                               angle::ParamCapture *paramCapture);
 void CaptureUniform2uiv_value(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               const GLuint *value,
                               angle::ParamCapture *paramCapture);
 void CaptureUniform3uiv_value(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               const GLuint *value,
                               angle::ParamCapture *paramCapture);
 void CaptureUniform4uiv_value(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               const GLuint *value,
                               angle::ParamCapture *paramCapture);
 void CaptureUniformMatrix2x3fv_value(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value,
                                      angle::ParamCapture *paramCapture);
 void CaptureUniformMatrix2x4fv_value(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value,
                                      angle::ParamCapture *paramCapture);
 void CaptureUniformMatrix3x2fv_value(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value,
                                      angle::ParamCapture *paramCapture);
 void CaptureUniformMatrix3x4fv_value(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value,
                                      angle::ParamCapture *paramCapture);
 void CaptureUniformMatrix4x2fv_value(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value,
                                      angle::ParamCapture *paramCapture);
 void CaptureUniformMatrix4x3fv_value(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value,
diff --git a/src/libANGLE/capture_gles_3_0_params.cpp b/src/libANGLE/capture_gles_3_0_params.cpp
index a191d26..5e7e2f5 100644
--- a/src/libANGLE/capture_gles_3_0_params.cpp
+++ b/src/libANGLE/capture_gles_3_0_params.cpp
@@ -515,7 +515,7 @@
 void CaptureGetUniformuiv_params(const State &glState,
                                  bool isCallValid,
                                  ShaderProgramID program,
-                                 GLint location,
+                                 UniformLocation location,
                                  GLuint *params,
                                  ParamCapture *paramCapture)
 {
@@ -669,7 +669,7 @@
 
 void CaptureUniform1uiv_value(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation location,
                               GLsizei count,
                               const GLuint *value,
                               ParamCapture *paramCapture)
@@ -679,7 +679,7 @@
 
 void CaptureUniform2uiv_value(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation location,
                               GLsizei count,
                               const GLuint *value,
                               ParamCapture *paramCapture)
@@ -689,7 +689,7 @@
 
 void CaptureUniform3uiv_value(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation location,
                               GLsizei count,
                               const GLuint *value,
                               ParamCapture *paramCapture)
@@ -699,7 +699,7 @@
 
 void CaptureUniform4uiv_value(const State &glState,
                               bool isCallValid,
-                              GLint location,
+                              UniformLocation location,
                               GLsizei count,
                               const GLuint *value,
                               ParamCapture *paramCapture)
@@ -709,7 +709,7 @@
 
 void CaptureUniformMatrix2x3fv_value(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value,
@@ -720,7 +720,7 @@
 
 void CaptureUniformMatrix2x4fv_value(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value,
@@ -731,7 +731,7 @@
 
 void CaptureUniformMatrix3x2fv_value(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value,
@@ -742,7 +742,7 @@
 
 void CaptureUniformMatrix3x4fv_value(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value,
@@ -753,7 +753,7 @@
 
 void CaptureUniformMatrix4x2fv_value(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value,
@@ -764,7 +764,7 @@
 
 void CaptureUniformMatrix4x3fv_value(const State &glState,
                                      bool isCallValid,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value,
diff --git a/src/libANGLE/capture_gles_3_1_autogen.cpp b/src/libANGLE/capture_gles_3_1_autogen.cpp
index 62cba66..560c59a 100644
--- a/src/libANGLE/capture_gles_3_1_autogen.cpp
+++ b/src/libANGLE/capture_gles_3_1_autogen.cpp
@@ -568,13 +568,13 @@
 CallCapture CaptureProgramUniform1f(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLfloat v0)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
 
     return CallCapture(gl::EntryPoint::ProgramUniform1f, std::move(paramBuffer));
@@ -583,20 +583,20 @@
 CallCapture CaptureProgramUniform1fv(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLfloat *value)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureProgramUniform1fv_value(glState, isCallValid, programPacked, location, count, value,
-                                   &valueParam);
+    CaptureProgramUniform1fv_value(glState, isCallValid, programPacked, locationPacked, count,
+                                   value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniform1fv, std::move(paramBuffer));
@@ -605,13 +605,13 @@
 CallCapture CaptureProgramUniform1i(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLint v0)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
 
     return CallCapture(gl::EntryPoint::ProgramUniform1i, std::move(paramBuffer));
@@ -620,20 +620,20 @@
 CallCapture CaptureProgramUniform1iv(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLint *value)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLintConstPointer);
     InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
-    CaptureProgramUniform1iv_value(glState, isCallValid, programPacked, location, count, value,
-                                   &valueParam);
+    CaptureProgramUniform1iv_value(glState, isCallValid, programPacked, locationPacked, count,
+                                   value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniform1iv, std::move(paramBuffer));
@@ -642,13 +642,13 @@
 CallCapture CaptureProgramUniform1ui(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLuint v0)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
 
     return CallCapture(gl::EntryPoint::ProgramUniform1ui, std::move(paramBuffer));
@@ -657,20 +657,20 @@
 CallCapture CaptureProgramUniform1uiv(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID programPacked,
-                                      GLint location,
+                                      UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLuint *value)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
     InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
-    CaptureProgramUniform1uiv_value(glState, isCallValid, programPacked, location, count, value,
-                                    &valueParam);
+    CaptureProgramUniform1uiv_value(glState, isCallValid, programPacked, locationPacked, count,
+                                    value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniform1uiv, std::move(paramBuffer));
@@ -679,14 +679,14 @@
 CallCapture CaptureProgramUniform2f(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLfloat v0,
                                     GLfloat v1)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
 
@@ -696,20 +696,20 @@
 CallCapture CaptureProgramUniform2fv(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLfloat *value)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureProgramUniform2fv_value(glState, isCallValid, programPacked, location, count, value,
-                                   &valueParam);
+    CaptureProgramUniform2fv_value(glState, isCallValid, programPacked, locationPacked, count,
+                                   value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniform2fv, std::move(paramBuffer));
@@ -718,14 +718,14 @@
 CallCapture CaptureProgramUniform2i(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLint v0,
                                     GLint v1)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
 
@@ -735,20 +735,20 @@
 CallCapture CaptureProgramUniform2iv(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLint *value)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLintConstPointer);
     InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
-    CaptureProgramUniform2iv_value(glState, isCallValid, programPacked, location, count, value,
-                                   &valueParam);
+    CaptureProgramUniform2iv_value(glState, isCallValid, programPacked, locationPacked, count,
+                                   value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniform2iv, std::move(paramBuffer));
@@ -757,14 +757,14 @@
 CallCapture CaptureProgramUniform2ui(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLuint v0,
                                      GLuint v1)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
 
@@ -774,20 +774,20 @@
 CallCapture CaptureProgramUniform2uiv(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID programPacked,
-                                      GLint location,
+                                      UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLuint *value)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
     InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
-    CaptureProgramUniform2uiv_value(glState, isCallValid, programPacked, location, count, value,
-                                    &valueParam);
+    CaptureProgramUniform2uiv_value(glState, isCallValid, programPacked, locationPacked, count,
+                                    value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniform2uiv, std::move(paramBuffer));
@@ -796,7 +796,7 @@
 CallCapture CaptureProgramUniform3f(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLfloat v0,
                                     GLfloat v1,
                                     GLfloat v2)
@@ -804,7 +804,7 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLfloat, v2);
@@ -815,20 +815,20 @@
 CallCapture CaptureProgramUniform3fv(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLfloat *value)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureProgramUniform3fv_value(glState, isCallValid, programPacked, location, count, value,
-                                   &valueParam);
+    CaptureProgramUniform3fv_value(glState, isCallValid, programPacked, locationPacked, count,
+                                   value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniform3fv, std::move(paramBuffer));
@@ -837,7 +837,7 @@
 CallCapture CaptureProgramUniform3i(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLint v0,
                                     GLint v1,
                                     GLint v2)
@@ -845,7 +845,7 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLint, v2);
@@ -856,20 +856,20 @@
 CallCapture CaptureProgramUniform3iv(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLint *value)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLintConstPointer);
     InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
-    CaptureProgramUniform3iv_value(glState, isCallValid, programPacked, location, count, value,
-                                   &valueParam);
+    CaptureProgramUniform3iv_value(glState, isCallValid, programPacked, locationPacked, count,
+                                   value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniform3iv, std::move(paramBuffer));
@@ -878,7 +878,7 @@
 CallCapture CaptureProgramUniform3ui(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLuint v0,
                                      GLuint v1,
                                      GLuint v2)
@@ -886,7 +886,7 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLuint, v2);
@@ -897,20 +897,20 @@
 CallCapture CaptureProgramUniform3uiv(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID programPacked,
-                                      GLint location,
+                                      UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLuint *value)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
     InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
-    CaptureProgramUniform3uiv_value(glState, isCallValid, programPacked, location, count, value,
-                                    &valueParam);
+    CaptureProgramUniform3uiv_value(glState, isCallValid, programPacked, locationPacked, count,
+                                    value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniform3uiv, std::move(paramBuffer));
@@ -919,7 +919,7 @@
 CallCapture CaptureProgramUniform4f(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLfloat v0,
                                     GLfloat v1,
                                     GLfloat v2,
@@ -928,7 +928,7 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLfloat, v2);
@@ -940,20 +940,20 @@
 CallCapture CaptureProgramUniform4fv(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLfloat *value)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureProgramUniform4fv_value(glState, isCallValid, programPacked, location, count, value,
-                                   &valueParam);
+    CaptureProgramUniform4fv_value(glState, isCallValid, programPacked, locationPacked, count,
+                                   value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniform4fv, std::move(paramBuffer));
@@ -962,7 +962,7 @@
 CallCapture CaptureProgramUniform4i(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLint v0,
                                     GLint v1,
                                     GLint v2,
@@ -971,7 +971,7 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLint, v2);
@@ -983,20 +983,20 @@
 CallCapture CaptureProgramUniform4iv(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLint *value)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLintConstPointer);
     InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
-    CaptureProgramUniform4iv_value(glState, isCallValid, programPacked, location, count, value,
-                                   &valueParam);
+    CaptureProgramUniform4iv_value(glState, isCallValid, programPacked, locationPacked, count,
+                                   value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniform4iv, std::move(paramBuffer));
@@ -1005,7 +1005,7 @@
 CallCapture CaptureProgramUniform4ui(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLuint v0,
                                      GLuint v1,
                                      GLuint v2,
@@ -1014,7 +1014,7 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLuint, v2);
@@ -1026,20 +1026,20 @@
 CallCapture CaptureProgramUniform4uiv(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID programPacked,
-                                      GLint location,
+                                      UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLuint *value)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
     ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
     InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
-    CaptureProgramUniform4uiv_value(glState, isCallValid, programPacked, location, count, value,
-                                    &valueParam);
+    CaptureProgramUniform4uiv_value(glState, isCallValid, programPacked, locationPacked, count,
+                                    value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniform4uiv, std::move(paramBuffer));
@@ -1048,7 +1048,7 @@
 CallCapture CaptureProgramUniformMatrix2fv(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLsizei count,
                                            GLboolean transpose,
                                            const GLfloat *value)
@@ -1056,13 +1056,13 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureProgramUniformMatrix2fv_value(glState, isCallValid, programPacked, location, count,
+    CaptureProgramUniformMatrix2fv_value(glState, isCallValid, programPacked, locationPacked, count,
                                          transpose, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
@@ -1072,7 +1072,7 @@
 CallCapture CaptureProgramUniformMatrix2x3fv(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value)
@@ -1080,14 +1080,14 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureProgramUniformMatrix2x3fv_value(glState, isCallValid, programPacked, location, count,
-                                           transpose, value, &valueParam);
+    CaptureProgramUniformMatrix2x3fv_value(glState, isCallValid, programPacked, locationPacked,
+                                           count, transpose, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniformMatrix2x3fv, std::move(paramBuffer));
@@ -1096,7 +1096,7 @@
 CallCapture CaptureProgramUniformMatrix2x4fv(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value)
@@ -1104,14 +1104,14 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureProgramUniformMatrix2x4fv_value(glState, isCallValid, programPacked, location, count,
-                                           transpose, value, &valueParam);
+    CaptureProgramUniformMatrix2x4fv_value(glState, isCallValid, programPacked, locationPacked,
+                                           count, transpose, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniformMatrix2x4fv, std::move(paramBuffer));
@@ -1120,7 +1120,7 @@
 CallCapture CaptureProgramUniformMatrix3fv(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLsizei count,
                                            GLboolean transpose,
                                            const GLfloat *value)
@@ -1128,13 +1128,13 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureProgramUniformMatrix3fv_value(glState, isCallValid, programPacked, location, count,
+    CaptureProgramUniformMatrix3fv_value(glState, isCallValid, programPacked, locationPacked, count,
                                          transpose, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
@@ -1144,7 +1144,7 @@
 CallCapture CaptureProgramUniformMatrix3x2fv(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value)
@@ -1152,14 +1152,14 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureProgramUniformMatrix3x2fv_value(glState, isCallValid, programPacked, location, count,
-                                           transpose, value, &valueParam);
+    CaptureProgramUniformMatrix3x2fv_value(glState, isCallValid, programPacked, locationPacked,
+                                           count, transpose, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniformMatrix3x2fv, std::move(paramBuffer));
@@ -1168,7 +1168,7 @@
 CallCapture CaptureProgramUniformMatrix3x4fv(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value)
@@ -1176,14 +1176,14 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureProgramUniformMatrix3x4fv_value(glState, isCallValid, programPacked, location, count,
-                                           transpose, value, &valueParam);
+    CaptureProgramUniformMatrix3x4fv_value(glState, isCallValid, programPacked, locationPacked,
+                                           count, transpose, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniformMatrix3x4fv, std::move(paramBuffer));
@@ -1192,7 +1192,7 @@
 CallCapture CaptureProgramUniformMatrix4fv(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLsizei count,
                                            GLboolean transpose,
                                            const GLfloat *value)
@@ -1200,13 +1200,13 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureProgramUniformMatrix4fv_value(glState, isCallValid, programPacked, location, count,
+    CaptureProgramUniformMatrix4fv_value(glState, isCallValid, programPacked, locationPacked, count,
                                          transpose, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
@@ -1216,7 +1216,7 @@
 CallCapture CaptureProgramUniformMatrix4x2fv(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value)
@@ -1224,14 +1224,14 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureProgramUniformMatrix4x2fv_value(glState, isCallValid, programPacked, location, count,
-                                           transpose, value, &valueParam);
+    CaptureProgramUniformMatrix4x2fv_value(glState, isCallValid, programPacked, locationPacked,
+                                           count, transpose, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniformMatrix4x2fv, std::move(paramBuffer));
@@ -1240,7 +1240,7 @@
 CallCapture CaptureProgramUniformMatrix4x3fv(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value)
@@ -1248,14 +1248,14 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
 
     ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
     InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
-    CaptureProgramUniformMatrix4x3fv_value(glState, isCallValid, programPacked, location, count,
-                                           transpose, value, &valueParam);
+    CaptureProgramUniformMatrix4x3fv_value(glState, isCallValid, programPacked, locationPacked,
+                                           count, transpose, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
     return CallCapture(gl::EntryPoint::ProgramUniformMatrix4x3fv, std::move(paramBuffer));
diff --git a/src/libANGLE/capture_gles_3_1_autogen.h b/src/libANGLE/capture_gles_3_1_autogen.h
index fab4e64..22c54e2 100644
--- a/src/libANGLE/capture_gles_3_1_autogen.h
+++ b/src/libANGLE/capture_gles_3_1_autogen.h
@@ -164,115 +164,115 @@
 angle::CallCapture CaptureProgramUniform1f(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLfloat v0);
 angle::CallCapture CaptureProgramUniform1fv(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei count,
                                             const GLfloat *value);
 angle::CallCapture CaptureProgramUniform1i(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLint v0);
 angle::CallCapture CaptureProgramUniform1iv(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei count,
                                             const GLint *value);
 angle::CallCapture CaptureProgramUniform1ui(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLuint v0);
 angle::CallCapture CaptureProgramUniform1uiv(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei count,
                                              const GLuint *value);
 angle::CallCapture CaptureProgramUniform2f(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLfloat v0,
                                            GLfloat v1);
 angle::CallCapture CaptureProgramUniform2fv(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei count,
                                             const GLfloat *value);
 angle::CallCapture CaptureProgramUniform2i(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLint v0,
                                            GLint v1);
 angle::CallCapture CaptureProgramUniform2iv(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei count,
                                             const GLint *value);
 angle::CallCapture CaptureProgramUniform2ui(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLuint v0,
                                             GLuint v1);
 angle::CallCapture CaptureProgramUniform2uiv(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei count,
                                              const GLuint *value);
 angle::CallCapture CaptureProgramUniform3f(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLfloat v0,
                                            GLfloat v1,
                                            GLfloat v2);
 angle::CallCapture CaptureProgramUniform3fv(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei count,
                                             const GLfloat *value);
 angle::CallCapture CaptureProgramUniform3i(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLint v0,
                                            GLint v1,
                                            GLint v2);
 angle::CallCapture CaptureProgramUniform3iv(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei count,
                                             const GLint *value);
 angle::CallCapture CaptureProgramUniform3ui(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLuint v0,
                                             GLuint v1,
                                             GLuint v2);
 angle::CallCapture CaptureProgramUniform3uiv(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei count,
                                              const GLuint *value);
 angle::CallCapture CaptureProgramUniform4f(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLfloat v0,
                                            GLfloat v1,
                                            GLfloat v2,
@@ -280,13 +280,13 @@
 angle::CallCapture CaptureProgramUniform4fv(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei count,
                                             const GLfloat *value);
 angle::CallCapture CaptureProgramUniform4i(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLint v0,
                                            GLint v1,
                                            GLint v2,
@@ -294,13 +294,13 @@
 angle::CallCapture CaptureProgramUniform4iv(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei count,
                                             const GLint *value);
 angle::CallCapture CaptureProgramUniform4ui(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLuint v0,
                                             GLuint v1,
                                             GLuint v2,
@@ -308,69 +308,69 @@
 angle::CallCapture CaptureProgramUniform4uiv(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei count,
                                              const GLuint *value);
 angle::CallCapture CaptureProgramUniformMatrix2fv(const State &glState,
                                                   bool isCallValid,
                                                   ShaderProgramID programPacked,
-                                                  GLint location,
+                                                  UniformLocation locationPacked,
                                                   GLsizei count,
                                                   GLboolean transpose,
                                                   const GLfloat *value);
 angle::CallCapture CaptureProgramUniformMatrix2x3fv(const State &glState,
                                                     bool isCallValid,
                                                     ShaderProgramID programPacked,
-                                                    GLint location,
+                                                    UniformLocation locationPacked,
                                                     GLsizei count,
                                                     GLboolean transpose,
                                                     const GLfloat *value);
 angle::CallCapture CaptureProgramUniformMatrix2x4fv(const State &glState,
                                                     bool isCallValid,
                                                     ShaderProgramID programPacked,
-                                                    GLint location,
+                                                    UniformLocation locationPacked,
                                                     GLsizei count,
                                                     GLboolean transpose,
                                                     const GLfloat *value);
 angle::CallCapture CaptureProgramUniformMatrix3fv(const State &glState,
                                                   bool isCallValid,
                                                   ShaderProgramID programPacked,
-                                                  GLint location,
+                                                  UniformLocation locationPacked,
                                                   GLsizei count,
                                                   GLboolean transpose,
                                                   const GLfloat *value);
 angle::CallCapture CaptureProgramUniformMatrix3x2fv(const State &glState,
                                                     bool isCallValid,
                                                     ShaderProgramID programPacked,
-                                                    GLint location,
+                                                    UniformLocation locationPacked,
                                                     GLsizei count,
                                                     GLboolean transpose,
                                                     const GLfloat *value);
 angle::CallCapture CaptureProgramUniformMatrix3x4fv(const State &glState,
                                                     bool isCallValid,
                                                     ShaderProgramID programPacked,
-                                                    GLint location,
+                                                    UniformLocation locationPacked,
                                                     GLsizei count,
                                                     GLboolean transpose,
                                                     const GLfloat *value);
 angle::CallCapture CaptureProgramUniformMatrix4fv(const State &glState,
                                                   bool isCallValid,
                                                   ShaderProgramID programPacked,
-                                                  GLint location,
+                                                  UniformLocation locationPacked,
                                                   GLsizei count,
                                                   GLboolean transpose,
                                                   const GLfloat *value);
 angle::CallCapture CaptureProgramUniformMatrix4x2fv(const State &glState,
                                                     bool isCallValid,
                                                     ShaderProgramID programPacked,
-                                                    GLint location,
+                                                    UniformLocation locationPacked,
                                                     GLsizei count,
                                                     GLboolean transpose,
                                                     const GLfloat *value);
 angle::CallCapture CaptureProgramUniformMatrix4x3fv(const State &glState,
                                                     bool isCallValid,
                                                     ShaderProgramID programPacked,
-                                                    GLint location,
+                                                    UniformLocation locationPacked,
                                                     GLsizei count,
                                                     GLboolean transpose,
                                                     const GLfloat *value);
@@ -570,91 +570,91 @@
 void CaptureProgramUniform1fv_value(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLsizei count,
                                     const GLfloat *value,
                                     angle::ParamCapture *paramCapture);
 void CaptureProgramUniform1iv_value(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLsizei count,
                                     const GLint *value,
                                     angle::ParamCapture *paramCapture);
 void CaptureProgramUniform1uiv_value(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLuint *value,
                                      angle::ParamCapture *paramCapture);
 void CaptureProgramUniform2fv_value(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLsizei count,
                                     const GLfloat *value,
                                     angle::ParamCapture *paramCapture);
 void CaptureProgramUniform2iv_value(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLsizei count,
                                     const GLint *value,
                                     angle::ParamCapture *paramCapture);
 void CaptureProgramUniform2uiv_value(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLuint *value,
                                      angle::ParamCapture *paramCapture);
 void CaptureProgramUniform3fv_value(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLsizei count,
                                     const GLfloat *value,
                                     angle::ParamCapture *paramCapture);
 void CaptureProgramUniform3iv_value(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLsizei count,
                                     const GLint *value,
                                     angle::ParamCapture *paramCapture);
 void CaptureProgramUniform3uiv_value(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLuint *value,
                                      angle::ParamCapture *paramCapture);
 void CaptureProgramUniform4fv_value(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLsizei count,
                                     const GLfloat *value,
                                     angle::ParamCapture *paramCapture);
 void CaptureProgramUniform4iv_value(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLsizei count,
                                     const GLint *value,
                                     angle::ParamCapture *paramCapture);
 void CaptureProgramUniform4uiv_value(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      const GLuint *value,
                                      angle::ParamCapture *paramCapture);
 void CaptureProgramUniformMatrix2fv_value(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
-                                          GLint location,
+                                          UniformLocation locationPacked,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value,
@@ -662,7 +662,7 @@
 void CaptureProgramUniformMatrix2x3fv_value(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value,
@@ -670,7 +670,7 @@
 void CaptureProgramUniformMatrix2x4fv_value(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value,
@@ -678,7 +678,7 @@
 void CaptureProgramUniformMatrix3fv_value(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
-                                          GLint location,
+                                          UniformLocation locationPacked,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value,
@@ -686,7 +686,7 @@
 void CaptureProgramUniformMatrix3x2fv_value(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value,
@@ -694,7 +694,7 @@
 void CaptureProgramUniformMatrix3x4fv_value(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value,
@@ -702,7 +702,7 @@
 void CaptureProgramUniformMatrix4fv_value(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
-                                          GLint location,
+                                          UniformLocation locationPacked,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value,
@@ -710,7 +710,7 @@
 void CaptureProgramUniformMatrix4x2fv_value(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value,
@@ -718,7 +718,7 @@
 void CaptureProgramUniformMatrix4x3fv_value(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value,
diff --git a/src/libANGLE/capture_gles_3_1_params.cpp b/src/libANGLE/capture_gles_3_1_params.cpp
index 1da03eb..32faf79 100644
--- a/src/libANGLE/capture_gles_3_1_params.cpp
+++ b/src/libANGLE/capture_gles_3_1_params.cpp
@@ -249,7 +249,7 @@
 void CaptureProgramUniform1fv_value(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID program,
-                                    GLint location,
+                                    UniformLocation location,
                                     GLsizei count,
                                     const GLfloat *value,
                                     ParamCapture *paramCapture)
@@ -260,7 +260,7 @@
 void CaptureProgramUniform1iv_value(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID program,
-                                    GLint location,
+                                    UniformLocation location,
                                     GLsizei count,
                                     const GLint *value,
                                     ParamCapture *paramCapture)
@@ -271,7 +271,7 @@
 void CaptureProgramUniform1uiv_value(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID program,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei count,
                                      const GLuint *value,
                                      ParamCapture *paramCapture)
@@ -282,7 +282,7 @@
 void CaptureProgramUniform2fv_value(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID program,
-                                    GLint location,
+                                    UniformLocation location,
                                     GLsizei count,
                                     const GLfloat *value,
                                     ParamCapture *paramCapture)
@@ -293,7 +293,7 @@
 void CaptureProgramUniform2iv_value(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID program,
-                                    GLint location,
+                                    UniformLocation location,
                                     GLsizei count,
                                     const GLint *value,
                                     ParamCapture *paramCapture)
@@ -304,7 +304,7 @@
 void CaptureProgramUniform2uiv_value(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID program,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei count,
                                      const GLuint *value,
                                      ParamCapture *paramCapture)
@@ -315,7 +315,7 @@
 void CaptureProgramUniform3fv_value(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID program,
-                                    GLint location,
+                                    UniformLocation location,
                                     GLsizei count,
                                     const GLfloat *value,
                                     ParamCapture *paramCapture)
@@ -326,7 +326,7 @@
 void CaptureProgramUniform3iv_value(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID program,
-                                    GLint location,
+                                    UniformLocation location,
                                     GLsizei count,
                                     const GLint *value,
                                     ParamCapture *paramCapture)
@@ -337,7 +337,7 @@
 void CaptureProgramUniform3uiv_value(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID program,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei count,
                                      const GLuint *value,
                                      ParamCapture *paramCapture)
@@ -348,7 +348,7 @@
 void CaptureProgramUniform4fv_value(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID program,
-                                    GLint location,
+                                    UniformLocation location,
                                     GLsizei count,
                                     const GLfloat *value,
                                     ParamCapture *paramCapture)
@@ -359,7 +359,7 @@
 void CaptureProgramUniform4iv_value(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID program,
-                                    GLint location,
+                                    UniformLocation location,
                                     GLsizei count,
                                     const GLint *value,
                                     ParamCapture *paramCapture)
@@ -370,7 +370,7 @@
 void CaptureProgramUniform4uiv_value(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID program,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei count,
                                      const GLuint *value,
                                      ParamCapture *paramCapture)
@@ -381,7 +381,7 @@
 void CaptureProgramUniformMatrix2fv_value(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID program,
-                                          GLint location,
+                                          UniformLocation location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value,
@@ -393,7 +393,7 @@
 void CaptureProgramUniformMatrix2x3fv_value(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID program,
-                                            GLint location,
+                                            UniformLocation location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value,
@@ -405,7 +405,7 @@
 void CaptureProgramUniformMatrix2x4fv_value(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID program,
-                                            GLint location,
+                                            UniformLocation location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value,
@@ -417,7 +417,7 @@
 void CaptureProgramUniformMatrix3fv_value(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID program,
-                                          GLint location,
+                                          UniformLocation location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value,
@@ -429,7 +429,7 @@
 void CaptureProgramUniformMatrix3x2fv_value(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID program,
-                                            GLint location,
+                                            UniformLocation location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value,
@@ -441,7 +441,7 @@
 void CaptureProgramUniformMatrix3x4fv_value(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID program,
-                                            GLint location,
+                                            UniformLocation location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value,
@@ -453,7 +453,7 @@
 void CaptureProgramUniformMatrix4fv_value(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID program,
-                                          GLint location,
+                                          UniformLocation location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value,
@@ -465,7 +465,7 @@
 void CaptureProgramUniformMatrix4x2fv_value(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID program,
-                                            GLint location,
+                                            UniformLocation location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value,
@@ -477,7 +477,7 @@
 void CaptureProgramUniformMatrix4x3fv_value(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID program,
-                                            GLint location,
+                                            UniformLocation location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value,
diff --git a/src/libANGLE/capture_gles_3_2_autogen.cpp b/src/libANGLE/capture_gles_3_2_autogen.cpp
index c4def93..20a5fb2 100644
--- a/src/libANGLE/capture_gles_3_2_autogen.cpp
+++ b/src/libANGLE/capture_gles_3_2_autogen.cpp
@@ -569,20 +569,20 @@
 CallCapture CaptureGetnUniformfv(const State &glState,
                                  bool isCallValid,
                                  ShaderProgramID programPacked,
-                                 GLint location,
+                                 UniformLocation locationPacked,
                                  GLsizei bufSize,
                                  GLfloat *params)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
 
     ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
     InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
-    CaptureGetnUniformfv_params(glState, isCallValid, programPacked, location, bufSize, params,
-                                &paramsParam);
+    CaptureGetnUniformfv_params(glState, isCallValid, programPacked, locationPacked, bufSize,
+                                params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
     return CallCapture(gl::EntryPoint::GetnUniformfv, std::move(paramBuffer));
@@ -591,20 +591,20 @@
 CallCapture CaptureGetnUniformiv(const State &glState,
                                  bool isCallValid,
                                  ShaderProgramID programPacked,
-                                 GLint location,
+                                 UniformLocation locationPacked,
                                  GLsizei bufSize,
                                  GLint *params)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
 
     ParamCapture paramsParam("params", ParamType::TGLintPointer);
     InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
-    CaptureGetnUniformiv_params(glState, isCallValid, programPacked, location, bufSize, params,
-                                &paramsParam);
+    CaptureGetnUniformiv_params(glState, isCallValid, programPacked, locationPacked, bufSize,
+                                params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
     return CallCapture(gl::EntryPoint::GetnUniformiv, std::move(paramBuffer));
@@ -613,20 +613,20 @@
 CallCapture CaptureGetnUniformuiv(const State &glState,
                                   bool isCallValid,
                                   ShaderProgramID programPacked,
-                                  GLint location,
+                                  UniformLocation locationPacked,
                                   GLsizei bufSize,
                                   GLuint *params)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
 
     ParamCapture paramsParam("params", ParamType::TGLuintPointer);
     InitParamValue(ParamType::TGLuintPointer, params, &paramsParam.value);
-    CaptureGetnUniformuiv_params(glState, isCallValid, programPacked, location, bufSize, params,
-                                 &paramsParam);
+    CaptureGetnUniformuiv_params(glState, isCallValid, programPacked, locationPacked, bufSize,
+                                 params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
     return CallCapture(gl::EntryPoint::GetnUniformuiv, std::move(paramBuffer));
diff --git a/src/libANGLE/capture_gles_3_2_autogen.h b/src/libANGLE/capture_gles_3_2_autogen.h
index 388856b..f014aca 100644
--- a/src/libANGLE/capture_gles_3_2_autogen.h
+++ b/src/libANGLE/capture_gles_3_2_autogen.h
@@ -177,19 +177,19 @@
 angle::CallCapture CaptureGetnUniformfv(const State &glState,
                                         bool isCallValid,
                                         ShaderProgramID programPacked,
-                                        GLint location,
+                                        UniformLocation locationPacked,
                                         GLsizei bufSize,
                                         GLfloat *params);
 angle::CallCapture CaptureGetnUniformiv(const State &glState,
                                         bool isCallValid,
                                         ShaderProgramID programPacked,
-                                        GLint location,
+                                        UniformLocation locationPacked,
                                         GLsizei bufSize,
                                         GLint *params);
 angle::CallCapture CaptureGetnUniformuiv(const State &glState,
                                          bool isCallValid,
                                          ShaderProgramID programPacked,
-                                         GLint location,
+                                         UniformLocation locationPacked,
                                          GLsizei bufSize,
                                          GLuint *params);
 angle::CallCapture CaptureIsEnabledi(const State &glState,
@@ -469,21 +469,21 @@
 void CaptureGetnUniformfv_params(const State &glState,
                                  bool isCallValid,
                                  ShaderProgramID programPacked,
-                                 GLint location,
+                                 UniformLocation locationPacked,
                                  GLsizei bufSize,
                                  GLfloat *params,
                                  angle::ParamCapture *paramCapture);
 void CaptureGetnUniformiv_params(const State &glState,
                                  bool isCallValid,
                                  ShaderProgramID programPacked,
-                                 GLint location,
+                                 UniformLocation locationPacked,
                                  GLsizei bufSize,
                                  GLint *params,
                                  angle::ParamCapture *paramCapture);
 void CaptureGetnUniformuiv_params(const State &glState,
                                   bool isCallValid,
                                   ShaderProgramID programPacked,
-                                  GLint location,
+                                  UniformLocation locationPacked,
                                   GLsizei bufSize,
                                   GLuint *params,
                                   angle::ParamCapture *paramCapture);
diff --git a/src/libANGLE/capture_gles_3_2_params.cpp b/src/libANGLE/capture_gles_3_2_params.cpp
index cbd8877..6a391a7 100644
--- a/src/libANGLE/capture_gles_3_2_params.cpp
+++ b/src/libANGLE/capture_gles_3_2_params.cpp
@@ -286,7 +286,7 @@
 void CaptureGetnUniformfv_params(const State &glState,
                                  bool isCallValid,
                                  ShaderProgramID program,
-                                 GLint location,
+                                 UniformLocation location,
                                  GLsizei bufSize,
                                  GLfloat *params,
                                  ParamCapture *paramsParam)
@@ -297,7 +297,7 @@
 void CaptureGetnUniformiv_params(const State &glState,
                                  bool isCallValid,
                                  ShaderProgramID program,
-                                 GLint location,
+                                 UniformLocation location,
                                  GLsizei bufSize,
                                  GLint *params,
                                  ParamCapture *paramsParam)
@@ -308,7 +308,7 @@
 void CaptureGetnUniformuiv_params(const State &glState,
                                   bool isCallValid,
                                   ShaderProgramID program,
-                                  GLint location,
+                                  UniformLocation location,
                                   GLsizei bufSize,
                                   GLuint *params,
                                   ParamCapture *paramsParam)
diff --git a/src/libANGLE/capture_gles_ext_autogen.cpp b/src/libANGLE/capture_gles_ext_autogen.cpp
index 046d987..bbeb110 100644
--- a/src/libANGLE/capture_gles_ext_autogen.cpp
+++ b/src/libANGLE/capture_gles_ext_autogen.cpp
@@ -884,7 +884,7 @@
 CallCapture CaptureGetUniformfvRobustANGLE(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLfloat *params)
@@ -892,19 +892,19 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
 
     ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
     InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
-    CaptureGetUniformfvRobustANGLE_length(glState, isCallValid, programPacked, location, bufSize,
-                                          length, params, &lengthParam);
+    CaptureGetUniformfvRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
+                                          bufSize, length, params, &lengthParam);
     paramBuffer.addParam(std::move(lengthParam));
 
     ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
     InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
-    CaptureGetUniformfvRobustANGLE_params(glState, isCallValid, programPacked, location, bufSize,
-                                          length, params, &paramsParam);
+    CaptureGetUniformfvRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
+                                          bufSize, length, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
     return CallCapture(gl::EntryPoint::GetUniformfvRobustANGLE, std::move(paramBuffer));
@@ -913,7 +913,7 @@
 CallCapture CaptureGetUniformivRobustANGLE(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint *params)
@@ -921,19 +921,19 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
 
     ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
     InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
-    CaptureGetUniformivRobustANGLE_length(glState, isCallValid, programPacked, location, bufSize,
-                                          length, params, &lengthParam);
+    CaptureGetUniformivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
+                                          bufSize, length, params, &lengthParam);
     paramBuffer.addParam(std::move(lengthParam));
 
     ParamCapture paramsParam("params", ParamType::TGLintPointer);
     InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
-    CaptureGetUniformivRobustANGLE_params(glState, isCallValid, programPacked, location, bufSize,
-                                          length, params, &paramsParam);
+    CaptureGetUniformivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
+                                          bufSize, length, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
     return CallCapture(gl::EntryPoint::GetUniformivRobustANGLE, std::move(paramBuffer));
@@ -1620,7 +1620,7 @@
 CallCapture CaptureGetUniformuivRobustANGLE(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLuint *params)
@@ -1628,19 +1628,19 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
 
     ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
     InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
-    CaptureGetUniformuivRobustANGLE_length(glState, isCallValid, programPacked, location, bufSize,
-                                           length, params, &lengthParam);
+    CaptureGetUniformuivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
+                                           bufSize, length, params, &lengthParam);
     paramBuffer.addParam(std::move(lengthParam));
 
     ParamCapture paramsParam("params", ParamType::TGLuintPointer);
     InitParamValue(ParamType::TGLuintPointer, params, &paramsParam.value);
-    CaptureGetUniformuivRobustANGLE_params(glState, isCallValid, programPacked, location, bufSize,
-                                           length, params, &paramsParam);
+    CaptureGetUniformuivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
+                                           bufSize, length, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
     return CallCapture(gl::EntryPoint::GetUniformuivRobustANGLE, std::move(paramBuffer));
@@ -2131,7 +2131,7 @@
 CallCapture CaptureGetnUniformfvRobustANGLE(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLfloat *params)
@@ -2139,19 +2139,19 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
 
     ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
     InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
-    CaptureGetnUniformfvRobustANGLE_length(glState, isCallValid, programPacked, location, bufSize,
-                                           length, params, &lengthParam);
+    CaptureGetnUniformfvRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
+                                           bufSize, length, params, &lengthParam);
     paramBuffer.addParam(std::move(lengthParam));
 
     ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
     InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
-    CaptureGetnUniformfvRobustANGLE_params(glState, isCallValid, programPacked, location, bufSize,
-                                           length, params, &paramsParam);
+    CaptureGetnUniformfvRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
+                                           bufSize, length, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
     return CallCapture(gl::EntryPoint::GetnUniformfvRobustANGLE, std::move(paramBuffer));
@@ -2160,7 +2160,7 @@
 CallCapture CaptureGetnUniformivRobustANGLE(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLint *params)
@@ -2168,19 +2168,19 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
 
     ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
     InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
-    CaptureGetnUniformivRobustANGLE_length(glState, isCallValid, programPacked, location, bufSize,
-                                           length, params, &lengthParam);
+    CaptureGetnUniformivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
+                                           bufSize, length, params, &lengthParam);
     paramBuffer.addParam(std::move(lengthParam));
 
     ParamCapture paramsParam("params", ParamType::TGLintPointer);
     InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
-    CaptureGetnUniformivRobustANGLE_params(glState, isCallValid, programPacked, location, bufSize,
-                                           length, params, &paramsParam);
+    CaptureGetnUniformivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
+                                           bufSize, length, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
     return CallCapture(gl::EntryPoint::GetnUniformivRobustANGLE, std::move(paramBuffer));
@@ -2189,7 +2189,7 @@
 CallCapture CaptureGetnUniformuivRobustANGLE(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              GLuint *params)
@@ -2197,19 +2197,19 @@
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
 
     ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
     InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
-    CaptureGetnUniformuivRobustANGLE_length(glState, isCallValid, programPacked, location, bufSize,
-                                            length, params, &lengthParam);
+    CaptureGetnUniformuivRobustANGLE_length(glState, isCallValid, programPacked, locationPacked,
+                                            bufSize, length, params, &lengthParam);
     paramBuffer.addParam(std::move(lengthParam));
 
     ParamCapture paramsParam("params", ParamType::TGLuintPointer);
     InitParamValue(ParamType::TGLuintPointer, params, &paramsParam.value);
-    CaptureGetnUniformuivRobustANGLE_params(glState, isCallValid, programPacked, location, bufSize,
-                                            length, params, &paramsParam);
+    CaptureGetnUniformuivRobustANGLE_params(glState, isCallValid, programPacked, locationPacked,
+                                            bufSize, length, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
     return CallCapture(gl::EntryPoint::GetnUniformuivRobustANGLE, std::move(paramBuffer));
@@ -2685,18 +2685,18 @@
 CallCapture CaptureBindUniformLocationCHROMIUM(const State &glState,
                                                bool isCallValid,
                                                ShaderProgramID programPacked,
-                                               GLint location,
+                                               UniformLocation locationPacked,
                                                const GLchar *name)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
 
     ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
     InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
-    CaptureBindUniformLocationCHROMIUM_name(glState, isCallValid, programPacked, location, name,
-                                            &nameParam);
+    CaptureBindUniformLocationCHROMIUM_name(glState, isCallValid, programPacked, locationPacked,
+                                            name, &nameParam);
     paramBuffer.addParam(std::move(nameParam));
 
     return CallCapture(gl::EntryPoint::BindUniformLocationCHROMIUM, std::move(paramBuffer));
@@ -4296,20 +4296,20 @@
 CallCapture CaptureGetnUniformfvEXT(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLsizei bufSize,
                                     GLfloat *params)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
 
     ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
     InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
-    CaptureGetnUniformfvEXT_params(glState, isCallValid, programPacked, location, bufSize, params,
-                                   &paramsParam);
+    CaptureGetnUniformfvEXT_params(glState, isCallValid, programPacked, locationPacked, bufSize,
+                                   params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
     return CallCapture(gl::EntryPoint::GetnUniformfvEXT, std::move(paramBuffer));
@@ -4318,20 +4318,20 @@
 CallCapture CaptureGetnUniformivEXT(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLsizei bufSize,
                                     GLint *params)
 {
     ParamBuffer paramBuffer;
 
     paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
-    paramBuffer.addValueParam("location", ParamType::TGLint, location);
+    paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
     paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
 
     ParamCapture paramsParam("params", ParamType::TGLintPointer);
     InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
-    CaptureGetnUniformivEXT_params(glState, isCallValid, programPacked, location, bufSize, params,
-                                   &paramsParam);
+    CaptureGetnUniformivEXT_params(glState, isCallValid, programPacked, locationPacked, bufSize,
+                                   params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
     return CallCapture(gl::EntryPoint::GetnUniformivEXT, std::move(paramBuffer));
diff --git a/src/libANGLE/capture_gles_ext_autogen.h b/src/libANGLE/capture_gles_ext_autogen.h
index 1bd5ae9..951ee25 100644
--- a/src/libANGLE/capture_gles_ext_autogen.h
+++ b/src/libANGLE/capture_gles_ext_autogen.h
@@ -272,14 +272,14 @@
 angle::CallCapture CaptureGetUniformfvRobustANGLE(const State &glState,
                                                   bool isCallValid,
                                                   ShaderProgramID programPacked,
-                                                  GLint location,
+                                                  UniformLocation locationPacked,
                                                   GLsizei bufSize,
                                                   GLsizei *length,
                                                   GLfloat *params);
 angle::CallCapture CaptureGetUniformivRobustANGLE(const State &glState,
                                                   bool isCallValid,
                                                   ShaderProgramID programPacked,
-                                                  GLint location,
+                                                  UniformLocation locationPacked,
                                                   GLsizei bufSize,
                                                   GLsizei *length,
                                                   GLint *params);
@@ -482,7 +482,7 @@
 angle::CallCapture CaptureGetUniformuivRobustANGLE(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
-                                                   GLint location,
+                                                   UniformLocation locationPacked,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLuint *params);
@@ -607,21 +607,21 @@
 angle::CallCapture CaptureGetnUniformfvRobustANGLE(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
-                                                   GLint location,
+                                                   UniformLocation locationPacked,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLfloat *params);
 angle::CallCapture CaptureGetnUniformivRobustANGLE(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
-                                                   GLint location,
+                                                   UniformLocation locationPacked,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLint *params);
 angle::CallCapture CaptureGetnUniformuivRobustANGLE(const State &glState,
                                                     bool isCallValid,
                                                     ShaderProgramID programPacked,
-                                                    GLint location,
+                                                    UniformLocation locationPacked,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLuint *params);
@@ -764,7 +764,7 @@
 angle::CallCapture CaptureBindUniformLocationCHROMIUM(const State &glState,
                                                       bool isCallValid,
                                                       ShaderProgramID programPacked,
-                                                      GLint location,
+                                                      UniformLocation locationPacked,
                                                       const GLchar *name);
 
 // GL_CHROMIUM_copy_compressed_texture
@@ -1259,13 +1259,13 @@
 angle::CallCapture CaptureGetnUniformfvEXT(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLsizei bufSize,
                                            GLfloat *params);
 angle::CallCapture CaptureGetnUniformivEXT(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLsizei bufSize,
                                            GLint *params);
 angle::CallCapture CaptureReadnPixelsEXT(const State &glState,
@@ -2267,7 +2267,7 @@
 void CaptureGetUniformfvRobustANGLE_length(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLfloat *params,
@@ -2275,7 +2275,7 @@
 void CaptureGetUniformfvRobustANGLE_params(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLfloat *params,
@@ -2283,7 +2283,7 @@
 void CaptureGetUniformivRobustANGLE_length(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint *params,
@@ -2291,7 +2291,7 @@
 void CaptureGetUniformivRobustANGLE_params(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID programPacked,
-                                           GLint location,
+                                           UniformLocation locationPacked,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint *params,
@@ -2639,7 +2639,7 @@
 void CaptureGetUniformuivRobustANGLE_length(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLuint *params,
@@ -2647,7 +2647,7 @@
 void CaptureGetUniformuivRobustANGLE_params(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLuint *params,
@@ -2937,7 +2937,7 @@
 void CaptureGetnUniformfvRobustANGLE_length(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLfloat *params,
@@ -2945,7 +2945,7 @@
 void CaptureGetnUniformfvRobustANGLE_params(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLfloat *params,
@@ -2953,7 +2953,7 @@
 void CaptureGetnUniformivRobustANGLE_length(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLint *params,
@@ -2961,7 +2961,7 @@
 void CaptureGetnUniformivRobustANGLE_params(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
-                                            GLint location,
+                                            UniformLocation locationPacked,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLint *params,
@@ -2969,7 +2969,7 @@
 void CaptureGetnUniformuivRobustANGLE_length(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              GLuint *params,
@@ -2977,7 +2977,7 @@
 void CaptureGetnUniformuivRobustANGLE_params(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              GLuint *params,
@@ -3159,7 +3159,7 @@
 void CaptureBindUniformLocationCHROMIUM_name(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID programPacked,
-                                             GLint location,
+                                             UniformLocation locationPacked,
                                              const GLchar *name,
                                              angle::ParamCapture *paramCapture);
 void CaptureMatrixLoadfCHROMIUM_matrix(const State &glState,
@@ -3528,14 +3528,14 @@
 void CaptureGetnUniformfvEXT_params(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLsizei bufSize,
                                     GLfloat *params,
                                     angle::ParamCapture *paramCapture);
 void CaptureGetnUniformivEXT_params(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
-                                    GLint location,
+                                    UniformLocation locationPacked,
                                     GLsizei bufSize,
                                     GLint *params,
                                     angle::ParamCapture *paramCapture);
diff --git a/src/libANGLE/capture_gles_ext_params.cpp b/src/libANGLE/capture_gles_ext_params.cpp
index a224315..b5c94dd 100644
--- a/src/libANGLE/capture_gles_ext_params.cpp
+++ b/src/libANGLE/capture_gles_ext_params.cpp
@@ -666,7 +666,7 @@
 void CaptureGetUniformfvRobustANGLE_length(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID program,
-                                           GLint location,
+                                           UniformLocation location,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLfloat *params,
@@ -678,7 +678,7 @@
 void CaptureGetUniformfvRobustANGLE_params(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID program,
-                                           GLint location,
+                                           UniformLocation location,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLfloat *params,
@@ -690,7 +690,7 @@
 void CaptureGetUniformivRobustANGLE_length(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID program,
-                                           GLint location,
+                                           UniformLocation location,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint *params,
@@ -702,7 +702,7 @@
 void CaptureGetUniformivRobustANGLE_params(const State &glState,
                                            bool isCallValid,
                                            ShaderProgramID program,
-                                           GLint location,
+                                           UniformLocation location,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint *params,
@@ -1190,7 +1190,7 @@
 void CaptureGetUniformuivRobustANGLE_length(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID program,
-                                            GLint location,
+                                            UniformLocation location,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLuint *params,
@@ -1202,7 +1202,7 @@
 void CaptureGetUniformuivRobustANGLE_params(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID program,
-                                            GLint location,
+                                            UniformLocation location,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLuint *params,
@@ -1624,7 +1624,7 @@
 void CaptureGetnUniformfvRobustANGLE_length(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID program,
-                                            GLint location,
+                                            UniformLocation location,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLfloat *params,
@@ -1636,7 +1636,7 @@
 void CaptureGetnUniformfvRobustANGLE_params(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID program,
-                                            GLint location,
+                                            UniformLocation location,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLfloat *params,
@@ -1648,7 +1648,7 @@
 void CaptureGetnUniformivRobustANGLE_length(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID program,
-                                            GLint location,
+                                            UniformLocation location,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLint *params,
@@ -1660,7 +1660,7 @@
 void CaptureGetnUniformivRobustANGLE_params(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID program,
-                                            GLint location,
+                                            UniformLocation location,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLint *params,
@@ -1672,7 +1672,7 @@
 void CaptureGetnUniformuivRobustANGLE_length(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID program,
-                                             GLint location,
+                                             UniformLocation location,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              GLuint *params,
@@ -1684,7 +1684,7 @@
 void CaptureGetnUniformuivRobustANGLE_params(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID program,
-                                             GLint location,
+                                             UniformLocation location,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              GLuint *params,
@@ -1962,7 +1962,7 @@
 void CaptureBindUniformLocationCHROMIUM_name(const State &glState,
                                              bool isCallValid,
                                              ShaderProgramID program,
-                                             GLint location,
+                                             UniformLocation location,
                                              const GLchar *name,
                                              ParamCapture *paramCapture)
 {
@@ -2445,7 +2445,7 @@
 void CaptureGetnUniformfvEXT_params(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID program,
-                                    GLint location,
+                                    UniformLocation location,
                                     GLsizei bufSize,
                                     GLfloat *params,
                                     ParamCapture *paramCapture)
@@ -2456,7 +2456,7 @@
 void CaptureGetnUniformivEXT_params(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID program,
-                                    GLint location,
+                                    UniformLocation location,
                                     GLsizei bufSize,
                                     GLint *params,
                                     ParamCapture *paramCapture)
diff --git a/src/libANGLE/frame_capture_replay_autogen.cpp b/src/libANGLE/frame_capture_replay_autogen.cpp
index f6e4c51..1fc8469 100644
--- a/src/libANGLE/frame_capture_replay_autogen.cpp
+++ b/src/libANGLE/frame_capture_replay_autogen.cpp
@@ -1609,21 +1609,24 @@
         case gl::EntryPoint::GetUniformfv:
             context->getUniformfv(params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                                       .value.ShaderProgramIDVal,
-                                  params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                                  params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                                      .value.UniformLocationVal,
                                   replayContext->getReadBufferPointer<GLfloat *>(
                                       params.getParam("params", ParamType::TGLfloatPointer, 2)));
             break;
         case gl::EntryPoint::GetUniformiv:
             context->getUniformiv(params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                                       .value.ShaderProgramIDVal,
-                                  params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                                  params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                                      .value.UniformLocationVal,
                                   replayContext->getReadBufferPointer<GLint *>(
                                       params.getParam("params", ParamType::TGLintPointer, 2)));
             break;
         case gl::EntryPoint::GetUniformuiv:
             context->getUniformuiv(params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                                        .value.ShaderProgramIDVal,
-                                   params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                                   params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                                       .value.UniformLocationVal,
                                    replayContext->getReadBufferPointer<GLuint *>(
                                        params.getParam("params", ParamType::TGLuintPointer, 2)));
             break;
@@ -1666,7 +1669,8 @@
             context->getnUniformfv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("bufSize", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 replayContext->getReadBufferPointer<GLfloat *>(
                     params.getParam("params", ParamType::TGLfloatPointer, 3)));
@@ -1675,7 +1679,8 @@
             context->getnUniformiv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("bufSize", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 replayContext->getReadBufferPointer<GLint *>(
                     params.getParam("params", ParamType::TGLintPointer, 3)));
@@ -1684,7 +1689,8 @@
             context->getnUniformuiv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("bufSize", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 replayContext->getReadBufferPointer<GLuint *>(
                     params.getParam("params", ParamType::TGLuintPointer, 3)));
@@ -2094,14 +2100,16 @@
             context->programUniform1f(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("v0", ParamType::TGLfloat, 2).value.GLfloatVal);
             break;
         case gl::EntryPoint::ProgramUniform1fv:
             context->programUniform1fv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
                     params.getParam("value", ParamType::TGLfloatConstPointer, 3)));
@@ -2110,14 +2118,16 @@
             context->programUniform1i(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("v0", ParamType::TGLint, 2).value.GLintVal);
             break;
         case gl::EntryPoint::ProgramUniform1iv:
             context->programUniform1iv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 replayContext->getAsConstPointer<const GLint *>(
                     params.getParam("value", ParamType::TGLintConstPointer, 3)));
@@ -2126,14 +2136,16 @@
             context->programUniform1ui(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("v0", ParamType::TGLuint, 2).value.GLuintVal);
             break;
         case gl::EntryPoint::ProgramUniform1uiv:
             context->programUniform1uiv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 replayContext->getAsConstPointer<const GLuint *>(
                     params.getParam("value", ParamType::TGLuintConstPointer, 3)));
@@ -2142,7 +2154,8 @@
             context->programUniform2f(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("v0", ParamType::TGLfloat, 2).value.GLfloatVal,
                 params.getParam("v1", ParamType::TGLfloat, 3).value.GLfloatVal);
             break;
@@ -2150,7 +2163,8 @@
             context->programUniform2fv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
                     params.getParam("value", ParamType::TGLfloatConstPointer, 3)));
@@ -2159,7 +2173,8 @@
             context->programUniform2i(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("v0", ParamType::TGLint, 2).value.GLintVal,
                 params.getParam("v1", ParamType::TGLint, 3).value.GLintVal);
             break;
@@ -2167,7 +2182,8 @@
             context->programUniform2iv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 replayContext->getAsConstPointer<const GLint *>(
                     params.getParam("value", ParamType::TGLintConstPointer, 3)));
@@ -2176,7 +2192,8 @@
             context->programUniform2ui(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("v0", ParamType::TGLuint, 2).value.GLuintVal,
                 params.getParam("v1", ParamType::TGLuint, 3).value.GLuintVal);
             break;
@@ -2184,7 +2201,8 @@
             context->programUniform2uiv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 replayContext->getAsConstPointer<const GLuint *>(
                     params.getParam("value", ParamType::TGLuintConstPointer, 3)));
@@ -2193,7 +2211,8 @@
             context->programUniform3f(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("v0", ParamType::TGLfloat, 2).value.GLfloatVal,
                 params.getParam("v1", ParamType::TGLfloat, 3).value.GLfloatVal,
                 params.getParam("v2", ParamType::TGLfloat, 4).value.GLfloatVal);
@@ -2202,7 +2221,8 @@
             context->programUniform3fv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
                     params.getParam("value", ParamType::TGLfloatConstPointer, 3)));
@@ -2211,7 +2231,8 @@
             context->programUniform3i(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("v0", ParamType::TGLint, 2).value.GLintVal,
                 params.getParam("v1", ParamType::TGLint, 3).value.GLintVal,
                 params.getParam("v2", ParamType::TGLint, 4).value.GLintVal);
@@ -2220,7 +2241,8 @@
             context->programUniform3iv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 replayContext->getAsConstPointer<const GLint *>(
                     params.getParam("value", ParamType::TGLintConstPointer, 3)));
@@ -2229,7 +2251,8 @@
             context->programUniform3ui(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("v0", ParamType::TGLuint, 2).value.GLuintVal,
                 params.getParam("v1", ParamType::TGLuint, 3).value.GLuintVal,
                 params.getParam("v2", ParamType::TGLuint, 4).value.GLuintVal);
@@ -2238,7 +2261,8 @@
             context->programUniform3uiv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 replayContext->getAsConstPointer<const GLuint *>(
                     params.getParam("value", ParamType::TGLuintConstPointer, 3)));
@@ -2247,7 +2271,8 @@
             context->programUniform4f(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("v0", ParamType::TGLfloat, 2).value.GLfloatVal,
                 params.getParam("v1", ParamType::TGLfloat, 3).value.GLfloatVal,
                 params.getParam("v2", ParamType::TGLfloat, 4).value.GLfloatVal,
@@ -2257,7 +2282,8 @@
             context->programUniform4fv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
                     params.getParam("value", ParamType::TGLfloatConstPointer, 3)));
@@ -2266,7 +2292,8 @@
             context->programUniform4i(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("v0", ParamType::TGLint, 2).value.GLintVal,
                 params.getParam("v1", ParamType::TGLint, 3).value.GLintVal,
                 params.getParam("v2", ParamType::TGLint, 4).value.GLintVal,
@@ -2276,7 +2303,8 @@
             context->programUniform4iv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 replayContext->getAsConstPointer<const GLint *>(
                     params.getParam("value", ParamType::TGLintConstPointer, 3)));
@@ -2285,7 +2313,8 @@
             context->programUniform4ui(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("v0", ParamType::TGLuint, 2).value.GLuintVal,
                 params.getParam("v1", ParamType::TGLuint, 3).value.GLuintVal,
                 params.getParam("v2", ParamType::TGLuint, 4).value.GLuintVal,
@@ -2295,7 +2324,8 @@
             context->programUniform4uiv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 replayContext->getAsConstPointer<const GLuint *>(
                     params.getParam("value", ParamType::TGLuintConstPointer, 3)));
@@ -2304,7 +2334,8 @@
             context->programUniformMatrix2fv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 3).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
@@ -2314,7 +2345,8 @@
             context->programUniformMatrix2x3fv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 3).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
@@ -2324,7 +2356,8 @@
             context->programUniformMatrix2x4fv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 3).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
@@ -2334,7 +2367,8 @@
             context->programUniformMatrix3fv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 3).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
@@ -2344,7 +2378,8 @@
             context->programUniformMatrix3x2fv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 3).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
@@ -2354,7 +2389,8 @@
             context->programUniformMatrix3x4fv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 3).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
@@ -2364,7 +2400,8 @@
             context->programUniformMatrix4fv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 3).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
@@ -2374,7 +2411,8 @@
             context->programUniformMatrix4x2fv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 3).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
@@ -2384,7 +2422,8 @@
             context->programUniformMatrix4x3fv(
                 params.getParam("programPacked", ParamType::TShaderProgramID, 0)
                     .value.ShaderProgramIDVal,
-                params.getParam("location", ParamType::TGLint, 1).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 1)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 3).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
@@ -2872,139 +2911,163 @@
                                 params.getParam("z", ParamType::TGLfixed, 2).value.GLfixedVal);
             break;
         case gl::EntryPoint::Uniform1f:
-            context->uniform1f(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform1f(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                   .value.UniformLocationVal,
                                params.getParam("v0", ParamType::TGLfloat, 1).value.GLfloatVal);
             break;
         case gl::EntryPoint::Uniform1fv:
-            context->uniform1fv(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform1fv(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                    .value.UniformLocationVal,
                                 params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                                 replayContext->getAsConstPointer<const GLfloat *>(
                                     params.getParam("value", ParamType::TGLfloatConstPointer, 2)));
             break;
         case gl::EntryPoint::Uniform1i:
-            context->uniform1i(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform1i(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                   .value.UniformLocationVal,
                                params.getParam("v0", ParamType::TGLint, 1).value.GLintVal);
             break;
         case gl::EntryPoint::Uniform1iv:
-            context->uniform1iv(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform1iv(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                    .value.UniformLocationVal,
                                 params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                                 replayContext->getAsConstPointer<const GLint *>(
                                     params.getParam("value", ParamType::TGLintConstPointer, 2)));
             break;
         case gl::EntryPoint::Uniform1ui:
-            context->uniform1ui(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform1ui(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                    .value.UniformLocationVal,
                                 params.getParam("v0", ParamType::TGLuint, 1).value.GLuintVal);
             break;
         case gl::EntryPoint::Uniform1uiv:
-            context->uniform1uiv(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform1uiv(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                     .value.UniformLocationVal,
                                  params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                                  replayContext->getAsConstPointer<const GLuint *>(
                                      params.getParam("value", ParamType::TGLuintConstPointer, 2)));
             break;
         case gl::EntryPoint::Uniform2f:
-            context->uniform2f(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform2f(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                   .value.UniformLocationVal,
                                params.getParam("v0", ParamType::TGLfloat, 1).value.GLfloatVal,
                                params.getParam("v1", ParamType::TGLfloat, 2).value.GLfloatVal);
             break;
         case gl::EntryPoint::Uniform2fv:
-            context->uniform2fv(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform2fv(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                    .value.UniformLocationVal,
                                 params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                                 replayContext->getAsConstPointer<const GLfloat *>(
                                     params.getParam("value", ParamType::TGLfloatConstPointer, 2)));
             break;
         case gl::EntryPoint::Uniform2i:
-            context->uniform2i(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform2i(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                   .value.UniformLocationVal,
                                params.getParam("v0", ParamType::TGLint, 1).value.GLintVal,
                                params.getParam("v1", ParamType::TGLint, 2).value.GLintVal);
             break;
         case gl::EntryPoint::Uniform2iv:
-            context->uniform2iv(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform2iv(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                    .value.UniformLocationVal,
                                 params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                                 replayContext->getAsConstPointer<const GLint *>(
                                     params.getParam("value", ParamType::TGLintConstPointer, 2)));
             break;
         case gl::EntryPoint::Uniform2ui:
-            context->uniform2ui(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform2ui(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                    .value.UniformLocationVal,
                                 params.getParam("v0", ParamType::TGLuint, 1).value.GLuintVal,
                                 params.getParam("v1", ParamType::TGLuint, 2).value.GLuintVal);
             break;
         case gl::EntryPoint::Uniform2uiv:
-            context->uniform2uiv(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform2uiv(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                     .value.UniformLocationVal,
                                  params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                                  replayContext->getAsConstPointer<const GLuint *>(
                                      params.getParam("value", ParamType::TGLuintConstPointer, 2)));
             break;
         case gl::EntryPoint::Uniform3f:
-            context->uniform3f(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform3f(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                   .value.UniformLocationVal,
                                params.getParam("v0", ParamType::TGLfloat, 1).value.GLfloatVal,
                                params.getParam("v1", ParamType::TGLfloat, 2).value.GLfloatVal,
                                params.getParam("v2", ParamType::TGLfloat, 3).value.GLfloatVal);
             break;
         case gl::EntryPoint::Uniform3fv:
-            context->uniform3fv(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform3fv(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                    .value.UniformLocationVal,
                                 params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                                 replayContext->getAsConstPointer<const GLfloat *>(
                                     params.getParam("value", ParamType::TGLfloatConstPointer, 2)));
             break;
         case gl::EntryPoint::Uniform3i:
-            context->uniform3i(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform3i(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                   .value.UniformLocationVal,
                                params.getParam("v0", ParamType::TGLint, 1).value.GLintVal,
                                params.getParam("v1", ParamType::TGLint, 2).value.GLintVal,
                                params.getParam("v2", ParamType::TGLint, 3).value.GLintVal);
             break;
         case gl::EntryPoint::Uniform3iv:
-            context->uniform3iv(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform3iv(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                    .value.UniformLocationVal,
                                 params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                                 replayContext->getAsConstPointer<const GLint *>(
                                     params.getParam("value", ParamType::TGLintConstPointer, 2)));
             break;
         case gl::EntryPoint::Uniform3ui:
-            context->uniform3ui(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform3ui(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                    .value.UniformLocationVal,
                                 params.getParam("v0", ParamType::TGLuint, 1).value.GLuintVal,
                                 params.getParam("v1", ParamType::TGLuint, 2).value.GLuintVal,
                                 params.getParam("v2", ParamType::TGLuint, 3).value.GLuintVal);
             break;
         case gl::EntryPoint::Uniform3uiv:
-            context->uniform3uiv(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform3uiv(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                     .value.UniformLocationVal,
                                  params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                                  replayContext->getAsConstPointer<const GLuint *>(
                                      params.getParam("value", ParamType::TGLuintConstPointer, 2)));
             break;
         case gl::EntryPoint::Uniform4f:
-            context->uniform4f(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform4f(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                   .value.UniformLocationVal,
                                params.getParam("v0", ParamType::TGLfloat, 1).value.GLfloatVal,
                                params.getParam("v1", ParamType::TGLfloat, 2).value.GLfloatVal,
                                params.getParam("v2", ParamType::TGLfloat, 3).value.GLfloatVal,
                                params.getParam("v3", ParamType::TGLfloat, 4).value.GLfloatVal);
             break;
         case gl::EntryPoint::Uniform4fv:
-            context->uniform4fv(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform4fv(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                    .value.UniformLocationVal,
                                 params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                                 replayContext->getAsConstPointer<const GLfloat *>(
                                     params.getParam("value", ParamType::TGLfloatConstPointer, 2)));
             break;
         case gl::EntryPoint::Uniform4i:
-            context->uniform4i(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform4i(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                   .value.UniformLocationVal,
                                params.getParam("v0", ParamType::TGLint, 1).value.GLintVal,
                                params.getParam("v1", ParamType::TGLint, 2).value.GLintVal,
                                params.getParam("v2", ParamType::TGLint, 3).value.GLintVal,
                                params.getParam("v3", ParamType::TGLint, 4).value.GLintVal);
             break;
         case gl::EntryPoint::Uniform4iv:
-            context->uniform4iv(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform4iv(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                    .value.UniformLocationVal,
                                 params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                                 replayContext->getAsConstPointer<const GLint *>(
                                     params.getParam("value", ParamType::TGLintConstPointer, 2)));
             break;
         case gl::EntryPoint::Uniform4ui:
-            context->uniform4ui(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform4ui(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                    .value.UniformLocationVal,
                                 params.getParam("v0", ParamType::TGLuint, 1).value.GLuintVal,
                                 params.getParam("v1", ParamType::TGLuint, 2).value.GLuintVal,
                                 params.getParam("v2", ParamType::TGLuint, 3).value.GLuintVal,
                                 params.getParam("v3", ParamType::TGLuint, 4).value.GLuintVal);
             break;
         case gl::EntryPoint::Uniform4uiv:
-            context->uniform4uiv(params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+            context->uniform4uiv(params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                                     .value.UniformLocationVal,
                                  params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                                  replayContext->getAsConstPointer<const GLuint *>(
                                      params.getParam("value", ParamType::TGLuintConstPointer, 2)));
@@ -3018,7 +3081,8 @@
             break;
         case gl::EntryPoint::UniformMatrix2fv:
             context->uniformMatrix2fv(
-                params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 2).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
@@ -3026,7 +3090,8 @@
             break;
         case gl::EntryPoint::UniformMatrix2x3fv:
             context->uniformMatrix2x3fv(
-                params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 2).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
@@ -3034,7 +3099,8 @@
             break;
         case gl::EntryPoint::UniformMatrix2x4fv:
             context->uniformMatrix2x4fv(
-                params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 2).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
@@ -3042,7 +3108,8 @@
             break;
         case gl::EntryPoint::UniformMatrix3fv:
             context->uniformMatrix3fv(
-                params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 2).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
@@ -3050,7 +3117,8 @@
             break;
         case gl::EntryPoint::UniformMatrix3x2fv:
             context->uniformMatrix3x2fv(
-                params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 2).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
@@ -3058,7 +3126,8 @@
             break;
         case gl::EntryPoint::UniformMatrix3x4fv:
             context->uniformMatrix3x4fv(
-                params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 2).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
@@ -3066,7 +3135,8 @@
             break;
         case gl::EntryPoint::UniformMatrix4fv:
             context->uniformMatrix4fv(
-                params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 2).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
@@ -3074,7 +3144,8 @@
             break;
         case gl::EntryPoint::UniformMatrix4x2fv:
             context->uniformMatrix4x2fv(
-                params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 2).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
@@ -3082,7 +3153,8 @@
             break;
         case gl::EntryPoint::UniformMatrix4x3fv:
             context->uniformMatrix4x3fv(
-                params.getParam("location", ParamType::TGLint, 0).value.GLintVal,
+                params.getParam("locationPacked", ParamType::TUniformLocation, 0)
+                    .value.UniformLocationVal,
                 params.getParam("count", ParamType::TGLsizei, 1).value.GLsizeiVal,
                 params.getParam("transpose", ParamType::TGLboolean, 2).value.GLbooleanVal,
                 replayContext->getAsConstPointer<const GLfloat *>(
diff --git a/src/libANGLE/frame_capture_utils_autogen.cpp b/src/libANGLE/frame_capture_utils_autogen.cpp
index e22341f..8e96e3a 100644
--- a/src/libANGLE/frame_capture_utils_autogen.cpp
+++ b/src/libANGLE/frame_capture_utils_autogen.cpp
@@ -406,6 +406,9 @@
             WriteParamValueToStream<ParamType::TTransformFeedbackIDPointer>(
                 os, paramValue.TransformFeedbackIDPointerVal);
             break;
+        case ParamType::TUniformLocation:
+            WriteParamValueToStream<ParamType::TUniformLocation>(os, paramValue.UniformLocationVal);
+            break;
         case ParamType::TVertexArrayID:
             WriteParamValueToStream<ParamType::TVertexArrayID>(os, paramValue.VertexArrayIDVal);
             break;
@@ -670,6 +673,8 @@
             return "const GLuint *";
         case ParamType::TTransformFeedbackIDPointer:
             return "GLuint *";
+        case ParamType::TUniformLocation:
+            return "GLenum";
         case ParamType::TVertexArrayID:
             return "GLuint";
         case ParamType::TVertexArrayIDConstPointer:
diff --git a/src/libANGLE/frame_capture_utils_autogen.h b/src/libANGLE/frame_capture_utils_autogen.h
index 6798952..06e2608 100644
--- a/src/libANGLE/frame_capture_utils_autogen.h
+++ b/src/libANGLE/frame_capture_utils_autogen.h
@@ -129,6 +129,7 @@
     TTransformFeedbackID,
     TTransformFeedbackIDConstPointer,
     TTransformFeedbackIDPointer,
+    TUniformLocation,
     TVertexArrayID,
     TVertexArrayIDConstPointer,
     TVertexArrayIDPointer,
@@ -139,7 +140,7 @@
     TvoidPointerPointer,
 };
 
-constexpr uint32_t kParamTypeCount = 120;
+constexpr uint32_t kParamTypeCount = 121;
 
 union ParamValue
 {
@@ -255,6 +256,7 @@
     gl::TransformFeedbackID TransformFeedbackIDVal;
     const gl::TransformFeedbackID *TransformFeedbackIDConstPointerVal;
     gl::TransformFeedbackID *TransformFeedbackIDPointerVal;
+    gl::UniformLocation UniformLocationVal;
     gl::VertexArrayID VertexArrayIDVal;
     const gl::VertexArrayID *VertexArrayIDConstPointerVal;
     gl::VertexArrayID *VertexArrayIDPointerVal;
@@ -1012,6 +1014,13 @@
 }
 
 template <>
+inline gl::UniformLocation GetParamVal<ParamType::TUniformLocation, gl::UniformLocation>(
+    const ParamValue &value)
+{
+    return value.UniformLocationVal;
+}
+
+template <>
 inline gl::VertexArrayID GetParamVal<ParamType::TVertexArrayID, gl::VertexArrayID>(
     const ParamValue &value)
 {
@@ -1300,6 +1309,8 @@
             return GetParamVal<ParamType::TTransformFeedbackIDConstPointer, T>(value);
         case ParamType::TTransformFeedbackIDPointer:
             return GetParamVal<ParamType::TTransformFeedbackIDPointer, T>(value);
+        case ParamType::TUniformLocation:
+            return GetParamVal<ParamType::TUniformLocation, T>(value);
         case ParamType::TVertexArrayID:
             return GetParamVal<ParamType::TVertexArrayID, T>(value);
         case ParamType::TVertexArrayIDConstPointer:
@@ -2045,6 +2056,13 @@
 }
 
 template <>
+inline void SetParamVal<ParamType::TUniformLocation>(gl::UniformLocation valueIn,
+                                                     ParamValue *valueOut)
+{
+    valueOut->UniformLocationVal = valueIn;
+}
+
+template <>
 inline void SetParamVal<ParamType::TVertexArrayID>(gl::VertexArrayID valueIn, ParamValue *valueOut)
 {
     valueOut->VertexArrayIDVal = valueIn;
@@ -2443,6 +2461,9 @@
         case ParamType::TTransformFeedbackIDPointer:
             SetParamVal<ParamType::TTransformFeedbackIDPointer>(valueIn, valueOut);
             break;
+        case ParamType::TUniformLocation:
+            SetParamVal<ParamType::TUniformLocation>(valueIn, valueOut);
+            break;
         case ParamType::TVertexArrayID:
             SetParamVal<ParamType::TVertexArrayID>(valueIn, valueOut);
             break;
diff --git a/src/libANGLE/queryutils.cpp b/src/libANGLE/queryutils.cpp
index d3416f5..6cf8b44 100644
--- a/src/libANGLE/queryutils.cpp
+++ b/src/libANGLE/queryutils.cpp
@@ -1729,7 +1729,7 @@
             return GetCommonVariableProperty(uniform, resourceProp);
 
         case GL_LOCATION:
-            return program->getUniformLocation(uniform.name);
+            return program->getUniformLocation(uniform.name).value;
 
         case GL_BLOCK_INDEX:
             return (uniform.isAtomicCounter() ? -1 : uniform.bufferIndex);
@@ -1904,7 +1904,7 @@
             return program->getOutputResourceLocation(name);
 
         case GL_UNIFORM:
-            return program->getUniformLocation(name);
+            return program->getUniformLocation(name).value;
 
         default:
             UNREACHABLE();
diff --git a/src/libANGLE/validationES.cpp b/src/libANGLE/validationES.cpp
index f828eff..77a1c70 100644
--- a/src/libANGLE/validationES.cpp
+++ b/src/libANGLE/validationES.cpp
@@ -2108,7 +2108,7 @@
 
 bool ValidateUniformCommonBase(const Context *context,
                                const Program *program,
-                               GLint location,
+                               UniformLocation location,
                                GLsizei count,
                                const LinkedUniform **uniformOut)
 {
@@ -2131,14 +2131,14 @@
         return false;
     }
 
-    if (location == -1)
+    if (location.value == -1)
     {
         // Silently ignore the uniform command
         return false;
     }
 
     const auto &uniformLocations = program->getUniformLocations();
-    size_t castedLocation        = static_cast<size_t>(location);
+    size_t castedLocation        = static_cast<size_t>(location.value);
     if (castedLocation >= uniformLocations.size())
     {
         context->validationError(GL_INVALID_OPERATION, kInvalidUniformLocation);
@@ -2215,7 +2215,10 @@
     return false;
 }
 
-bool ValidateUniform(const Context *context, GLenum valueType, GLint location, GLsizei count)
+bool ValidateUniform(const Context *context,
+                     GLenum valueType,
+                     UniformLocation location,
+                     GLsizei count)
 {
     const LinkedUniform *uniform = nullptr;
     Program *programObject       = context->getState().getLinkedProgram(context);
@@ -2223,7 +2226,10 @@
            ValidateUniformValue(context, valueType, uniform->type);
 }
 
-bool ValidateUniform1iv(const Context *context, GLint location, GLsizei count, const GLint *value)
+bool ValidateUniform1iv(const Context *context,
+                        UniformLocation location,
+                        GLsizei count,
+                        const GLint *value)
 {
     const LinkedUniform *uniform = nullptr;
     Program *programObject       = context->getState().getLinkedProgram(context);
@@ -2233,7 +2239,7 @@
 
 bool ValidateUniformMatrix(const Context *context,
                            GLenum valueType,
-                           GLint location,
+                           UniformLocation location,
                            GLsizei count,
                            GLboolean transpose)
 {
@@ -3103,7 +3109,9 @@
     return true;
 }
 
-bool ValidateGetUniformBase(const Context *context, ShaderProgramID program, GLint location)
+bool ValidateGetUniformBase(const Context *context,
+                            ShaderProgramID program,
+                            UniformLocation location)
 {
     if (program.value == 0)
     {
@@ -3134,7 +3142,7 @@
 
 static bool ValidateSizedGetUniform(const Context *context,
                                     ShaderProgramID program,
-                                    GLint location,
+                                    UniformLocation location,
                                     GLsizei bufSize,
                                     GLsizei *length)
 {
@@ -3175,7 +3183,7 @@
 
 bool ValidateGetnUniformfvEXT(const Context *context,
                               ShaderProgramID program,
-                              GLint location,
+                              UniformLocation location,
                               GLsizei bufSize,
                               const GLfloat *params)
 {
@@ -3184,7 +3192,7 @@
 
 bool ValidateGetnUniformfvRobustANGLE(const Context *context,
                                       ShaderProgramID program,
-                                      GLint location,
+                                      UniformLocation location,
                                       GLsizei bufSize,
                                       const GLsizei *length,
                                       const GLfloat *params)
@@ -3195,7 +3203,7 @@
 
 bool ValidateGetnUniformivEXT(const Context *context,
                               ShaderProgramID program,
-                              GLint location,
+                              UniformLocation location,
                               GLsizei bufSize,
                               const GLint *params)
 {
@@ -3204,7 +3212,7 @@
 
 bool ValidateGetnUniformivRobustANGLE(const Context *context,
                                       ShaderProgramID program,
-                                      GLint location,
+                                      UniformLocation location,
                                       GLsizei bufSize,
                                       const GLsizei *length,
                                       const GLint *params)
@@ -3215,7 +3223,7 @@
 
 bool ValidateGetnUniformuivRobustANGLE(const Context *context,
                                        ShaderProgramID program,
-                                       GLint location,
+                                       UniformLocation location,
                                        GLsizei bufSize,
                                        const GLsizei *length,
                                        const GLuint *params)
@@ -3226,7 +3234,7 @@
 
 bool ValidateGetUniformfvRobustANGLE(const Context *context,
                                      ShaderProgramID program,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei bufSize,
                                      const GLsizei *length,
                                      const GLfloat *params)
@@ -3251,7 +3259,7 @@
 
 bool ValidateGetUniformivRobustANGLE(const Context *context,
                                      ShaderProgramID program,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei bufSize,
                                      const GLsizei *length,
                                      const GLint *params)
@@ -3276,7 +3284,7 @@
 
 bool ValidateGetUniformuivRobustANGLE(const Context *context,
                                       ShaderProgramID program,
-                                      GLint location,
+                                      UniformLocation location,
                                       GLsizei bufSize,
                                       const GLsizei *length,
                                       const GLuint *params)
diff --git a/src/libANGLE/validationES.h b/src/libANGLE/validationES.h
index 4d041ce..ac7d77d 100644
--- a/src/libANGLE/validationES.h
+++ b/src/libANGLE/validationES.h
@@ -251,7 +251,7 @@
 
 bool ValidateUniformCommonBase(const Context *context,
                                const Program *program,
-                               GLint location,
+                               UniformLocation location,
                                GLsizei count,
                                const LinkedUniform **uniformOut);
 bool ValidateUniform1ivValue(const Context *context,
@@ -272,10 +272,13 @@
 }
 
 bool ValidateUniformMatrixValue(const Context *context, GLenum valueType, GLenum uniformType);
-bool ValidateUniform(const Context *context, GLenum uniformType, GLint location, GLsizei count);
+bool ValidateUniform(const Context *context,
+                     GLenum uniformType,
+                     UniformLocation location,
+                     GLsizei count);
 bool ValidateUniformMatrix(const Context *context,
                            GLenum matrixType,
-                           GLint location,
+                           UniformLocation location,
                            GLsizei count,
                            GLboolean transpose);
 bool ValidateGetBooleanvRobustANGLE(const Context *context,
@@ -395,50 +398,52 @@
                                     TextureID texture,
                                     GLint level);
 
-bool ValidateGetUniformBase(const Context *context, ShaderProgramID program, GLint location);
+bool ValidateGetUniformBase(const Context *context,
+                            ShaderProgramID program,
+                            UniformLocation location);
 bool ValidateGetnUniformfvEXT(const Context *context,
                               ShaderProgramID program,
-                              GLint location,
+                              UniformLocation location,
                               GLsizei bufSize,
                               const GLfloat *params);
 bool ValidateGetnUniformfvRobustANGLE(const Context *context,
                                       ShaderProgramID program,
-                                      GLint location,
+                                      UniformLocation location,
                                       GLsizei bufSize,
                                       const GLsizei *length,
                                       const GLfloat *params);
 bool ValidateGetnUniformivEXT(const Context *context,
                               ShaderProgramID program,
-                              GLint location,
+                              UniformLocation location,
                               GLsizei bufSize,
                               const GLint *params);
 bool ValidateGetnUniformivRobustANGLE(const Context *context,
                                       ShaderProgramID program,
-                                      GLint location,
+                                      UniformLocation location,
                                       GLsizei bufSize,
                                       const GLsizei *length,
                                       const GLint *params);
 bool ValidateGetnUniformuivRobustANGLE(const Context *context,
                                        ShaderProgramID program,
-                                       GLint location,
+                                       UniformLocation location,
                                        GLsizei bufSize,
                                        const GLsizei *length,
                                        const GLuint *params);
 bool ValidateGetUniformfvRobustANGLE(const Context *context,
                                      ShaderProgramID program,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei bufSize,
                                      const GLsizei *length,
                                      const GLfloat *params);
 bool ValidateGetUniformivRobustANGLE(const Context *context,
                                      ShaderProgramID program,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei bufSize,
                                      const GLsizei *length,
                                      const GLint *params);
 bool ValidateGetUniformuivRobustANGLE(const Context *context,
                                       ShaderProgramID program,
-                                      GLint location,
+                                      UniformLocation location,
                                       GLsizei bufSize,
                                       const GLsizei *length,
                                       const GLuint *params);
diff --git a/src/libANGLE/validationES2.cpp b/src/libANGLE/validationES2.cpp
index 0f2b9b4..175ad51 100644
--- a/src/libANGLE/validationES2.cpp
+++ b/src/libANGLE/validationES2.cpp
@@ -3792,7 +3792,7 @@
 
 bool ValidateBindUniformLocationCHROMIUM(const Context *context,
                                          ShaderProgramID program,
-                                         GLint location,
+                                         UniformLocation location,
                                          const GLchar *name)
 {
     if (!context->getExtensions().bindUniformLocation)
@@ -3807,14 +3807,14 @@
         return false;
     }
 
-    if (location < 0)
+    if (location.value < 0)
     {
         context->validationError(GL_INVALID_VALUE, kNegativeLocation);
         return false;
     }
 
     const Caps &caps = context->getCaps();
-    if (static_cast<long>(location) >=
+    if (static_cast<long>(location.value) >=
         (caps.maxVertexUniformVectors + caps.maxFragmentUniformVectors) * 4)
     {
         context->validationError(GL_INVALID_VALUE, kInvalidBindUniformLocation);
@@ -6277,58 +6277,77 @@
     return ValidateStencilOp(context, fail, zfail, zpass);
 }
 
-bool ValidateUniform1f(const Context *context, GLint location, GLfloat x)
+bool ValidateUniform1f(const Context *context, UniformLocation location, GLfloat x)
 {
     return ValidateUniform(context, GL_FLOAT, location, 1);
 }
 
-bool ValidateUniform1fv(const Context *context, GLint location, GLsizei count, const GLfloat *v)
+bool ValidateUniform1fv(const Context *context,
+                        UniformLocation location,
+                        GLsizei count,
+                        const GLfloat *v)
 {
     return ValidateUniform(context, GL_FLOAT, location, count);
 }
 
-bool ValidateUniform1i(const Context *context, GLint location, GLint x)
+bool ValidateUniform1i(const Context *context, UniformLocation location, GLint x)
 {
     return ValidateUniform1iv(context, location, 1, &x);
 }
 
-bool ValidateUniform2fv(const Context *context, GLint location, GLsizei count, const GLfloat *v)
+bool ValidateUniform2fv(const Context *context,
+                        UniformLocation location,
+                        GLsizei count,
+                        const GLfloat *v)
 {
     return ValidateUniform(context, GL_FLOAT_VEC2, location, count);
 }
 
-bool ValidateUniform2i(const Context *context, GLint location, GLint x, GLint y)
+bool ValidateUniform2i(const Context *context, UniformLocation location, GLint x, GLint y)
 {
     return ValidateUniform(context, GL_INT_VEC2, location, 1);
 }
 
-bool ValidateUniform2iv(const Context *context, GLint location, GLsizei count, const GLint *v)
+bool ValidateUniform2iv(const Context *context,
+                        UniformLocation location,
+                        GLsizei count,
+                        const GLint *v)
 {
     return ValidateUniform(context, GL_INT_VEC2, location, count);
 }
 
-bool ValidateUniform3f(const Context *context, GLint location, GLfloat x, GLfloat y, GLfloat z)
+bool ValidateUniform3f(const Context *context,
+                       UniformLocation location,
+                       GLfloat x,
+                       GLfloat y,
+                       GLfloat z)
 {
     return ValidateUniform(context, GL_FLOAT_VEC3, location, 1);
 }
 
-bool ValidateUniform3fv(const Context *context, GLint location, GLsizei count, const GLfloat *v)
+bool ValidateUniform3fv(const Context *context,
+                        UniformLocation location,
+                        GLsizei count,
+                        const GLfloat *v)
 {
     return ValidateUniform(context, GL_FLOAT_VEC3, location, count);
 }
 
-bool ValidateUniform3i(const Context *context, GLint location, GLint x, GLint y, GLint z)
+bool ValidateUniform3i(const Context *context, UniformLocation location, GLint x, GLint y, GLint z)
 {
     return ValidateUniform(context, GL_INT_VEC3, location, 1);
 }
 
-bool ValidateUniform3iv(const Context *context, GLint location, GLsizei count, const GLint *v)
+bool ValidateUniform3iv(const Context *context,
+                        UniformLocation location,
+                        GLsizei count,
+                        const GLint *v)
 {
     return ValidateUniform(context, GL_INT_VEC3, location, count);
 }
 
 bool ValidateUniform4f(const Context *context,
-                       GLint location,
+                       UniformLocation location,
                        GLfloat x,
                        GLfloat y,
                        GLfloat z,
@@ -6337,23 +6356,34 @@
     return ValidateUniform(context, GL_FLOAT_VEC4, location, 1);
 }
 
-bool ValidateUniform4fv(const Context *context, GLint location, GLsizei count, const GLfloat *v)
+bool ValidateUniform4fv(const Context *context,
+                        UniformLocation location,
+                        GLsizei count,
+                        const GLfloat *v)
 {
     return ValidateUniform(context, GL_FLOAT_VEC4, location, count);
 }
 
-bool ValidateUniform4i(const Context *context, GLint location, GLint x, GLint y, GLint z, GLint w)
+bool ValidateUniform4i(const Context *context,
+                       UniformLocation location,
+                       GLint x,
+                       GLint y,
+                       GLint z,
+                       GLint w)
 {
     return ValidateUniform(context, GL_INT_VEC4, location, 1);
 }
 
-bool ValidateUniform4iv(const Context *context, GLint location, GLsizei count, const GLint *v)
+bool ValidateUniform4iv(const Context *context,
+                        UniformLocation location,
+                        GLsizei count,
+                        const GLint *v)
 {
     return ValidateUniform(context, GL_INT_VEC4, location, count);
 }
 
 bool ValidateUniformMatrix2fv(const Context *context,
-                              GLint location,
+                              UniformLocation location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value)
@@ -6362,7 +6392,7 @@
 }
 
 bool ValidateUniformMatrix3fv(const Context *context,
-                              GLint location,
+                              UniformLocation location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value)
@@ -6371,7 +6401,7 @@
 }
 
 bool ValidateUniformMatrix4fv(const Context *context,
-                              GLint location,
+                              UniformLocation location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value)
@@ -6960,7 +6990,7 @@
 
 bool ValidateGetUniformfv(const Context *context,
                           ShaderProgramID program,
-                          GLint location,
+                          UniformLocation location,
                           const GLfloat *params)
 {
     return ValidateGetUniformBase(context, program, location);
@@ -6968,7 +6998,7 @@
 
 bool ValidateGetUniformiv(const Context *context,
                           ShaderProgramID program,
-                          GLint location,
+                          UniformLocation location,
                           const GLint *params)
 {
     return ValidateGetUniformBase(context, program, location);
diff --git a/src/libANGLE/validationES2.h b/src/libANGLE/validationES2.h
index 444bf82..229d704 100644
--- a/src/libANGLE/validationES2.h
+++ b/src/libANGLE/validationES2.h
@@ -23,7 +23,10 @@
     return ValidateDrawArraysCommon(context, mode, first, count, 1);
 }
 
-ANGLE_INLINE bool ValidateUniform2f(const Context *context, GLint location, GLfloat x, GLfloat y)
+ANGLE_INLINE bool ValidateUniform2f(const Context *context,
+                                    UniformLocation location,
+                                    GLfloat x,
+                                    GLfloat y)
 {
     return ValidateUniform(context, GL_FLOAT_VEC2, location, 1);
 }
diff --git a/src/libANGLE/validationES2_autogen.h b/src/libANGLE/validationES2_autogen.h
index ecb83b7..8cfc4c1 100644
--- a/src/libANGLE/validationES2_autogen.h
+++ b/src/libANGLE/validationES2_autogen.h
@@ -246,11 +246,11 @@
                                 const GLchar *name);
 bool ValidateGetUniformfv(const Context *context,
                           ShaderProgramID programPacked,
-                          GLint location,
+                          UniformLocation locationPacked,
                           const GLfloat *params);
 bool ValidateGetUniformiv(const Context *context,
                           ShaderProgramID programPacked,
-                          GLint location,
+                          UniformLocation locationPacked,
                           const GLint *params);
 bool ValidateGetVertexAttribPointerv(const Context *context,
                                      GLuint index,
@@ -353,56 +353,79 @@
                            GLenum format,
                            GLenum type,
                            const void *pixels);
-bool ValidateUniform1f(const Context *context, GLint location, GLfloat v0);
+bool ValidateUniform1f(const Context *context, UniformLocation locationPacked, GLfloat v0);
 bool ValidateUniform1fv(const Context *context,
-                        GLint location,
+                        UniformLocation locationPacked,
                         GLsizei count,
                         const GLfloat *value);
-bool ValidateUniform1i(const Context *context, GLint location, GLint v0);
-bool ValidateUniform1iv(const Context *context, GLint location, GLsizei count, const GLint *value);
-bool ValidateUniform2f(const Context *context, GLint location, GLfloat v0, GLfloat v1);
+bool ValidateUniform1i(const Context *context, UniformLocation locationPacked, GLint v0);
+bool ValidateUniform1iv(const Context *context,
+                        UniformLocation locationPacked,
+                        GLsizei count,
+                        const GLint *value);
+bool ValidateUniform2f(const Context *context,
+                       UniformLocation locationPacked,
+                       GLfloat v0,
+                       GLfloat v1);
 bool ValidateUniform2fv(const Context *context,
-                        GLint location,
+                        UniformLocation locationPacked,
                         GLsizei count,
                         const GLfloat *value);
-bool ValidateUniform2i(const Context *context, GLint location, GLint v0, GLint v1);
-bool ValidateUniform2iv(const Context *context, GLint location, GLsizei count, const GLint *value);
-bool ValidateUniform3f(const Context *context, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+bool ValidateUniform2i(const Context *context, UniformLocation locationPacked, GLint v0, GLint v1);
+bool ValidateUniform2iv(const Context *context,
+                        UniformLocation locationPacked,
+                        GLsizei count,
+                        const GLint *value);
+bool ValidateUniform3f(const Context *context,
+                       UniformLocation locationPacked,
+                       GLfloat v0,
+                       GLfloat v1,
+                       GLfloat v2);
 bool ValidateUniform3fv(const Context *context,
-                        GLint location,
+                        UniformLocation locationPacked,
                         GLsizei count,
                         const GLfloat *value);
-bool ValidateUniform3i(const Context *context, GLint location, GLint v0, GLint v1, GLint v2);
-bool ValidateUniform3iv(const Context *context, GLint location, GLsizei count, const GLint *value);
+bool ValidateUniform3i(const Context *context,
+                       UniformLocation locationPacked,
+                       GLint v0,
+                       GLint v1,
+                       GLint v2);
+bool ValidateUniform3iv(const Context *context,
+                        UniformLocation locationPacked,
+                        GLsizei count,
+                        const GLint *value);
 bool ValidateUniform4f(const Context *context,
-                       GLint location,
+                       UniformLocation locationPacked,
                        GLfloat v0,
                        GLfloat v1,
                        GLfloat v2,
                        GLfloat v3);
 bool ValidateUniform4fv(const Context *context,
-                        GLint location,
+                        UniformLocation locationPacked,
                         GLsizei count,
                         const GLfloat *value);
 bool ValidateUniform4i(const Context *context,
-                       GLint location,
+                       UniformLocation locationPacked,
                        GLint v0,
                        GLint v1,
                        GLint v2,
                        GLint v3);
-bool ValidateUniform4iv(const Context *context, GLint location, GLsizei count, const GLint *value);
+bool ValidateUniform4iv(const Context *context,
+                        UniformLocation locationPacked,
+                        GLsizei count,
+                        const GLint *value);
 bool ValidateUniformMatrix2fv(const Context *context,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value);
 bool ValidateUniformMatrix3fv(const Context *context,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value);
 bool ValidateUniformMatrix4fv(const Context *context,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               GLboolean transpose,
                               const GLfloat *value);
diff --git a/src/libANGLE/validationES3.cpp b/src/libANGLE/validationES3.cpp
index 0c5044b..0055897 100644
--- a/src/libANGLE/validationES3.cpp
+++ b/src/libANGLE/validationES3.cpp
@@ -83,7 +83,10 @@
     return true;
 }
 
-bool ValidateUniformES3(const Context *context, GLenum uniformType, GLint location, GLint count)
+bool ValidateUniformES3(const Context *context,
+                        GLenum uniformType,
+                        UniformLocation location,
+                        GLint count)
 {
     if (context->getClientMajorVersion() < 3)
     {
@@ -96,7 +99,7 @@
 
 bool ValidateUniformMatrixES3(const Context *context,
                               GLenum valueType,
-                              GLint location,
+                              UniformLocation location,
                               GLsizei count,
                               GLboolean transpose)
 {
@@ -1531,7 +1534,7 @@
 
 bool ValidateGetUniformuiv(const Context *context,
                            ShaderProgramID program,
-                           GLint location,
+                           UniformLocation location,
                            const GLuint *params)
 {
     if (context->getClientMajorVersion() < 3)
@@ -3437,23 +3440,27 @@
     return true;
 }
 
-bool ValidateUniform1ui(const Context *context, GLint location, GLuint v0)
+bool ValidateUniform1ui(const Context *context, UniformLocation location, GLuint v0)
 {
     return ValidateUniformES3(context, GL_UNSIGNED_INT, location, 1);
 }
 
-bool ValidateUniform2ui(const Context *context, GLint location, GLuint v0, GLuint v1)
+bool ValidateUniform2ui(const Context *context, UniformLocation location, GLuint v0, GLuint v1)
 {
     return ValidateUniformES3(context, GL_UNSIGNED_INT_VEC2, location, 1);
 }
 
-bool ValidateUniform3ui(const Context *context, GLint location, GLuint v0, GLuint v1, GLuint v2)
+bool ValidateUniform3ui(const Context *context,
+                        UniformLocation location,
+                        GLuint v0,
+                        GLuint v1,
+                        GLuint v2)
 {
     return ValidateUniformES3(context, GL_UNSIGNED_INT_VEC3, location, 1);
 }
 
 bool ValidateUniform4ui(const Context *context,
-                        GLint location,
+                        UniformLocation location,
                         GLuint v0,
                         GLuint v1,
                         GLuint v2,
@@ -3462,22 +3469,34 @@
     return ValidateUniformES3(context, GL_UNSIGNED_INT_VEC4, location, 1);
 }
 
-bool ValidateUniform1uiv(const Context *context, GLint location, GLsizei count, const GLuint *value)
+bool ValidateUniform1uiv(const Context *context,
+                         UniformLocation location,
+                         GLsizei count,
+                         const GLuint *value)
 {
     return ValidateUniformES3(context, GL_UNSIGNED_INT, location, count);
 }
 
-bool ValidateUniform2uiv(const Context *context, GLint location, GLsizei count, const GLuint *value)
+bool ValidateUniform2uiv(const Context *context,
+                         UniformLocation location,
+                         GLsizei count,
+                         const GLuint *value)
 {
     return ValidateUniformES3(context, GL_UNSIGNED_INT_VEC2, location, count);
 }
 
-bool ValidateUniform3uiv(const Context *context, GLint location, GLsizei count, const GLuint *value)
+bool ValidateUniform3uiv(const Context *context,
+                         UniformLocation location,
+                         GLsizei count,
+                         const GLuint *value)
 {
     return ValidateUniformES3(context, GL_UNSIGNED_INT_VEC3, location, count);
 }
 
-bool ValidateUniform4uiv(const Context *context, GLint location, GLsizei count, const GLuint *value)
+bool ValidateUniform4uiv(const Context *context,
+                         UniformLocation location,
+                         GLsizei count,
+                         const GLuint *value)
 {
     return ValidateUniformES3(context, GL_UNSIGNED_INT_VEC4, location, count);
 }
@@ -3494,7 +3513,7 @@
 }
 
 bool ValidateUniformMatrix2x3fv(const Context *context,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value)
@@ -3503,7 +3522,7 @@
 }
 
 bool ValidateUniformMatrix3x2fv(const Context *context,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value)
@@ -3512,7 +3531,7 @@
 }
 
 bool ValidateUniformMatrix2x4fv(const Context *context,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value)
@@ -3521,7 +3540,7 @@
 }
 
 bool ValidateUniformMatrix4x2fv(const Context *context,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value)
@@ -3530,7 +3549,7 @@
 }
 
 bool ValidateUniformMatrix3x4fv(const Context *context,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value)
@@ -3539,7 +3558,7 @@
 }
 
 bool ValidateUniformMatrix4x3fv(const Context *context,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value)
diff --git a/src/libANGLE/validationES31.cpp b/src/libANGLE/validationES31.cpp
index d14bcbc..676371a 100644
--- a/src/libANGLE/validationES31.cpp
+++ b/src/libANGLE/validationES31.cpp
@@ -300,7 +300,7 @@
 bool ValidateProgramUniform(const Context *context,
                             GLenum valueType,
                             ShaderProgramID program,
-                            GLint location,
+                            UniformLocation location,
                             GLsizei count)
 {
     // Check for ES31 program uniform entry points
@@ -319,7 +319,7 @@
 bool ValidateProgramUniformMatrix(const Context *context,
                                   GLenum valueType,
                                   ShaderProgramID program,
-                                  GLint location,
+                                  UniformLocation location,
                                   GLsizei count,
                                   GLboolean transpose)
 {
@@ -551,7 +551,7 @@
 
 bool ValidateProgramUniform1i(const Context *context,
                               ShaderProgramID program,
-                              GLint location,
+                              UniformLocation location,
                               GLint v0)
 {
     return ValidateProgramUniform1iv(context, program, location, 1, &v0);
@@ -559,7 +559,7 @@
 
 bool ValidateProgramUniform2i(const Context *context,
                               ShaderProgramID program,
-                              GLint location,
+                              UniformLocation location,
                               GLint v0,
                               GLint v1)
 {
@@ -569,7 +569,7 @@
 
 bool ValidateProgramUniform3i(const Context *context,
                               ShaderProgramID program,
-                              GLint location,
+                              UniformLocation location,
                               GLint v0,
                               GLint v1,
                               GLint v2)
@@ -580,7 +580,7 @@
 
 bool ValidateProgramUniform4i(const Context *context,
                               ShaderProgramID program,
-                              GLint location,
+                              UniformLocation location,
                               GLint v0,
                               GLint v1,
                               GLint v2,
@@ -592,7 +592,7 @@
 
 bool ValidateProgramUniform1ui(const Context *context,
                                ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLuint v0)
 {
     return ValidateProgramUniform1uiv(context, program, location, 1, &v0);
@@ -600,7 +600,7 @@
 
 bool ValidateProgramUniform2ui(const Context *context,
                                ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLuint v0,
                                GLuint v1)
 {
@@ -610,7 +610,7 @@
 
 bool ValidateProgramUniform3ui(const Context *context,
                                ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLuint v0,
                                GLuint v1,
                                GLuint v2)
@@ -621,7 +621,7 @@
 
 bool ValidateProgramUniform4ui(const Context *context,
                                ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLuint v0,
                                GLuint v1,
                                GLuint v2,
@@ -633,7 +633,7 @@
 
 bool ValidateProgramUniform1f(const Context *context,
                               ShaderProgramID program,
-                              GLint location,
+                              UniformLocation location,
                               GLfloat v0)
 {
     return ValidateProgramUniform1fv(context, program, location, 1, &v0);
@@ -641,7 +641,7 @@
 
 bool ValidateProgramUniform2f(const Context *context,
                               ShaderProgramID program,
-                              GLint location,
+                              UniformLocation location,
                               GLfloat v0,
                               GLfloat v1)
 {
@@ -651,7 +651,7 @@
 
 bool ValidateProgramUniform3f(const Context *context,
                               ShaderProgramID program,
-                              GLint location,
+                              UniformLocation location,
                               GLfloat v0,
                               GLfloat v1,
                               GLfloat v2)
@@ -662,7 +662,7 @@
 
 bool ValidateProgramUniform4f(const Context *context,
                               ShaderProgramID program,
-                              GLint location,
+                              UniformLocation location,
                               GLfloat v0,
                               GLfloat v1,
                               GLfloat v2,
@@ -674,7 +674,7 @@
 
 bool ValidateProgramUniform1iv(const Context *context,
                                ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLsizei count,
                                const GLint *value)
 {
@@ -693,7 +693,7 @@
 
 bool ValidateProgramUniform2iv(const Context *context,
                                ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLsizei count,
                                const GLint *value)
 {
@@ -702,7 +702,7 @@
 
 bool ValidateProgramUniform3iv(const Context *context,
                                ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLsizei count,
                                const GLint *value)
 {
@@ -711,7 +711,7 @@
 
 bool ValidateProgramUniform4iv(const Context *context,
                                ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLsizei count,
                                const GLint *value)
 {
@@ -720,7 +720,7 @@
 
 bool ValidateProgramUniform1uiv(const Context *context,
                                 ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 const GLuint *value)
 {
@@ -729,7 +729,7 @@
 
 bool ValidateProgramUniform2uiv(const Context *context,
                                 ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 const GLuint *value)
 {
@@ -738,7 +738,7 @@
 
 bool ValidateProgramUniform3uiv(const Context *context,
                                 ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 const GLuint *value)
 {
@@ -747,7 +747,7 @@
 
 bool ValidateProgramUniform4uiv(const Context *context,
                                 ShaderProgramID program,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 const GLuint *value)
 {
@@ -756,7 +756,7 @@
 
 bool ValidateProgramUniform1fv(const Context *context,
                                ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLsizei count,
                                const GLfloat *value)
 {
@@ -765,7 +765,7 @@
 
 bool ValidateProgramUniform2fv(const Context *context,
                                ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLsizei count,
                                const GLfloat *value)
 {
@@ -774,7 +774,7 @@
 
 bool ValidateProgramUniform3fv(const Context *context,
                                ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLsizei count,
                                const GLfloat *value)
 {
@@ -783,7 +783,7 @@
 
 bool ValidateProgramUniform4fv(const Context *context,
                                ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLsizei count,
                                const GLfloat *value)
 {
@@ -792,7 +792,7 @@
 
 bool ValidateProgramUniformMatrix2fv(const Context *context,
                                      ShaderProgramID program,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value)
@@ -803,7 +803,7 @@
 
 bool ValidateProgramUniformMatrix3fv(const Context *context,
                                      ShaderProgramID program,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value)
@@ -814,7 +814,7 @@
 
 bool ValidateProgramUniformMatrix4fv(const Context *context,
                                      ShaderProgramID program,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value)
@@ -825,7 +825,7 @@
 
 bool ValidateProgramUniformMatrix2x3fv(const Context *context,
                                        ShaderProgramID program,
-                                       GLint location,
+                                       UniformLocation location,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLfloat *value)
@@ -836,7 +836,7 @@
 
 bool ValidateProgramUniformMatrix3x2fv(const Context *context,
                                        ShaderProgramID program,
-                                       GLint location,
+                                       UniformLocation location,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLfloat *value)
@@ -847,7 +847,7 @@
 
 bool ValidateProgramUniformMatrix2x4fv(const Context *context,
                                        ShaderProgramID program,
-                                       GLint location,
+                                       UniformLocation location,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLfloat *value)
@@ -858,7 +858,7 @@
 
 bool ValidateProgramUniformMatrix4x2fv(const Context *context,
                                        ShaderProgramID program,
-                                       GLint location,
+                                       UniformLocation location,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLfloat *value)
@@ -869,7 +869,7 @@
 
 bool ValidateProgramUniformMatrix3x4fv(const Context *context,
                                        ShaderProgramID program,
-                                       GLint location,
+                                       UniformLocation location,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLfloat *value)
@@ -880,7 +880,7 @@
 
 bool ValidateProgramUniformMatrix4x3fv(const Context *context,
                                        ShaderProgramID program,
-                                       GLint location,
+                                       UniformLocation location,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLfloat *value)
diff --git a/src/libANGLE/validationES31_autogen.h b/src/libANGLE/validationES31_autogen.h
index a38749b..0563428 100644
--- a/src/libANGLE/validationES31_autogen.h
+++ b/src/libANGLE/validationES31_autogen.h
@@ -125,181 +125,181 @@
 bool ValidateMemoryBarrierByRegion(const Context *context, GLbitfield barriers);
 bool ValidateProgramUniform1f(const Context *context,
                               ShaderProgramID programPacked,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLfloat v0);
 bool ValidateProgramUniform1fv(const Context *context,
                                ShaderProgramID programPacked,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLsizei count,
                                const GLfloat *value);
 bool ValidateProgramUniform1i(const Context *context,
                               ShaderProgramID programPacked,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLint v0);
 bool ValidateProgramUniform1iv(const Context *context,
                                ShaderProgramID programPacked,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLsizei count,
                                const GLint *value);
 bool ValidateProgramUniform1ui(const Context *context,
                                ShaderProgramID programPacked,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLuint v0);
 bool ValidateProgramUniform1uiv(const Context *context,
                                 ShaderProgramID programPacked,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLsizei count,
                                 const GLuint *value);
 bool ValidateProgramUniform2f(const Context *context,
                               ShaderProgramID programPacked,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLfloat v0,
                               GLfloat v1);
 bool ValidateProgramUniform2fv(const Context *context,
                                ShaderProgramID programPacked,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLsizei count,
                                const GLfloat *value);
 bool ValidateProgramUniform2i(const Context *context,
                               ShaderProgramID programPacked,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLint v0,
                               GLint v1);
 bool ValidateProgramUniform2iv(const Context *context,
                                ShaderProgramID programPacked,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLsizei count,
                                const GLint *value);
 bool ValidateProgramUniform2ui(const Context *context,
                                ShaderProgramID programPacked,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLuint v0,
                                GLuint v1);
 bool ValidateProgramUniform2uiv(const Context *context,
                                 ShaderProgramID programPacked,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLsizei count,
                                 const GLuint *value);
 bool ValidateProgramUniform3f(const Context *context,
                               ShaderProgramID programPacked,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLfloat v0,
                               GLfloat v1,
                               GLfloat v2);
 bool ValidateProgramUniform3fv(const Context *context,
                                ShaderProgramID programPacked,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLsizei count,
                                const GLfloat *value);
 bool ValidateProgramUniform3i(const Context *context,
                               ShaderProgramID programPacked,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLint v0,
                               GLint v1,
                               GLint v2);
 bool ValidateProgramUniform3iv(const Context *context,
                                ShaderProgramID programPacked,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLsizei count,
                                const GLint *value);
 bool ValidateProgramUniform3ui(const Context *context,
                                ShaderProgramID programPacked,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLuint v0,
                                GLuint v1,
                                GLuint v2);
 bool ValidateProgramUniform3uiv(const Context *context,
                                 ShaderProgramID programPacked,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLsizei count,
                                 const GLuint *value);
 bool ValidateProgramUniform4f(const Context *context,
                               ShaderProgramID programPacked,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLfloat v0,
                               GLfloat v1,
                               GLfloat v2,
                               GLfloat v3);
 bool ValidateProgramUniform4fv(const Context *context,
                                ShaderProgramID programPacked,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLsizei count,
                                const GLfloat *value);
 bool ValidateProgramUniform4i(const Context *context,
                               ShaderProgramID programPacked,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLint v0,
                               GLint v1,
                               GLint v2,
                               GLint v3);
 bool ValidateProgramUniform4iv(const Context *context,
                                ShaderProgramID programPacked,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLsizei count,
                                const GLint *value);
 bool ValidateProgramUniform4ui(const Context *context,
                                ShaderProgramID programPacked,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLuint v0,
                                GLuint v1,
                                GLuint v2,
                                GLuint v3);
 bool ValidateProgramUniform4uiv(const Context *context,
                                 ShaderProgramID programPacked,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLsizei count,
                                 const GLuint *value);
 bool ValidateProgramUniformMatrix2fv(const Context *context,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value);
 bool ValidateProgramUniformMatrix2x3fv(const Context *context,
                                        ShaderProgramID programPacked,
-                                       GLint location,
+                                       UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLfloat *value);
 bool ValidateProgramUniformMatrix2x4fv(const Context *context,
                                        ShaderProgramID programPacked,
-                                       GLint location,
+                                       UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLfloat *value);
 bool ValidateProgramUniformMatrix3fv(const Context *context,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value);
 bool ValidateProgramUniformMatrix3x2fv(const Context *context,
                                        ShaderProgramID programPacked,
-                                       GLint location,
+                                       UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLfloat *value);
 bool ValidateProgramUniformMatrix3x4fv(const Context *context,
                                        ShaderProgramID programPacked,
-                                       GLint location,
+                                       UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLfloat *value);
 bool ValidateProgramUniformMatrix4fv(const Context *context,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value);
 bool ValidateProgramUniformMatrix4x2fv(const Context *context,
                                        ShaderProgramID programPacked,
-                                       GLint location,
+                                       UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLfloat *value);
 bool ValidateProgramUniformMatrix4x3fv(const Context *context,
                                        ShaderProgramID programPacked,
-                                       GLint location,
+                                       UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLfloat *value);
diff --git a/src/libANGLE/validationES32.cpp b/src/libANGLE/validationES32.cpp
index e54b0ea..60c61e8 100644
--- a/src/libANGLE/validationES32.cpp
+++ b/src/libANGLE/validationES32.cpp
@@ -313,7 +313,7 @@
 
 bool ValidateGetnUniformfv(const Context *context,
                            ShaderProgramID program,
-                           GLint location,
+                           UniformLocation location,
                            GLsizei bufSize,
                            const GLfloat *params)
 {
@@ -322,7 +322,7 @@
 
 bool ValidateGetnUniformiv(const Context *context,
                            ShaderProgramID program,
-                           GLint location,
+                           UniformLocation location,
                            GLsizei bufSize,
                            const GLint *params)
 {
@@ -331,7 +331,7 @@
 
 bool ValidateGetnUniformuiv(const Context *context,
                             ShaderProgramID program,
-                            GLint location,
+                            UniformLocation location,
                             GLsizei bufSize,
                             const GLuint *params)
 {
diff --git a/src/libANGLE/validationES32_autogen.h b/src/libANGLE/validationES32_autogen.h
index c7e64af..b621b38 100644
--- a/src/libANGLE/validationES32_autogen.h
+++ b/src/libANGLE/validationES32_autogen.h
@@ -137,17 +137,17 @@
                                  const GLuint *params);
 bool ValidateGetnUniformfv(const Context *context,
                            ShaderProgramID programPacked,
-                           GLint location,
+                           UniformLocation locationPacked,
                            GLsizei bufSize,
                            const GLfloat *params);
 bool ValidateGetnUniformiv(const Context *context,
                            ShaderProgramID programPacked,
-                           GLint location,
+                           UniformLocation locationPacked,
                            GLsizei bufSize,
                            const GLint *params);
 bool ValidateGetnUniformuiv(const Context *context,
                             ShaderProgramID programPacked,
-                            GLint location,
+                            UniformLocation locationPacked,
                             GLsizei bufSize,
                             const GLuint *params);
 bool ValidateIsEnabledi(const Context *context, GLenum target, GLuint index);
diff --git a/src/libANGLE/validationES3_autogen.h b/src/libANGLE/validationES3_autogen.h
index b97f5ec..803da1e 100644
--- a/src/libANGLE/validationES3_autogen.h
+++ b/src/libANGLE/validationES3_autogen.h
@@ -238,7 +238,7 @@
                                const GLuint *uniformIndices);
 bool ValidateGetUniformuiv(const Context *context,
                            ShaderProgramID programPacked,
-                           GLint location,
+                           UniformLocation locationPacked,
                            const GLuint *params);
 bool ValidateGetVertexAttribIiv(const Context *context,
                                 GLuint index,
@@ -345,29 +345,36 @@
                                        GLsizei count,
                                        const GLchar *const *varyings,
                                        GLenum bufferMode);
-bool ValidateUniform1ui(const Context *context, GLint location, GLuint v0);
+bool ValidateUniform1ui(const Context *context, UniformLocation locationPacked, GLuint v0);
 bool ValidateUniform1uiv(const Context *context,
-                         GLint location,
+                         UniformLocation locationPacked,
                          GLsizei count,
                          const GLuint *value);
-bool ValidateUniform2ui(const Context *context, GLint location, GLuint v0, GLuint v1);
+bool ValidateUniform2ui(const Context *context,
+                        UniformLocation locationPacked,
+                        GLuint v0,
+                        GLuint v1);
 bool ValidateUniform2uiv(const Context *context,
-                         GLint location,
+                         UniformLocation locationPacked,
                          GLsizei count,
                          const GLuint *value);
-bool ValidateUniform3ui(const Context *context, GLint location, GLuint v0, GLuint v1, GLuint v2);
+bool ValidateUniform3ui(const Context *context,
+                        UniformLocation locationPacked,
+                        GLuint v0,
+                        GLuint v1,
+                        GLuint v2);
 bool ValidateUniform3uiv(const Context *context,
-                         GLint location,
+                         UniformLocation locationPacked,
                          GLsizei count,
                          const GLuint *value);
 bool ValidateUniform4ui(const Context *context,
-                        GLint location,
+                        UniformLocation locationPacked,
                         GLuint v0,
                         GLuint v1,
                         GLuint v2,
                         GLuint v3);
 bool ValidateUniform4uiv(const Context *context,
-                         GLint location,
+                         UniformLocation locationPacked,
                          GLsizei count,
                          const GLuint *value);
 bool ValidateUniformBlockBinding(const Context *context,
@@ -375,32 +382,32 @@
                                  GLuint uniformBlockIndex,
                                  GLuint uniformBlockBinding);
 bool ValidateUniformMatrix2x3fv(const Context *context,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value);
 bool ValidateUniformMatrix2x4fv(const Context *context,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value);
 bool ValidateUniformMatrix3x2fv(const Context *context,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value);
 bool ValidateUniformMatrix3x4fv(const Context *context,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value);
 bool ValidateUniformMatrix4x2fv(const Context *context,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value);
 bool ValidateUniformMatrix4x3fv(const Context *context,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLfloat *value);
diff --git a/src/libANGLE/validationESEXT_autogen.h b/src/libANGLE/validationESEXT_autogen.h
index 786f758..be18f84 100644
--- a/src/libANGLE/validationESEXT_autogen.h
+++ b/src/libANGLE/validationESEXT_autogen.h
@@ -231,13 +231,13 @@
                                           const GLint *params);
 bool ValidateGetUniformfvRobustANGLE(const Context *context,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei bufSize,
                                      const GLsizei *length,
                                      const GLfloat *params);
 bool ValidateGetUniformivRobustANGLE(const Context *context,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei bufSize,
                                      const GLsizei *length,
                                      const GLint *params);
@@ -418,7 +418,7 @@
                                             const GLuint *params);
 bool ValidateGetUniformuivRobustANGLE(const Context *context,
                                       ShaderProgramID programPacked,
-                                      GLint location,
+                                      UniformLocation locationPacked,
                                       GLsizei bufSize,
                                       const GLsizei *length,
                                       const GLuint *params);
@@ -526,19 +526,19 @@
                                     const void *data);
 bool ValidateGetnUniformfvRobustANGLE(const Context *context,
                                       ShaderProgramID programPacked,
-                                      GLint location,
+                                      UniformLocation locationPacked,
                                       GLsizei bufSize,
                                       const GLsizei *length,
                                       const GLfloat *params);
 bool ValidateGetnUniformivRobustANGLE(const Context *context,
                                       ShaderProgramID programPacked,
-                                      GLint location,
+                                      UniformLocation locationPacked,
                                       GLsizei bufSize,
                                       const GLsizei *length,
                                       const GLint *params);
 bool ValidateGetnUniformuivRobustANGLE(const Context *context,
                                        ShaderProgramID programPacked,
-                                       GLint location,
+                                       UniformLocation locationPacked,
                                        GLsizei bufSize,
                                        const GLsizei *length,
                                        const GLuint *params);
@@ -657,7 +657,7 @@
 // GL_CHROMIUM_bind_uniform_location
 bool ValidateBindUniformLocationCHROMIUM(const Context *context,
                                          ShaderProgramID programPacked,
-                                         GLint location,
+                                         UniformLocation locationPacked,
                                          const GLchar *name);
 
 // GL_CHROMIUM_copy_compressed_texture
@@ -1031,12 +1031,12 @@
 bool ValidateGetGraphicsResetStatusEXT(const Context *context);
 bool ValidateGetnUniformfvEXT(const Context *context,
                               ShaderProgramID programPacked,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei bufSize,
                               const GLfloat *params);
 bool ValidateGetnUniformivEXT(const Context *context,
                               ShaderProgramID programPacked,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei bufSize,
                               const GLint *params);
 bool ValidateReadnPixelsEXT(const Context *context,
diff --git a/src/libANGLE/validationGL4.cpp b/src/libANGLE/validationGL4.cpp
index 843ded2..bcfb606 100644
--- a/src/libANGLE/validationGL4.cpp
+++ b/src/libANGLE/validationGL4.cpp
@@ -110,7 +110,7 @@
 
 bool ValidateGetUniformdv(const Context *context,
                           ShaderProgramID program,
-                          GLint location,
+                          UniformLocation location,
                           const GLdouble *params)
 {
     return true;
@@ -121,39 +121,43 @@
     return true;
 }
 
-bool ValidateUniform1d(const Context *context, GLint location, GLdouble x)
+bool ValidateUniform1d(const Context *context, UniformLocation location, GLdouble x)
 {
     return true;
 }
 
 bool ValidateUniform1dv(const Context *context,
-                        GLint location,
+                        UniformLocation location,
                         GLsizei count,
                         const GLdouble *value)
 {
     return true;
 }
 
-bool ValidateUniform2d(const Context *context, GLint location, GLdouble x, GLdouble y)
+bool ValidateUniform2d(const Context *context, UniformLocation location, GLdouble x, GLdouble y)
 {
     return true;
 }
 
 bool ValidateUniform2dv(const Context *context,
-                        GLint location,
+                        UniformLocation location,
                         GLsizei count,
                         const GLdouble *value)
 {
     return true;
 }
 
-bool ValidateUniform3d(const Context *context, GLint location, GLdouble x, GLdouble y, GLdouble z)
+bool ValidateUniform3d(const Context *context,
+                       UniformLocation location,
+                       GLdouble x,
+                       GLdouble y,
+                       GLdouble z)
 {
     return true;
 }
 
 bool ValidateUniform3dv(const Context *context,
-                        GLint location,
+                        UniformLocation location,
                         GLsizei count,
                         const GLdouble *value)
 {
@@ -161,7 +165,7 @@
 }
 
 bool ValidateUniform4d(const Context *context,
-                       GLint location,
+                       UniformLocation location,
                        GLdouble x,
                        GLdouble y,
                        GLdouble z,
@@ -171,7 +175,7 @@
 }
 
 bool ValidateUniform4dv(const Context *context,
-                        GLint location,
+                        UniformLocation location,
                         GLsizei count,
                         const GLdouble *value)
 {
@@ -179,7 +183,7 @@
 }
 
 bool ValidateUniformMatrix2dv(const Context *context,
-                              GLint location,
+                              UniformLocation location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLdouble *value)
@@ -188,7 +192,7 @@
 }
 
 bool ValidateUniformMatrix2x3dv(const Context *context,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLdouble *value)
@@ -197,7 +201,7 @@
 }
 
 bool ValidateUniformMatrix2x4dv(const Context *context,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLdouble *value)
@@ -206,7 +210,7 @@
 }
 
 bool ValidateUniformMatrix3dv(const Context *context,
-                              GLint location,
+                              UniformLocation location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLdouble *value)
@@ -215,7 +219,7 @@
 }
 
 bool ValidateUniformMatrix3x2dv(const Context *context,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLdouble *value)
@@ -224,7 +228,7 @@
 }
 
 bool ValidateUniformMatrix3x4dv(const Context *context,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLdouble *value)
@@ -233,7 +237,7 @@
 }
 
 bool ValidateUniformMatrix4dv(const Context *context,
-                              GLint location,
+                              UniformLocation location,
                               GLsizei count,
                               GLboolean transpose,
                               const GLdouble *value)
@@ -242,7 +246,7 @@
 }
 
 bool ValidateUniformMatrix4x2dv(const Context *context,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLdouble *value)
@@ -251,7 +255,7 @@
 }
 
 bool ValidateUniformMatrix4x3dv(const Context *context,
-                                GLint location,
+                                UniformLocation location,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLdouble *value)
diff --git a/src/libANGLE/validationGL41.cpp b/src/libANGLE/validationGL41.cpp
index 8f4fe04..9c55d21 100644
--- a/src/libANGLE/validationGL41.cpp
+++ b/src/libANGLE/validationGL41.cpp
@@ -44,7 +44,7 @@
 
 bool ValidateProgramUniform1d(const Context *context,
                               ShaderProgramID program,
-                              GLint location,
+                              UniformLocation location,
                               GLdouble v0)
 {
     return true;
@@ -52,7 +52,7 @@
 
 bool ValidateProgramUniform1dv(const Context *context,
                                ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLsizei count,
                                const GLdouble *value)
 {
@@ -61,7 +61,7 @@
 
 bool ValidateProgramUniform2d(const Context *context,
                               ShaderProgramID program,
-                              GLint location,
+                              UniformLocation location,
                               GLdouble v0,
                               GLdouble v1)
 {
@@ -70,7 +70,7 @@
 
 bool ValidateProgramUniform2dv(const Context *context,
                                ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLsizei count,
                                const GLdouble *value)
 {
@@ -79,7 +79,7 @@
 
 bool ValidateProgramUniform3d(const Context *context,
                               ShaderProgramID program,
-                              GLint location,
+                              UniformLocation location,
                               GLdouble v0,
                               GLdouble v1,
                               GLdouble v2)
@@ -89,7 +89,7 @@
 
 bool ValidateProgramUniform3dv(const Context *context,
                                ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLsizei count,
                                const GLdouble *value)
 {
@@ -98,7 +98,7 @@
 
 bool ValidateProgramUniform4d(const Context *context,
                               ShaderProgramID program,
-                              GLint location,
+                              UniformLocation location,
                               GLdouble v0,
                               GLdouble v1,
                               GLdouble v2,
@@ -109,7 +109,7 @@
 
 bool ValidateProgramUniform4dv(const Context *context,
                                ShaderProgramID program,
-                               GLint location,
+                               UniformLocation location,
                                GLsizei count,
                                const GLdouble *value)
 {
@@ -118,7 +118,7 @@
 
 bool ValidateProgramUniformMatrix2dv(const Context *context,
                                      ShaderProgramID program,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
@@ -128,7 +128,7 @@
 
 bool ValidateProgramUniformMatrix2x3dv(const Context *context,
                                        ShaderProgramID program,
-                                       GLint location,
+                                       UniformLocation location,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value)
@@ -138,7 +138,7 @@
 
 bool ValidateProgramUniformMatrix2x4dv(const Context *context,
                                        ShaderProgramID program,
-                                       GLint location,
+                                       UniformLocation location,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value)
@@ -148,7 +148,7 @@
 
 bool ValidateProgramUniformMatrix3dv(const Context *context,
                                      ShaderProgramID program,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
@@ -158,7 +158,7 @@
 
 bool ValidateProgramUniformMatrix3x2dv(const Context *context,
                                        ShaderProgramID program,
-                                       GLint location,
+                                       UniformLocation location,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value)
@@ -168,7 +168,7 @@
 
 bool ValidateProgramUniformMatrix3x4dv(const Context *context,
                                        ShaderProgramID program,
-                                       GLint location,
+                                       UniformLocation location,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value)
@@ -178,7 +178,7 @@
 
 bool ValidateProgramUniformMatrix4dv(const Context *context,
                                      ShaderProgramID program,
-                                     GLint location,
+                                     UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
@@ -188,7 +188,7 @@
 
 bool ValidateProgramUniformMatrix4x2dv(const Context *context,
                                        ShaderProgramID program,
-                                       GLint location,
+                                       UniformLocation location,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value)
@@ -198,7 +198,7 @@
 
 bool ValidateProgramUniformMatrix4x3dv(const Context *context,
                                        ShaderProgramID program,
-                                       GLint location,
+                                       UniformLocation location,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value)
diff --git a/src/libANGLE/validationGL41_autogen.h b/src/libANGLE/validationGL41_autogen.h
index 89a1431..c5ccf9d 100644
--- a/src/libANGLE/validationGL41_autogen.h
+++ b/src/libANGLE/validationGL41_autogen.h
@@ -33,97 +33,97 @@
                                 const GLdouble *params);
 bool ValidateProgramUniform1d(const Context *context,
                               ShaderProgramID programPacked,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLdouble v0);
 bool ValidateProgramUniform1dv(const Context *context,
                                ShaderProgramID programPacked,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLsizei count,
                                const GLdouble *value);
 bool ValidateProgramUniform2d(const Context *context,
                               ShaderProgramID programPacked,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLdouble v0,
                               GLdouble v1);
 bool ValidateProgramUniform2dv(const Context *context,
                                ShaderProgramID programPacked,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLsizei count,
                                const GLdouble *value);
 bool ValidateProgramUniform3d(const Context *context,
                               ShaderProgramID programPacked,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLdouble v0,
                               GLdouble v1,
                               GLdouble v2);
 bool ValidateProgramUniform3dv(const Context *context,
                                ShaderProgramID programPacked,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLsizei count,
                                const GLdouble *value);
 bool ValidateProgramUniform4d(const Context *context,
                               ShaderProgramID programPacked,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLdouble v0,
                               GLdouble v1,
                               GLdouble v2,
                               GLdouble v3);
 bool ValidateProgramUniform4dv(const Context *context,
                                ShaderProgramID programPacked,
-                               GLint location,
+                               UniformLocation locationPacked,
                                GLsizei count,
                                const GLdouble *value);
 bool ValidateProgramUniformMatrix2dv(const Context *context,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value);
 bool ValidateProgramUniformMatrix2x3dv(const Context *context,
                                        ShaderProgramID programPacked,
-                                       GLint location,
+                                       UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value);
 bool ValidateProgramUniformMatrix2x4dv(const Context *context,
                                        ShaderProgramID programPacked,
-                                       GLint location,
+                                       UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value);
 bool ValidateProgramUniformMatrix3dv(const Context *context,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value);
 bool ValidateProgramUniformMatrix3x2dv(const Context *context,
                                        ShaderProgramID programPacked,
-                                       GLint location,
+                                       UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value);
 bool ValidateProgramUniformMatrix3x4dv(const Context *context,
                                        ShaderProgramID programPacked,
-                                       GLint location,
+                                       UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value);
 bool ValidateProgramUniformMatrix4dv(const Context *context,
                                      ShaderProgramID programPacked,
-                                     GLint location,
+                                     UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value);
 bool ValidateProgramUniformMatrix4x2dv(const Context *context,
                                        ShaderProgramID programPacked,
-                                       GLint location,
+                                       UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value);
 bool ValidateProgramUniformMatrix4x3dv(const Context *context,
                                        ShaderProgramID programPacked,
-                                       GLint location,
+                                       UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value);
diff --git a/src/libANGLE/validationGL45.cpp b/src/libANGLE/validationGL45.cpp
index 0ac9931..d5b43d0 100644
--- a/src/libANGLE/validationGL45.cpp
+++ b/src/libANGLE/validationGL45.cpp
@@ -648,7 +648,7 @@
 
 bool ValidateGetnUniformdv(const Context *context,
                            ShaderProgramID program,
-                           GLint location,
+                           UniformLocation location,
                            GLsizei bufSize,
                            const GLdouble *params)
 {
diff --git a/src/libANGLE/validationGL45_autogen.h b/src/libANGLE/validationGL45_autogen.h
index 5c5a5bd..cb88064 100644
--- a/src/libANGLE/validationGL45_autogen.h
+++ b/src/libANGLE/validationGL45_autogen.h
@@ -376,7 +376,7 @@
                           const void *pixels);
 bool ValidateGetnUniformdv(const Context *context,
                            ShaderProgramID programPacked,
-                           GLint location,
+                           UniformLocation locationPacked,
                            GLsizei bufSize,
                            const GLdouble *params);
 bool ValidateInvalidateNamedFramebufferData(const Context *context,
diff --git a/src/libANGLE/validationGL4_autogen.h b/src/libANGLE/validationGL4_autogen.h
index f1b8ee9..8043f7d 100644
--- a/src/libANGLE/validationGL4_autogen.h
+++ b/src/libANGLE/validationGL4_autogen.h
@@ -73,76 +73,83 @@
                                      const GLuint *params);
 bool ValidateGetUniformdv(const Context *context,
                           ShaderProgramID programPacked,
-                          GLint location,
+                          UniformLocation locationPacked,
                           const GLdouble *params);
 bool ValidatePatchParameterfv(const Context *context, GLenum pname, const GLfloat *values);
-bool ValidateUniform1d(const Context *context, GLint location, GLdouble x);
+bool ValidateUniform1d(const Context *context, UniformLocation locationPacked, GLdouble x);
 bool ValidateUniform1dv(const Context *context,
-                        GLint location,
+                        UniformLocation locationPacked,
                         GLsizei count,
                         const GLdouble *value);
-bool ValidateUniform2d(const Context *context, GLint location, GLdouble x, GLdouble y);
+bool ValidateUniform2d(const Context *context,
+                       UniformLocation locationPacked,
+                       GLdouble x,
+                       GLdouble y);
 bool ValidateUniform2dv(const Context *context,
-                        GLint location,
+                        UniformLocation locationPacked,
                         GLsizei count,
                         const GLdouble *value);
-bool ValidateUniform3d(const Context *context, GLint location, GLdouble x, GLdouble y, GLdouble z);
+bool ValidateUniform3d(const Context *context,
+                       UniformLocation locationPacked,
+                       GLdouble x,
+                       GLdouble y,
+                       GLdouble z);
 bool ValidateUniform3dv(const Context *context,
-                        GLint location,
+                        UniformLocation locationPacked,
                         GLsizei count,
                         const GLdouble *value);
 bool ValidateUniform4d(const Context *context,
-                       GLint location,
+                       UniformLocation locationPacked,
                        GLdouble x,
                        GLdouble y,
                        GLdouble z,
                        GLdouble w);
 bool ValidateUniform4dv(const Context *context,
-                        GLint location,
+                        UniformLocation locationPacked,
                         GLsizei count,
                         const GLdouble *value);
 bool ValidateUniformMatrix2dv(const Context *context,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               GLboolean transpose,
                               const GLdouble *value);
 bool ValidateUniformMatrix2x3dv(const Context *context,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLdouble *value);
 bool ValidateUniformMatrix2x4dv(const Context *context,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLdouble *value);
 bool ValidateUniformMatrix3dv(const Context *context,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               GLboolean transpose,
                               const GLdouble *value);
 bool ValidateUniformMatrix3x2dv(const Context *context,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLdouble *value);
 bool ValidateUniformMatrix3x4dv(const Context *context,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLdouble *value);
 bool ValidateUniformMatrix4dv(const Context *context,
-                              GLint location,
+                              UniformLocation locationPacked,
                               GLsizei count,
                               GLboolean transpose,
                               const GLdouble *value);
 bool ValidateUniformMatrix4x2dv(const Context *context,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLdouble *value);
 bool ValidateUniformMatrix4x3dv(const Context *context,
-                                GLint location,
+                                UniformLocation locationPacked,
                                 GLsizei count,
                                 GLboolean transpose,
                                 const GLdouble *value);
diff --git a/src/libGL/entry_points_gl_2_0_autogen.cpp b/src/libGL/entry_points_gl_2_0_autogen.cpp
index 22d10e9..145ba18 100644
--- a/src/libGL/entry_points_gl_2_0_autogen.cpp
+++ b/src/libGL/entry_points_gl_2_0_autogen.cpp
@@ -564,14 +564,15 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetUniformfv(context, programPacked, location, params));
+                            ValidateGetUniformfv(context, programPacked, locationPacked, params));
         if (isCallValid)
         {
-            context->getUniformfv(programPacked, location, params);
+            context->getUniformfv(programPacked, locationPacked, params);
         }
-        ANGLE_CAPTURE(GetUniformfv, isCallValid, context, programPacked, location, params);
+        ANGLE_CAPTURE(GetUniformfv, isCallValid, context, programPacked, locationPacked, params);
     }
 }
 
@@ -586,14 +587,15 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetUniformiv(context, programPacked, location, params));
+                            ValidateGetUniformiv(context, programPacked, locationPacked, params));
         if (isCallValid)
         {
-            context->getUniformiv(programPacked, location, params);
+            context->getUniformiv(programPacked, locationPacked, params);
         }
-        ANGLE_CAPTURE(GetUniformiv, isCallValid, context, programPacked, location, params);
+        ANGLE_CAPTURE(GetUniformiv, isCallValid, context, programPacked, locationPacked, params);
     }
 }
 
@@ -851,13 +853,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid = (context->skipValidation() || ValidateUniform1f(context, location, v0));
+        bool isCallValid =
+            (context->skipValidation() || ValidateUniform1f(context, locationPacked, v0));
         if (isCallValid)
         {
-            context->uniform1f(location, v0);
+            context->uniform1f(locationPacked, v0);
         }
-        ANGLE_CAPTURE(Uniform1f, isCallValid, context, location, v0);
+        ANGLE_CAPTURE(Uniform1f, isCallValid, context, locationPacked, v0);
     }
 }
 
@@ -871,14 +875,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform1fv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform1fv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform1fv(location, count, value);
+            context->uniform1fv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform1fv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform1fv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -890,13 +895,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid = (context->skipValidation() || ValidateUniform1i(context, location, v0));
+        bool isCallValid =
+            (context->skipValidation() || ValidateUniform1i(context, locationPacked, v0));
         if (isCallValid)
         {
-            context->uniform1i(location, v0);
+            context->uniform1i(locationPacked, v0);
         }
-        ANGLE_CAPTURE(Uniform1i, isCallValid, context, location, v0);
+        ANGLE_CAPTURE(Uniform1i, isCallValid, context, locationPacked, v0);
     }
 }
 
@@ -911,14 +918,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform1iv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform1iv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform1iv(location, count, value);
+            context->uniform1iv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform1iv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform1iv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -930,14 +938,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform2f(context, location, v0, v1));
+            (context->skipValidation() || ValidateUniform2f(context, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->uniform2f(location, v0, v1);
+            context->uniform2f(locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(Uniform2f, isCallValid, context, location, v0, v1);
+        ANGLE_CAPTURE(Uniform2f, isCallValid, context, locationPacked, v0, v1);
     }
 }
 
@@ -951,14 +960,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform2fv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform2fv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform2fv(location, count, value);
+            context->uniform2fv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform2fv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform2fv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -970,14 +980,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform2i(context, location, v0, v1));
+            (context->skipValidation() || ValidateUniform2i(context, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->uniform2i(location, v0, v1);
+            context->uniform2i(locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(Uniform2i, isCallValid, context, location, v0, v1);
+        ANGLE_CAPTURE(Uniform2i, isCallValid, context, locationPacked, v0, v1);
     }
 }
 
@@ -992,14 +1003,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform2iv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform2iv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform2iv(location, count, value);
+            context->uniform2iv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform2iv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform2iv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -1012,14 +1024,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform3f(context, location, v0, v1, v2));
+            (context->skipValidation() || ValidateUniform3f(context, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->uniform3f(location, v0, v1, v2);
+            context->uniform3f(locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(Uniform3f, isCallValid, context, location, v0, v1, v2);
+        ANGLE_CAPTURE(Uniform3f, isCallValid, context, locationPacked, v0, v1, v2);
     }
 }
 
@@ -1033,14 +1046,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform3fv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform3fv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform3fv(location, count, value);
+            context->uniform3fv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform3fv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform3fv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -1053,14 +1067,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform3i(context, location, v0, v1, v2));
+            (context->skipValidation() || ValidateUniform3i(context, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->uniform3i(location, v0, v1, v2);
+            context->uniform3i(locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(Uniform3i, isCallValid, context, location, v0, v1, v2);
+        ANGLE_CAPTURE(Uniform3i, isCallValid, context, locationPacked, v0, v1, v2);
     }
 }
 
@@ -1075,14 +1090,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform3iv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform3iv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform3iv(location, count, value);
+            context->uniform3iv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform3iv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform3iv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -1096,14 +1112,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4f(context, location, v0, v1, v2, v3));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4f(context, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->uniform4f(location, v0, v1, v2, v3);
+            context->uniform4f(locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(Uniform4f, isCallValid, context, location, v0, v1, v2, v3);
+        ANGLE_CAPTURE(Uniform4f, isCallValid, context, locationPacked, v0, v1, v2, v3);
     }
 }
 
@@ -1117,14 +1134,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4fv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4fv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform4fv(location, count, value);
+            context->uniform4fv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform4fv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform4fv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -1138,14 +1156,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4i(context, location, v0, v1, v2, v3));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4i(context, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->uniform4i(location, v0, v1, v2, v3);
+            context->uniform4i(locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(Uniform4i, isCallValid, context, location, v0, v1, v2, v3);
+        ANGLE_CAPTURE(Uniform4i, isCallValid, context, locationPacked, v0, v1, v2, v3);
     }
 }
 
@@ -1160,14 +1179,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4iv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4iv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform4iv(location, count, value);
+            context->uniform4iv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform4iv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform4iv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -1184,14 +1204,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix2fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix2fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix2fv(location, count, transpose, value);
+            context->uniformMatrix2fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix2fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix2fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -1208,14 +1231,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix3fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix3fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix3fv(location, count, transpose, value);
+            context->uniformMatrix3fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix3fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix3fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -1232,14 +1258,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix4fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix4fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix4fv(location, count, transpose, value);
+            context->uniformMatrix4fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix4fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix4fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
diff --git a/src/libGL/entry_points_gl_2_1_autogen.cpp b/src/libGL/entry_points_gl_2_1_autogen.cpp
index d528bc3..6c56c00 100644
--- a/src/libGL/entry_points_gl_2_1_autogen.cpp
+++ b/src/libGL/entry_points_gl_2_1_autogen.cpp
@@ -40,14 +40,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix2x3fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix2x3fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix2x3fv(location, count, transpose, value);
+            context->uniformMatrix2x3fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix2x3fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix2x3fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -64,14 +67,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix2x4fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix2x4fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix2x4fv(location, count, transpose, value);
+            context->uniformMatrix2x4fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix2x4fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix2x4fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -88,14 +94,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix3x2fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix3x2fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix3x2fv(location, count, transpose, value);
+            context->uniformMatrix3x2fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix3x2fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix3x2fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -112,14 +121,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix3x4fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix3x4fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix3x4fv(location, count, transpose, value);
+            context->uniformMatrix3x4fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix3x4fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix3x4fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -136,14 +148,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix4x2fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix4x2fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix4x2fv(location, count, transpose, value);
+            context->uniformMatrix4x2fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix4x2fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix4x2fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -160,14 +175,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix4x3fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix4x3fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix4x3fv(location, count, transpose, value);
+            context->uniformMatrix4x3fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix4x3fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix4x3fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 }  // namespace gl
diff --git a/src/libGL/entry_points_gl_3_0_autogen.cpp b/src/libGL/entry_points_gl_3_0_autogen.cpp
index 91aa15a..47e3cbd 100644
--- a/src/libGL/entry_points_gl_3_0_autogen.cpp
+++ b/src/libGL/entry_points_gl_3_0_autogen.cpp
@@ -1018,14 +1018,15 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetUniformuiv(context, programPacked, location, params));
+                            ValidateGetUniformuiv(context, programPacked, locationPacked, params));
         if (isCallValid)
         {
-            context->getUniformuiv(programPacked, location, params);
+            context->getUniformuiv(programPacked, locationPacked, params);
         }
-        ANGLE_CAPTURE(GetUniformuiv, isCallValid, context, programPacked, location, params);
+        ANGLE_CAPTURE(GetUniformuiv, isCallValid, context, programPacked, locationPacked, params);
     }
 }
 
@@ -1364,13 +1365,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid = (context->skipValidation() || ValidateUniform1ui(context, location, v0));
+        bool isCallValid =
+            (context->skipValidation() || ValidateUniform1ui(context, locationPacked, v0));
         if (isCallValid)
         {
-            context->uniform1ui(location, v0);
+            context->uniform1ui(locationPacked, v0);
         }
-        ANGLE_CAPTURE(Uniform1ui, isCallValid, context, location, v0);
+        ANGLE_CAPTURE(Uniform1ui, isCallValid, context, locationPacked, v0);
     }
 }
 
@@ -1384,14 +1387,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform1uiv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform1uiv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform1uiv(location, count, value);
+            context->uniform1uiv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform1uiv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform1uiv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -1403,14 +1407,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform2ui(context, location, v0, v1));
+            (context->skipValidation() || ValidateUniform2ui(context, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->uniform2ui(location, v0, v1);
+            context->uniform2ui(locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(Uniform2ui, isCallValid, context, location, v0, v1);
+        ANGLE_CAPTURE(Uniform2ui, isCallValid, context, locationPacked, v0, v1);
     }
 }
 
@@ -1424,14 +1429,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform2uiv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform2uiv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform2uiv(location, count, value);
+            context->uniform2uiv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform2uiv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform2uiv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -1444,14 +1450,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform3ui(context, location, v0, v1, v2));
+            (context->skipValidation() || ValidateUniform3ui(context, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->uniform3ui(location, v0, v1, v2);
+            context->uniform3ui(locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(Uniform3ui, isCallValid, context, location, v0, v1, v2);
+        ANGLE_CAPTURE(Uniform3ui, isCallValid, context, locationPacked, v0, v1, v2);
     }
 }
 
@@ -1465,14 +1472,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform3uiv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform3uiv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform3uiv(location, count, value);
+            context->uniform3uiv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform3uiv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform3uiv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -1486,14 +1494,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4ui(context, location, v0, v1, v2, v3));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4ui(context, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->uniform4ui(location, v0, v1, v2, v3);
+            context->uniform4ui(locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(Uniform4ui, isCallValid, context, location, v0, v1, v2, v3);
+        ANGLE_CAPTURE(Uniform4ui, isCallValid, context, locationPacked, v0, v1, v2, v3);
     }
 }
 
@@ -1507,14 +1516,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4uiv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4uiv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform4uiv(location, count, value);
+            context->uniform4uiv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform4uiv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform4uiv, isCallValid, context, locationPacked, count, value);
     }
 }
 
diff --git a/src/libGL/entry_points_gl_4_0_autogen.cpp b/src/libGL/entry_points_gl_4_0_autogen.cpp
index 9580f97..ab7610b 100644
--- a/src/libGL/entry_points_gl_4_0_autogen.cpp
+++ b/src/libGL/entry_points_gl_4_0_autogen.cpp
@@ -547,14 +547,15 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetUniformdv(context, programPacked, location, params));
+                            ValidateGetUniformdv(context, programPacked, locationPacked, params));
         if (isCallValid)
         {
-            context->getUniformdv(programPacked, location, params);
+            context->getUniformdv(programPacked, locationPacked, params);
         }
-        ANGLE_CAPTURE(GetUniformdv, isCallValid, context, programPacked, location, params);
+        ANGLE_CAPTURE(GetUniformdv, isCallValid, context, programPacked, locationPacked, params);
     }
 }
 
@@ -685,13 +686,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid = (context->skipValidation() || ValidateUniform1d(context, location, x));
+        bool isCallValid =
+            (context->skipValidation() || ValidateUniform1d(context, locationPacked, x));
         if (isCallValid)
         {
-            context->uniform1d(location, x);
+            context->uniform1d(locationPacked, x);
         }
-        ANGLE_CAPTURE(Uniform1d, isCallValid, context, location, x);
+        ANGLE_CAPTURE(Uniform1d, isCallValid, context, locationPacked, x);
     }
 }
 
@@ -705,14 +708,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform1dv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform1dv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform1dv(location, count, value);
+            context->uniform1dv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform1dv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform1dv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -724,14 +728,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform2d(context, location, x, y));
+            (context->skipValidation() || ValidateUniform2d(context, locationPacked, x, y));
         if (isCallValid)
         {
-            context->uniform2d(location, x, y);
+            context->uniform2d(locationPacked, x, y);
         }
-        ANGLE_CAPTURE(Uniform2d, isCallValid, context, location, x, y);
+        ANGLE_CAPTURE(Uniform2d, isCallValid, context, locationPacked, x, y);
     }
 }
 
@@ -745,14 +750,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform2dv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform2dv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform2dv(location, count, value);
+            context->uniform2dv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform2dv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform2dv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -765,14 +771,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform3d(context, location, x, y, z));
+            (context->skipValidation() || ValidateUniform3d(context, locationPacked, x, y, z));
         if (isCallValid)
         {
-            context->uniform3d(location, x, y, z);
+            context->uniform3d(locationPacked, x, y, z);
         }
-        ANGLE_CAPTURE(Uniform3d, isCallValid, context, location, x, y, z);
+        ANGLE_CAPTURE(Uniform3d, isCallValid, context, locationPacked, x, y, z);
     }
 }
 
@@ -786,14 +793,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform3dv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform3dv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform3dv(location, count, value);
+            context->uniform3dv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform3dv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform3dv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -807,14 +815,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform4d(context, location, x, y, z, w));
+            (context->skipValidation() || ValidateUniform4d(context, locationPacked, x, y, z, w));
         if (isCallValid)
         {
-            context->uniform4d(location, x, y, z, w);
+            context->uniform4d(locationPacked, x, y, z, w);
         }
-        ANGLE_CAPTURE(Uniform4d, isCallValid, context, location, x, y, z, w);
+        ANGLE_CAPTURE(Uniform4d, isCallValid, context, locationPacked, x, y, z, w);
     }
 }
 
@@ -828,14 +837,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4dv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4dv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform4dv(location, count, value);
+            context->uniform4dv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform4dv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform4dv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -852,14 +862,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix2dv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix2dv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix2dv(location, count, transpose, value);
+            context->uniformMatrix2dv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix2dv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix2dv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -876,14 +889,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix2x3dv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix2x3dv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix2x3dv(location, count, transpose, value);
+            context->uniformMatrix2x3dv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix2x3dv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix2x3dv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -900,14 +916,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix2x4dv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix2x4dv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix2x4dv(location, count, transpose, value);
+            context->uniformMatrix2x4dv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix2x4dv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix2x4dv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -924,14 +943,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix3dv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix3dv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix3dv(location, count, transpose, value);
+            context->uniformMatrix3dv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix3dv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix3dv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -948,14 +970,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix3x2dv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix3x2dv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix3x2dv(location, count, transpose, value);
+            context->uniformMatrix3x2dv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix3x2dv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix3x2dv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -972,14 +997,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix3x4dv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix3x4dv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix3x4dv(location, count, transpose, value);
+            context->uniformMatrix3x4dv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix3x4dv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix3x4dv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -996,14 +1024,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix4dv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix4dv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix4dv(location, count, transpose, value);
+            context->uniformMatrix4dv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix4dv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix4dv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -1020,14 +1051,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix4x2dv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix4x2dv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix4x2dv(location, count, transpose, value);
+            context->uniformMatrix4x2dv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix4x2dv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix4x2dv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -1044,14 +1078,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix4x3dv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix4x3dv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix4x3dv(location, count, transpose, value);
+            context->uniformMatrix4x3dv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix4x3dv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix4x3dv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
diff --git a/src/libGL/entry_points_gl_4_1_autogen.cpp b/src/libGL/entry_points_gl_4_1_autogen.cpp
index f9567e8..dcccdd8 100644
--- a/src/libGL/entry_points_gl_4_1_autogen.cpp
+++ b/src/libGL/entry_points_gl_4_1_autogen.cpp
@@ -476,14 +476,15 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform1d(context, programPacked, location, v0));
+                            ValidateProgramUniform1d(context, programPacked, locationPacked, v0));
         if (isCallValid)
         {
-            context->programUniform1d(programPacked, location, v0);
+            context->programUniform1d(programPacked, locationPacked, v0);
         }
-        ANGLE_CAPTURE(ProgramUniform1d, isCallValid, context, programPacked, location, v0);
+        ANGLE_CAPTURE(ProgramUniform1d, isCallValid, context, programPacked, locationPacked, v0);
     }
 }
 
@@ -501,15 +502,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform1dv(context, programPacked, location, count, value));
+             ValidateProgramUniform1dv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform1dv(programPacked, location, count, value);
+            context->programUniform1dv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform1dv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform1dv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -524,14 +526,15 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform1f(context, programPacked, location, v0));
+                            ValidateProgramUniform1f(context, programPacked, locationPacked, v0));
         if (isCallValid)
         {
-            context->programUniform1f(programPacked, location, v0);
+            context->programUniform1f(programPacked, locationPacked, v0);
         }
-        ANGLE_CAPTURE(ProgramUniform1f, isCallValid, context, programPacked, location, v0);
+        ANGLE_CAPTURE(ProgramUniform1f, isCallValid, context, programPacked, locationPacked, v0);
     }
 }
 
@@ -549,15 +552,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform1fv(context, programPacked, location, count, value));
+             ValidateProgramUniform1fv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform1fv(programPacked, location, count, value);
+            context->programUniform1fv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform1fv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform1fv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -572,14 +576,15 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform1i(context, programPacked, location, v0));
+                            ValidateProgramUniform1i(context, programPacked, locationPacked, v0));
         if (isCallValid)
         {
-            context->programUniform1i(programPacked, location, v0);
+            context->programUniform1i(programPacked, locationPacked, v0);
         }
-        ANGLE_CAPTURE(ProgramUniform1i, isCallValid, context, programPacked, location, v0);
+        ANGLE_CAPTURE(ProgramUniform1i, isCallValid, context, programPacked, locationPacked, v0);
     }
 }
 
@@ -597,15 +602,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform1iv(context, programPacked, location, count, value));
+             ValidateProgramUniform1iv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform1iv(programPacked, location, count, value);
+            context->programUniform1iv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform1iv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform1iv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -620,14 +626,15 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform1ui(context, programPacked, location, v0));
+                            ValidateProgramUniform1ui(context, programPacked, locationPacked, v0));
         if (isCallValid)
         {
-            context->programUniform1ui(programPacked, location, v0);
+            context->programUniform1ui(programPacked, locationPacked, v0);
         }
-        ANGLE_CAPTURE(ProgramUniform1ui, isCallValid, context, programPacked, location, v0);
+        ANGLE_CAPTURE(ProgramUniform1ui, isCallValid, context, programPacked, locationPacked, v0);
     }
 }
 
@@ -645,16 +652,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform1uiv(context, programPacked, location, count, value));
+             ValidateProgramUniform1uiv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform1uiv(programPacked, location, count, value);
+            context->programUniform1uiv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform1uiv, isCallValid, context, programPacked, location, count,
-                      value);
+        ANGLE_CAPTURE(ProgramUniform1uiv, isCallValid, context, programPacked, locationPacked,
+                      count, value);
     }
 }
 
@@ -669,14 +677,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform2d(context, programPacked, location, v0, v1));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateProgramUniform2d(context, programPacked, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->programUniform2d(programPacked, location, v0, v1);
+            context->programUniform2d(programPacked, locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(ProgramUniform2d, isCallValid, context, programPacked, location, v0, v1);
+        ANGLE_CAPTURE(ProgramUniform2d, isCallValid, context, programPacked, locationPacked, v0,
+                      v1);
     }
 }
 
@@ -694,15 +705,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform2dv(context, programPacked, location, count, value));
+             ValidateProgramUniform2dv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform2dv(programPacked, location, count, value);
+            context->programUniform2dv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform2dv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform2dv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -718,14 +730,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform2f(context, programPacked, location, v0, v1));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateProgramUniform2f(context, programPacked, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->programUniform2f(programPacked, location, v0, v1);
+            context->programUniform2f(programPacked, locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(ProgramUniform2f, isCallValid, context, programPacked, location, v0, v1);
+        ANGLE_CAPTURE(ProgramUniform2f, isCallValid, context, programPacked, locationPacked, v0,
+                      v1);
     }
 }
 
@@ -743,15 +758,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform2fv(context, programPacked, location, count, value));
+             ValidateProgramUniform2fv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform2fv(programPacked, location, count, value);
+            context->programUniform2fv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform2fv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform2fv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -766,14 +782,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform2i(context, programPacked, location, v0, v1));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateProgramUniform2i(context, programPacked, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->programUniform2i(programPacked, location, v0, v1);
+            context->programUniform2i(programPacked, locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(ProgramUniform2i, isCallValid, context, programPacked, location, v0, v1);
+        ANGLE_CAPTURE(ProgramUniform2i, isCallValid, context, programPacked, locationPacked, v0,
+                      v1);
     }
 }
 
@@ -791,15 +810,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform2iv(context, programPacked, location, count, value));
+             ValidateProgramUniform2iv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform2iv(programPacked, location, count, value);
+            context->programUniform2iv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform2iv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform2iv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -814,14 +834,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform2ui(context, programPacked, location, v0, v1));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateProgramUniform2ui(context, programPacked, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->programUniform2ui(programPacked, location, v0, v1);
+            context->programUniform2ui(programPacked, locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(ProgramUniform2ui, isCallValid, context, programPacked, location, v0, v1);
+        ANGLE_CAPTURE(ProgramUniform2ui, isCallValid, context, programPacked, locationPacked, v0,
+                      v1);
     }
 }
 
@@ -839,16 +862,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform2uiv(context, programPacked, location, count, value));
+             ValidateProgramUniform2uiv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform2uiv(programPacked, location, count, value);
+            context->programUniform2uiv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform2uiv, isCallValid, context, programPacked, location, count,
-                      value);
+        ANGLE_CAPTURE(ProgramUniform2uiv, isCallValid, context, programPacked, locationPacked,
+                      count, value);
     }
 }
 
@@ -864,14 +888,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform3d(context, programPacked, location, v0, v1, v2));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateProgramUniform3d(context, programPacked, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->programUniform3d(programPacked, location, v0, v1, v2);
+            context->programUniform3d(programPacked, locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(ProgramUniform3d, isCallValid, context, programPacked, location, v0, v1, v2);
+        ANGLE_CAPTURE(ProgramUniform3d, isCallValid, context, programPacked, locationPacked, v0, v1,
+                      v2);
     }
 }
 
@@ -889,15 +916,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform3dv(context, programPacked, location, count, value));
+             ValidateProgramUniform3dv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform3dv(programPacked, location, count, value);
+            context->programUniform3dv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform3dv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform3dv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -914,14 +942,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform3f(context, programPacked, location, v0, v1, v2));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateProgramUniform3f(context, programPacked, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->programUniform3f(programPacked, location, v0, v1, v2);
+            context->programUniform3f(programPacked, locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(ProgramUniform3f, isCallValid, context, programPacked, location, v0, v1, v2);
+        ANGLE_CAPTURE(ProgramUniform3f, isCallValid, context, programPacked, locationPacked, v0, v1,
+                      v2);
     }
 }
 
@@ -939,15 +970,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform3fv(context, programPacked, location, count, value));
+             ValidateProgramUniform3fv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform3fv(programPacked, location, count, value);
+            context->programUniform3fv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform3fv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform3fv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -963,14 +995,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform3i(context, programPacked, location, v0, v1, v2));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateProgramUniform3i(context, programPacked, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->programUniform3i(programPacked, location, v0, v1, v2);
+            context->programUniform3i(programPacked, locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(ProgramUniform3i, isCallValid, context, programPacked, location, v0, v1, v2);
+        ANGLE_CAPTURE(ProgramUniform3i, isCallValid, context, programPacked, locationPacked, v0, v1,
+                      v2);
     }
 }
 
@@ -988,15 +1023,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform3iv(context, programPacked, location, count, value));
+             ValidateProgramUniform3iv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform3iv(programPacked, location, count, value);
+            context->programUniform3iv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform3iv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform3iv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -1012,15 +1048,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform3ui(context, programPacked, location, v0, v1, v2));
+             ValidateProgramUniform3ui(context, programPacked, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->programUniform3ui(programPacked, location, v0, v1, v2);
+            context->programUniform3ui(programPacked, locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(ProgramUniform3ui, isCallValid, context, programPacked, location, v0, v1, v2);
+        ANGLE_CAPTURE(ProgramUniform3ui, isCallValid, context, programPacked, locationPacked, v0,
+                      v1, v2);
     }
 }
 
@@ -1038,16 +1076,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform3uiv(context, programPacked, location, count, value));
+             ValidateProgramUniform3uiv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform3uiv(programPacked, location, count, value);
+            context->programUniform3uiv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform3uiv, isCallValid, context, programPacked, location, count,
-                      value);
+        ANGLE_CAPTURE(ProgramUniform3uiv, isCallValid, context, programPacked, locationPacked,
+                      count, value);
     }
 }
 
@@ -1063,16 +1102,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4d(context, programPacked, location, v0, v1, v2, v3));
+             ValidateProgramUniform4d(context, programPacked, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->programUniform4d(programPacked, location, v0, v1, v2, v3);
+            context->programUniform4d(programPacked, locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(ProgramUniform4d, isCallValid, context, programPacked, location, v0, v1, v2,
-                      v3);
+        ANGLE_CAPTURE(ProgramUniform4d, isCallValid, context, programPacked, locationPacked, v0, v1,
+                      v2, v3);
     }
 }
 
@@ -1090,15 +1130,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4dv(context, programPacked, location, count, value));
+             ValidateProgramUniform4dv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform4dv(programPacked, location, count, value);
+            context->programUniform4dv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform4dv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform4dv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -1115,16 +1156,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4f(context, programPacked, location, v0, v1, v2, v3));
+             ValidateProgramUniform4f(context, programPacked, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->programUniform4f(programPacked, location, v0, v1, v2, v3);
+            context->programUniform4f(programPacked, locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(ProgramUniform4f, isCallValid, context, programPacked, location, v0, v1, v2,
-                      v3);
+        ANGLE_CAPTURE(ProgramUniform4f, isCallValid, context, programPacked, locationPacked, v0, v1,
+                      v2, v3);
     }
 }
 
@@ -1142,15 +1184,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4fv(context, programPacked, location, count, value));
+             ValidateProgramUniform4fv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform4fv(programPacked, location, count, value);
+            context->programUniform4fv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform4fv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform4fv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -1167,16 +1210,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4i(context, programPacked, location, v0, v1, v2, v3));
+             ValidateProgramUniform4i(context, programPacked, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->programUniform4i(programPacked, location, v0, v1, v2, v3);
+            context->programUniform4i(programPacked, locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(ProgramUniform4i, isCallValid, context, programPacked, location, v0, v1, v2,
-                      v3);
+        ANGLE_CAPTURE(ProgramUniform4i, isCallValid, context, programPacked, locationPacked, v0, v1,
+                      v2, v3);
     }
 }
 
@@ -1194,15 +1238,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4iv(context, programPacked, location, count, value));
+             ValidateProgramUniform4iv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform4iv(programPacked, location, count, value);
+            context->programUniform4iv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform4iv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform4iv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -1219,16 +1264,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4ui(context, programPacked, location, v0, v1, v2, v3));
+             ValidateProgramUniform4ui(context, programPacked, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->programUniform4ui(programPacked, location, v0, v1, v2, v3);
+            context->programUniform4ui(programPacked, locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(ProgramUniform4ui, isCallValid, context, programPacked, location, v0, v1, v2,
-                      v3);
+        ANGLE_CAPTURE(ProgramUniform4ui, isCallValid, context, programPacked, locationPacked, v0,
+                      v1, v2, v3);
     }
 }
 
@@ -1246,16 +1292,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4uiv(context, programPacked, location, count, value));
+             ValidateProgramUniform4uiv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform4uiv(programPacked, location, count, value);
+            context->programUniform4uiv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform4uiv, isCallValid, context, programPacked, location, count,
-                      value);
+        ANGLE_CAPTURE(ProgramUniform4uiv, isCallValid, context, programPacked, locationPacked,
+                      count, value);
     }
 }
 
@@ -1274,16 +1321,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix2dv(context, programPacked, location, count,
-                                                            transpose, value));
+                            ValidateProgramUniformMatrix2dv(context, programPacked, locationPacked,
+                                                            count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix2dv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix2dv(programPacked, locationPacked, count, transpose,
+                                             value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix2dv, isCallValid, context, programPacked, location, count,
-                      transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix2dv, isCallValid, context, programPacked, locationPacked,
+                      count, transpose, value);
     }
 }
 
@@ -1302,16 +1351,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix2fv(context, programPacked, location, count,
-                                                            transpose, value));
+                            ValidateProgramUniformMatrix2fv(context, programPacked, locationPacked,
+                                                            count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix2fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix2fv(programPacked, locationPacked, count, transpose,
+                                             value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix2fv, isCallValid, context, programPacked, location, count,
-                      transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix2fv, isCallValid, context, programPacked, locationPacked,
+                      count, transpose, value);
     }
 }
 
@@ -1330,16 +1381,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix2x3dv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix2x3dv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix2x3dv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix2x3dv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix2x3dv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix2x3dv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -1358,16 +1411,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix2x3fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix2x3fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix2x3fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix2x3fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix2x3fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix2x3fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -1386,16 +1441,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix2x4dv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix2x4dv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix2x4dv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix2x4dv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix2x4dv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix2x4dv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -1414,16 +1471,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix2x4fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix2x4fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix2x4fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix2x4fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix2x4fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix2x4fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -1442,16 +1501,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix3dv(context, programPacked, location, count,
-                                                            transpose, value));
+                            ValidateProgramUniformMatrix3dv(context, programPacked, locationPacked,
+                                                            count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix3dv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix3dv(programPacked, locationPacked, count, transpose,
+                                             value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix3dv, isCallValid, context, programPacked, location, count,
-                      transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix3dv, isCallValid, context, programPacked, locationPacked,
+                      count, transpose, value);
     }
 }
 
@@ -1470,16 +1531,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix3fv(context, programPacked, location, count,
-                                                            transpose, value));
+                            ValidateProgramUniformMatrix3fv(context, programPacked, locationPacked,
+                                                            count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix3fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix3fv(programPacked, locationPacked, count, transpose,
+                                             value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix3fv, isCallValid, context, programPacked, location, count,
-                      transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix3fv, isCallValid, context, programPacked, locationPacked,
+                      count, transpose, value);
     }
 }
 
@@ -1498,16 +1561,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix3x2dv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix3x2dv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix3x2dv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix3x2dv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix3x2dv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix3x2dv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -1526,16 +1591,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix3x2fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix3x2fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix3x2fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix3x2fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix3x2fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix3x2fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -1554,16 +1621,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix3x4dv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix3x4dv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix3x4dv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix3x4dv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix3x4dv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix3x4dv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -1582,16 +1651,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix3x4fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix3x4fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix3x4fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix3x4fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix3x4fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix3x4fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -1610,16 +1681,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix4dv(context, programPacked, location, count,
-                                                            transpose, value));
+                            ValidateProgramUniformMatrix4dv(context, programPacked, locationPacked,
+                                                            count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix4dv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix4dv(programPacked, locationPacked, count, transpose,
+                                             value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix4dv, isCallValid, context, programPacked, location, count,
-                      transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix4dv, isCallValid, context, programPacked, locationPacked,
+                      count, transpose, value);
     }
 }
 
@@ -1638,16 +1711,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix4fv(context, programPacked, location, count,
-                                                            transpose, value));
+                            ValidateProgramUniformMatrix4fv(context, programPacked, locationPacked,
+                                                            count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix4fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix4fv(programPacked, locationPacked, count, transpose,
+                                             value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix4fv, isCallValid, context, programPacked, location, count,
-                      transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix4fv, isCallValid, context, programPacked, locationPacked,
+                      count, transpose, value);
     }
 }
 
@@ -1666,16 +1741,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix4x2dv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix4x2dv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix4x2dv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix4x2dv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix4x2dv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix4x2dv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -1694,16 +1771,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix4x2fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix4x2fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix4x2fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix4x2fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix4x2fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix4x2fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -1722,16 +1801,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix4x3dv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix4x3dv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix4x3dv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix4x3dv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix4x3dv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix4x3dv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -1750,16 +1831,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix4x3fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix4x3fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix4x3fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix4x3fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix4x3fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix4x3fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
diff --git a/src/libGL/entry_points_gl_4_5_autogen.cpp b/src/libGL/entry_points_gl_4_5_autogen.cpp
index 4fa1c81..f4d46fc 100644
--- a/src/libGL/entry_points_gl_4_5_autogen.cpp
+++ b/src/libGL/entry_points_gl_4_5_autogen.cpp
@@ -1878,15 +1878,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateGetnUniformdv(context, programPacked, location, bufSize, params));
+             ValidateGetnUniformdv(context, programPacked, locationPacked, bufSize, params));
         if (isCallValid)
         {
-            context->getnUniformdv(programPacked, location, bufSize, params);
+            context->getnUniformdv(programPacked, locationPacked, bufSize, params);
         }
-        ANGLE_CAPTURE(GetnUniformdv, isCallValid, context, programPacked, location, bufSize,
+        ANGLE_CAPTURE(GetnUniformdv, isCallValid, context, programPacked, locationPacked, bufSize,
                       params);
     }
 }
@@ -1902,15 +1903,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateGetnUniformfv(context, programPacked, location, bufSize, params));
+             ValidateGetnUniformfv(context, programPacked, locationPacked, bufSize, params));
         if (isCallValid)
         {
-            context->getnUniformfv(programPacked, location, bufSize, params);
+            context->getnUniformfv(programPacked, locationPacked, bufSize, params);
         }
-        ANGLE_CAPTURE(GetnUniformfv, isCallValid, context, programPacked, location, bufSize,
+        ANGLE_CAPTURE(GetnUniformfv, isCallValid, context, programPacked, locationPacked, bufSize,
                       params);
     }
 }
@@ -1926,15 +1928,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateGetnUniformiv(context, programPacked, location, bufSize, params));
+             ValidateGetnUniformiv(context, programPacked, locationPacked, bufSize, params));
         if (isCallValid)
         {
-            context->getnUniformiv(programPacked, location, bufSize, params);
+            context->getnUniformiv(programPacked, locationPacked, bufSize, params);
         }
-        ANGLE_CAPTURE(GetnUniformiv, isCallValid, context, programPacked, location, bufSize,
+        ANGLE_CAPTURE(GetnUniformiv, isCallValid, context, programPacked, locationPacked, bufSize,
                       params);
     }
 }
@@ -1950,15 +1953,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateGetnUniformuiv(context, programPacked, location, bufSize, params));
+             ValidateGetnUniformuiv(context, programPacked, locationPacked, bufSize, params));
         if (isCallValid)
         {
-            context->getnUniformuiv(programPacked, location, bufSize, params);
+            context->getnUniformuiv(programPacked, locationPacked, bufSize, params);
         }
-        ANGLE_CAPTURE(GetnUniformuiv, isCallValid, context, programPacked, location, bufSize,
+        ANGLE_CAPTURE(GetnUniformuiv, isCallValid, context, programPacked, locationPacked, bufSize,
                       params);
     }
 }
diff --git a/src/libGLESv2/entry_points_gles_2_0_autogen.cpp b/src/libGLESv2/entry_points_gles_2_0_autogen.cpp
index a356149..ca768d1 100644
--- a/src/libGLESv2/entry_points_gles_2_0_autogen.cpp
+++ b/src/libGLESv2/entry_points_gles_2_0_autogen.cpp
@@ -1745,14 +1745,15 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetUniformfv(context, programPacked, location, params));
+                            ValidateGetUniformfv(context, programPacked, locationPacked, params));
         if (isCallValid)
         {
-            context->getUniformfv(programPacked, location, params);
+            context->getUniformfv(programPacked, locationPacked, params);
         }
-        ANGLE_CAPTURE(GetUniformfv, isCallValid, context, programPacked, location, params);
+        ANGLE_CAPTURE(GetUniformfv, isCallValid, context, programPacked, locationPacked, params);
     }
 }
 
@@ -1767,14 +1768,15 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetUniformiv(context, programPacked, location, params));
+                            ValidateGetUniformiv(context, programPacked, locationPacked, params));
         if (isCallValid)
         {
-            context->getUniformiv(programPacked, location, params);
+            context->getUniformiv(programPacked, locationPacked, params);
         }
-        ANGLE_CAPTURE(GetUniformiv, isCallValid, context, programPacked, location, params);
+        ANGLE_CAPTURE(GetUniformiv, isCallValid, context, programPacked, locationPacked, params);
     }
 }
 
@@ -2587,13 +2589,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid = (context->skipValidation() || ValidateUniform1f(context, location, v0));
+        bool isCallValid =
+            (context->skipValidation() || ValidateUniform1f(context, locationPacked, v0));
         if (isCallValid)
         {
-            context->uniform1f(location, v0);
+            context->uniform1f(locationPacked, v0);
         }
-        ANGLE_CAPTURE(Uniform1f, isCallValid, context, location, v0);
+        ANGLE_CAPTURE(Uniform1f, isCallValid, context, locationPacked, v0);
     }
 }
 
@@ -2607,14 +2611,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform1fv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform1fv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform1fv(location, count, value);
+            context->uniform1fv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform1fv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform1fv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -2626,13 +2631,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid = (context->skipValidation() || ValidateUniform1i(context, location, v0));
+        bool isCallValid =
+            (context->skipValidation() || ValidateUniform1i(context, locationPacked, v0));
         if (isCallValid)
         {
-            context->uniform1i(location, v0);
+            context->uniform1i(locationPacked, v0);
         }
-        ANGLE_CAPTURE(Uniform1i, isCallValid, context, location, v0);
+        ANGLE_CAPTURE(Uniform1i, isCallValid, context, locationPacked, v0);
     }
 }
 
@@ -2647,14 +2654,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform1iv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform1iv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform1iv(location, count, value);
+            context->uniform1iv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform1iv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform1iv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -2666,14 +2674,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform2f(context, location, v0, v1));
+            (context->skipValidation() || ValidateUniform2f(context, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->uniform2f(location, v0, v1);
+            context->uniform2f(locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(Uniform2f, isCallValid, context, location, v0, v1);
+        ANGLE_CAPTURE(Uniform2f, isCallValid, context, locationPacked, v0, v1);
     }
 }
 
@@ -2687,14 +2696,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform2fv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform2fv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform2fv(location, count, value);
+            context->uniform2fv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform2fv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform2fv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -2706,14 +2716,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform2i(context, location, v0, v1));
+            (context->skipValidation() || ValidateUniform2i(context, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->uniform2i(location, v0, v1);
+            context->uniform2i(locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(Uniform2i, isCallValid, context, location, v0, v1);
+        ANGLE_CAPTURE(Uniform2i, isCallValid, context, locationPacked, v0, v1);
     }
 }
 
@@ -2728,14 +2739,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform2iv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform2iv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform2iv(location, count, value);
+            context->uniform2iv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform2iv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform2iv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -2748,14 +2760,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform3f(context, location, v0, v1, v2));
+            (context->skipValidation() || ValidateUniform3f(context, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->uniform3f(location, v0, v1, v2);
+            context->uniform3f(locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(Uniform3f, isCallValid, context, location, v0, v1, v2);
+        ANGLE_CAPTURE(Uniform3f, isCallValid, context, locationPacked, v0, v1, v2);
     }
 }
 
@@ -2769,14 +2782,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform3fv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform3fv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform3fv(location, count, value);
+            context->uniform3fv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform3fv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform3fv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -2789,14 +2803,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform3i(context, location, v0, v1, v2));
+            (context->skipValidation() || ValidateUniform3i(context, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->uniform3i(location, v0, v1, v2);
+            context->uniform3i(locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(Uniform3i, isCallValid, context, location, v0, v1, v2);
+        ANGLE_CAPTURE(Uniform3i, isCallValid, context, locationPacked, v0, v1, v2);
     }
 }
 
@@ -2811,14 +2826,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform3iv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform3iv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform3iv(location, count, value);
+            context->uniform3iv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform3iv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform3iv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -2832,14 +2848,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4f(context, location, v0, v1, v2, v3));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4f(context, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->uniform4f(location, v0, v1, v2, v3);
+            context->uniform4f(locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(Uniform4f, isCallValid, context, location, v0, v1, v2, v3);
+        ANGLE_CAPTURE(Uniform4f, isCallValid, context, locationPacked, v0, v1, v2, v3);
     }
 }
 
@@ -2853,14 +2870,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4fv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4fv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform4fv(location, count, value);
+            context->uniform4fv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform4fv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform4fv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -2874,14 +2892,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4i(context, location, v0, v1, v2, v3));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4i(context, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->uniform4i(location, v0, v1, v2, v3);
+            context->uniform4i(locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(Uniform4i, isCallValid, context, location, v0, v1, v2, v3);
+        ANGLE_CAPTURE(Uniform4i, isCallValid, context, locationPacked, v0, v1, v2, v3);
     }
 }
 
@@ -2896,14 +2915,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4iv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4iv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform4iv(location, count, value);
+            context->uniform4iv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform4iv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform4iv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -2920,14 +2940,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix2fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix2fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix2fv(location, count, transpose, value);
+            context->uniformMatrix2fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix2fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix2fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -2944,14 +2967,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix3fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix3fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix3fv(location, count, transpose, value);
+            context->uniformMatrix3fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix3fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix3fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -2968,14 +2994,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix4fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix4fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix4fv(location, count, transpose, value);
+            context->uniformMatrix4fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix4fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix4fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
diff --git a/src/libGLESv2/entry_points_gles_3_0_autogen.cpp b/src/libGLESv2/entry_points_gles_3_0_autogen.cpp
index e67de0b..12b223d 100644
--- a/src/libGLESv2/entry_points_gles_3_0_autogen.cpp
+++ b/src/libGLESv2/entry_points_gles_3_0_autogen.cpp
@@ -1393,14 +1393,15 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetUniformuiv(context, programPacked, location, params));
+                            ValidateGetUniformuiv(context, programPacked, locationPacked, params));
         if (isCallValid)
         {
-            context->getUniformuiv(programPacked, location, params);
+            context->getUniformuiv(programPacked, locationPacked, params);
         }
-        ANGLE_CAPTURE(GetUniformuiv, isCallValid, context, programPacked, location, params);
+        ANGLE_CAPTURE(GetUniformuiv, isCallValid, context, programPacked, locationPacked, params);
     }
 }
 
@@ -2070,13 +2071,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid = (context->skipValidation() || ValidateUniform1ui(context, location, v0));
+        bool isCallValid =
+            (context->skipValidation() || ValidateUniform1ui(context, locationPacked, v0));
         if (isCallValid)
         {
-            context->uniform1ui(location, v0);
+            context->uniform1ui(locationPacked, v0);
         }
-        ANGLE_CAPTURE(Uniform1ui, isCallValid, context, location, v0);
+        ANGLE_CAPTURE(Uniform1ui, isCallValid, context, locationPacked, v0);
     }
 }
 
@@ -2090,14 +2093,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform1uiv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform1uiv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform1uiv(location, count, value);
+            context->uniform1uiv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform1uiv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform1uiv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -2109,14 +2113,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform2ui(context, location, v0, v1));
+            (context->skipValidation() || ValidateUniform2ui(context, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->uniform2ui(location, v0, v1);
+            context->uniform2ui(locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(Uniform2ui, isCallValid, context, location, v0, v1);
+        ANGLE_CAPTURE(Uniform2ui, isCallValid, context, locationPacked, v0, v1);
     }
 }
 
@@ -2130,14 +2135,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform2uiv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform2uiv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform2uiv(location, count, value);
+            context->uniform2uiv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform2uiv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform2uiv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -2150,14 +2156,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform3ui(context, location, v0, v1, v2));
+            (context->skipValidation() || ValidateUniform3ui(context, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->uniform3ui(location, v0, v1, v2);
+            context->uniform3ui(locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(Uniform3ui, isCallValid, context, location, v0, v1, v2);
+        ANGLE_CAPTURE(Uniform3ui, isCallValid, context, locationPacked, v0, v1, v2);
     }
 }
 
@@ -2171,14 +2178,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform3uiv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform3uiv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform3uiv(location, count, value);
+            context->uniform3uiv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform3uiv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform3uiv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -2192,14 +2200,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4ui(context, location, v0, v1, v2, v3));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4ui(context, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->uniform4ui(location, v0, v1, v2, v3);
+            context->uniform4ui(locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(Uniform4ui, isCallValid, context, location, v0, v1, v2, v3);
+        ANGLE_CAPTURE(Uniform4ui, isCallValid, context, locationPacked, v0, v1, v2, v3);
     }
 }
 
@@ -2213,14 +2222,15 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4uiv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4uiv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform4uiv(location, count, value);
+            context->uniform4uiv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform4uiv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform4uiv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -2263,14 +2273,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix2x3fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix2x3fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix2x3fv(location, count, transpose, value);
+            context->uniformMatrix2x3fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix2x3fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix2x3fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -2287,14 +2300,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix2x4fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix2x4fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix2x4fv(location, count, transpose, value);
+            context->uniformMatrix2x4fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix2x4fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix2x4fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -2311,14 +2327,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix3x2fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix3x2fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix3x2fv(location, count, transpose, value);
+            context->uniformMatrix3x2fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix3x2fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix3x2fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -2335,14 +2354,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix3x4fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix3x4fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix3x4fv(location, count, transpose, value);
+            context->uniformMatrix3x4fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix3x4fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix3x4fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -2359,14 +2381,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix4x2fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix4x2fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix4x2fv(location, count, transpose, value);
+            context->uniformMatrix4x2fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix4x2fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix4x2fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -2383,14 +2408,17 @@
 
     if (context)
     {
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix4x3fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix4x3fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix4x3fv(location, count, transpose, value);
+            context->uniformMatrix4x3fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix4x3fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix4x3fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
diff --git a/src/libGLESv2/entry_points_gles_3_1_autogen.cpp b/src/libGLESv2/entry_points_gles_3_1_autogen.cpp
index f6cefd2..05b73ff 100644
--- a/src/libGLESv2/entry_points_gles_3_1_autogen.cpp
+++ b/src/libGLESv2/entry_points_gles_3_1_autogen.cpp
@@ -714,14 +714,15 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform1f(context, programPacked, location, v0));
+                            ValidateProgramUniform1f(context, programPacked, locationPacked, v0));
         if (isCallValid)
         {
-            context->programUniform1f(programPacked, location, v0);
+            context->programUniform1f(programPacked, locationPacked, v0);
         }
-        ANGLE_CAPTURE(ProgramUniform1f, isCallValid, context, programPacked, location, v0);
+        ANGLE_CAPTURE(ProgramUniform1f, isCallValid, context, programPacked, locationPacked, v0);
     }
 }
 
@@ -739,15 +740,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform1fv(context, programPacked, location, count, value));
+             ValidateProgramUniform1fv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform1fv(programPacked, location, count, value);
+            context->programUniform1fv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform1fv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform1fv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -762,14 +764,15 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform1i(context, programPacked, location, v0));
+                            ValidateProgramUniform1i(context, programPacked, locationPacked, v0));
         if (isCallValid)
         {
-            context->programUniform1i(programPacked, location, v0);
+            context->programUniform1i(programPacked, locationPacked, v0);
         }
-        ANGLE_CAPTURE(ProgramUniform1i, isCallValid, context, programPacked, location, v0);
+        ANGLE_CAPTURE(ProgramUniform1i, isCallValid, context, programPacked, locationPacked, v0);
     }
 }
 
@@ -787,15 +790,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform1iv(context, programPacked, location, count, value));
+             ValidateProgramUniform1iv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform1iv(programPacked, location, count, value);
+            context->programUniform1iv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform1iv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform1iv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -810,14 +814,15 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform1ui(context, programPacked, location, v0));
+                            ValidateProgramUniform1ui(context, programPacked, locationPacked, v0));
         if (isCallValid)
         {
-            context->programUniform1ui(programPacked, location, v0);
+            context->programUniform1ui(programPacked, locationPacked, v0);
         }
-        ANGLE_CAPTURE(ProgramUniform1ui, isCallValid, context, programPacked, location, v0);
+        ANGLE_CAPTURE(ProgramUniform1ui, isCallValid, context, programPacked, locationPacked, v0);
     }
 }
 
@@ -835,16 +840,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform1uiv(context, programPacked, location, count, value));
+             ValidateProgramUniform1uiv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform1uiv(programPacked, location, count, value);
+            context->programUniform1uiv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform1uiv, isCallValid, context, programPacked, location, count,
-                      value);
+        ANGLE_CAPTURE(ProgramUniform1uiv, isCallValid, context, programPacked, locationPacked,
+                      count, value);
     }
 }
 
@@ -859,14 +865,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform2f(context, programPacked, location, v0, v1));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateProgramUniform2f(context, programPacked, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->programUniform2f(programPacked, location, v0, v1);
+            context->programUniform2f(programPacked, locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(ProgramUniform2f, isCallValid, context, programPacked, location, v0, v1);
+        ANGLE_CAPTURE(ProgramUniform2f, isCallValid, context, programPacked, locationPacked, v0,
+                      v1);
     }
 }
 
@@ -884,15 +893,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform2fv(context, programPacked, location, count, value));
+             ValidateProgramUniform2fv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform2fv(programPacked, location, count, value);
+            context->programUniform2fv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform2fv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform2fv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -907,14 +917,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform2i(context, programPacked, location, v0, v1));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateProgramUniform2i(context, programPacked, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->programUniform2i(programPacked, location, v0, v1);
+            context->programUniform2i(programPacked, locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(ProgramUniform2i, isCallValid, context, programPacked, location, v0, v1);
+        ANGLE_CAPTURE(ProgramUniform2i, isCallValid, context, programPacked, locationPacked, v0,
+                      v1);
     }
 }
 
@@ -932,15 +945,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform2iv(context, programPacked, location, count, value));
+             ValidateProgramUniform2iv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform2iv(programPacked, location, count, value);
+            context->programUniform2iv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform2iv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform2iv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -955,14 +969,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform2ui(context, programPacked, location, v0, v1));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateProgramUniform2ui(context, programPacked, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->programUniform2ui(programPacked, location, v0, v1);
+            context->programUniform2ui(programPacked, locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(ProgramUniform2ui, isCallValid, context, programPacked, location, v0, v1);
+        ANGLE_CAPTURE(ProgramUniform2ui, isCallValid, context, programPacked, locationPacked, v0,
+                      v1);
     }
 }
 
@@ -980,16 +997,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform2uiv(context, programPacked, location, count, value));
+             ValidateProgramUniform2uiv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform2uiv(programPacked, location, count, value);
+            context->programUniform2uiv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform2uiv, isCallValid, context, programPacked, location, count,
-                      value);
+        ANGLE_CAPTURE(ProgramUniform2uiv, isCallValid, context, programPacked, locationPacked,
+                      count, value);
     }
 }
 
@@ -1005,14 +1023,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform3f(context, programPacked, location, v0, v1, v2));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateProgramUniform3f(context, programPacked, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->programUniform3f(programPacked, location, v0, v1, v2);
+            context->programUniform3f(programPacked, locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(ProgramUniform3f, isCallValid, context, programPacked, location, v0, v1, v2);
+        ANGLE_CAPTURE(ProgramUniform3f, isCallValid, context, programPacked, locationPacked, v0, v1,
+                      v2);
     }
 }
 
@@ -1030,15 +1051,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform3fv(context, programPacked, location, count, value));
+             ValidateProgramUniform3fv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform3fv(programPacked, location, count, value);
+            context->programUniform3fv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform3fv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform3fv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -1054,14 +1076,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform3i(context, programPacked, location, v0, v1, v2));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateProgramUniform3i(context, programPacked, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->programUniform3i(programPacked, location, v0, v1, v2);
+            context->programUniform3i(programPacked, locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(ProgramUniform3i, isCallValid, context, programPacked, location, v0, v1, v2);
+        ANGLE_CAPTURE(ProgramUniform3i, isCallValid, context, programPacked, locationPacked, v0, v1,
+                      v2);
     }
 }
 
@@ -1079,15 +1104,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform3iv(context, programPacked, location, count, value));
+             ValidateProgramUniform3iv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform3iv(programPacked, location, count, value);
+            context->programUniform3iv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform3iv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform3iv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -1103,15 +1129,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform3ui(context, programPacked, location, v0, v1, v2));
+             ValidateProgramUniform3ui(context, programPacked, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->programUniform3ui(programPacked, location, v0, v1, v2);
+            context->programUniform3ui(programPacked, locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(ProgramUniform3ui, isCallValid, context, programPacked, location, v0, v1, v2);
+        ANGLE_CAPTURE(ProgramUniform3ui, isCallValid, context, programPacked, locationPacked, v0,
+                      v1, v2);
     }
 }
 
@@ -1129,16 +1157,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform3uiv(context, programPacked, location, count, value));
+             ValidateProgramUniform3uiv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform3uiv(programPacked, location, count, value);
+            context->programUniform3uiv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform3uiv, isCallValid, context, programPacked, location, count,
-                      value);
+        ANGLE_CAPTURE(ProgramUniform3uiv, isCallValid, context, programPacked, locationPacked,
+                      count, value);
     }
 }
 
@@ -1154,16 +1183,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4f(context, programPacked, location, v0, v1, v2, v3));
+             ValidateProgramUniform4f(context, programPacked, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->programUniform4f(programPacked, location, v0, v1, v2, v3);
+            context->programUniform4f(programPacked, locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(ProgramUniform4f, isCallValid, context, programPacked, location, v0, v1, v2,
-                      v3);
+        ANGLE_CAPTURE(ProgramUniform4f, isCallValid, context, programPacked, locationPacked, v0, v1,
+                      v2, v3);
     }
 }
 
@@ -1181,15 +1211,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4fv(context, programPacked, location, count, value));
+             ValidateProgramUniform4fv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform4fv(programPacked, location, count, value);
+            context->programUniform4fv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform4fv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform4fv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -1206,16 +1237,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4i(context, programPacked, location, v0, v1, v2, v3));
+             ValidateProgramUniform4i(context, programPacked, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->programUniform4i(programPacked, location, v0, v1, v2, v3);
+            context->programUniform4i(programPacked, locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(ProgramUniform4i, isCallValid, context, programPacked, location, v0, v1, v2,
-                      v3);
+        ANGLE_CAPTURE(ProgramUniform4i, isCallValid, context, programPacked, locationPacked, v0, v1,
+                      v2, v3);
     }
 }
 
@@ -1233,15 +1265,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4iv(context, programPacked, location, count, value));
+             ValidateProgramUniform4iv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform4iv(programPacked, location, count, value);
+            context->programUniform4iv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform4iv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform4iv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -1258,16 +1291,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4ui(context, programPacked, location, v0, v1, v2, v3));
+             ValidateProgramUniform4ui(context, programPacked, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->programUniform4ui(programPacked, location, v0, v1, v2, v3);
+            context->programUniform4ui(programPacked, locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(ProgramUniform4ui, isCallValid, context, programPacked, location, v0, v1, v2,
-                      v3);
+        ANGLE_CAPTURE(ProgramUniform4ui, isCallValid, context, programPacked, locationPacked, v0,
+                      v1, v2, v3);
     }
 }
 
@@ -1285,16 +1319,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4uiv(context, programPacked, location, count, value));
+             ValidateProgramUniform4uiv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform4uiv(programPacked, location, count, value);
+            context->programUniform4uiv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform4uiv, isCallValid, context, programPacked, location, count,
-                      value);
+        ANGLE_CAPTURE(ProgramUniform4uiv, isCallValid, context, programPacked, locationPacked,
+                      count, value);
     }
 }
 
@@ -1313,16 +1348,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix2fv(context, programPacked, location, count,
-                                                            transpose, value));
+                            ValidateProgramUniformMatrix2fv(context, programPacked, locationPacked,
+                                                            count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix2fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix2fv(programPacked, locationPacked, count, transpose,
+                                             value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix2fv, isCallValid, context, programPacked, location, count,
-                      transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix2fv, isCallValid, context, programPacked, locationPacked,
+                      count, transpose, value);
     }
 }
 
@@ -1341,16 +1378,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix2x3fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix2x3fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix2x3fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix2x3fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix2x3fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix2x3fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -1369,16 +1408,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix2x4fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix2x4fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix2x4fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix2x4fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix2x4fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix2x4fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -1397,16 +1438,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix3fv(context, programPacked, location, count,
-                                                            transpose, value));
+                            ValidateProgramUniformMatrix3fv(context, programPacked, locationPacked,
+                                                            count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix3fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix3fv(programPacked, locationPacked, count, transpose,
+                                             value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix3fv, isCallValid, context, programPacked, location, count,
-                      transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix3fv, isCallValid, context, programPacked, locationPacked,
+                      count, transpose, value);
     }
 }
 
@@ -1425,16 +1468,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix3x2fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix3x2fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix3x2fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix3x2fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix3x2fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix3x2fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -1453,16 +1498,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix3x4fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix3x4fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix3x4fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix3x4fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix3x4fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix3x4fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -1481,16 +1528,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix4fv(context, programPacked, location, count,
-                                                            transpose, value));
+                            ValidateProgramUniformMatrix4fv(context, programPacked, locationPacked,
+                                                            count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix4fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix4fv(programPacked, locationPacked, count, transpose,
+                                             value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix4fv, isCallValid, context, programPacked, location, count,
-                      transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix4fv, isCallValid, context, programPacked, locationPacked,
+                      count, transpose, value);
     }
 }
 
@@ -1509,16 +1558,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix4x2fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix4x2fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix4x2fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix4x2fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix4x2fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix4x2fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -1537,16 +1588,18 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix4x3fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix4x3fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix4x3fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix4x3fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix4x3fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix4x3fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
diff --git a/src/libGLESv2/entry_points_gles_3_2_autogen.cpp b/src/libGLESv2/entry_points_gles_3_2_autogen.cpp
index ddc15ec..716a3a3 100644
--- a/src/libGLESv2/entry_points_gles_3_2_autogen.cpp
+++ b/src/libGLESv2/entry_points_gles_3_2_autogen.cpp
@@ -668,15 +668,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateGetnUniformfv(context, programPacked, location, bufSize, params));
+             ValidateGetnUniformfv(context, programPacked, locationPacked, bufSize, params));
         if (isCallValid)
         {
-            context->getnUniformfv(programPacked, location, bufSize, params);
+            context->getnUniformfv(programPacked, locationPacked, bufSize, params);
         }
-        ANGLE_CAPTURE(GetnUniformfv, isCallValid, context, programPacked, location, bufSize,
+        ANGLE_CAPTURE(GetnUniformfv, isCallValid, context, programPacked, locationPacked, bufSize,
                       params);
     }
 }
@@ -692,15 +693,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateGetnUniformiv(context, programPacked, location, bufSize, params));
+             ValidateGetnUniformiv(context, programPacked, locationPacked, bufSize, params));
         if (isCallValid)
         {
-            context->getnUniformiv(programPacked, location, bufSize, params);
+            context->getnUniformiv(programPacked, locationPacked, bufSize, params);
         }
-        ANGLE_CAPTURE(GetnUniformiv, isCallValid, context, programPacked, location, bufSize,
+        ANGLE_CAPTURE(GetnUniformiv, isCallValid, context, programPacked, locationPacked, bufSize,
                       params);
     }
 }
@@ -716,15 +718,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateGetnUniformuiv(context, programPacked, location, bufSize, params));
+             ValidateGetnUniformuiv(context, programPacked, locationPacked, bufSize, params));
         if (isCallValid)
         {
-            context->getnUniformuiv(programPacked, location, bufSize, params);
+            context->getnUniformuiv(programPacked, locationPacked, bufSize, params);
         }
-        ANGLE_CAPTURE(GetnUniformuiv, isCallValid, context, programPacked, location, bufSize,
+        ANGLE_CAPTURE(GetnUniformuiv, isCallValid, context, programPacked, locationPacked, bufSize,
                       params);
     }
 }
diff --git a/src/libGLESv2/entry_points_gles_ext_autogen.cpp b/src/libGLESv2/entry_points_gles_ext_autogen.cpp
index cf6bc9d..d19cc9c 100644
--- a/src/libGLESv2/entry_points_gles_ext_autogen.cpp
+++ b/src/libGLESv2/entry_points_gles_ext_autogen.cpp
@@ -987,15 +987,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetUniformfvRobustANGLE(context, programPacked, location,
+                            ValidateGetUniformfvRobustANGLE(context, programPacked, locationPacked,
                                                             bufSize, length, params));
         if (isCallValid)
         {
-            context->getUniformfvRobust(programPacked, location, bufSize, length, params);
+            context->getUniformfvRobust(programPacked, locationPacked, bufSize, length, params);
         }
-        ANGLE_CAPTURE(GetUniformfvRobustANGLE, isCallValid, context, programPacked, location,
+        ANGLE_CAPTURE(GetUniformfvRobustANGLE, isCallValid, context, programPacked, locationPacked,
                       bufSize, length, params);
     }
 }
@@ -1015,15 +1016,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetUniformivRobustANGLE(context, programPacked, location,
+                            ValidateGetUniformivRobustANGLE(context, programPacked, locationPacked,
                                                             bufSize, length, params));
         if (isCallValid)
         {
-            context->getUniformivRobust(programPacked, location, bufSize, length, params);
+            context->getUniformivRobust(programPacked, locationPacked, bufSize, length, params);
         }
-        ANGLE_CAPTURE(GetUniformivRobustANGLE, isCallValid, context, programPacked, location,
+        ANGLE_CAPTURE(GetUniformivRobustANGLE, isCallValid, context, programPacked, locationPacked,
                       bufSize, length, params);
     }
 }
@@ -1735,15 +1737,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetUniformuivRobustANGLE(context, programPacked, location,
+                            ValidateGetUniformuivRobustANGLE(context, programPacked, locationPacked,
                                                              bufSize, length, params));
         if (isCallValid)
         {
-            context->getUniformuivRobust(programPacked, location, bufSize, length, params);
+            context->getUniformuivRobust(programPacked, locationPacked, bufSize, length, params);
         }
-        ANGLE_CAPTURE(GetUniformuivRobustANGLE, isCallValid, context, programPacked, location,
+        ANGLE_CAPTURE(GetUniformuivRobustANGLE, isCallValid, context, programPacked, locationPacked,
                       bufSize, length, params);
     }
 }
@@ -2244,15 +2247,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetnUniformfvRobustANGLE(context, programPacked, location,
+                            ValidateGetnUniformfvRobustANGLE(context, programPacked, locationPacked,
                                                              bufSize, length, params));
         if (isCallValid)
         {
-            context->getnUniformfvRobust(programPacked, location, bufSize, length, params);
+            context->getnUniformfvRobust(programPacked, locationPacked, bufSize, length, params);
         }
-        ANGLE_CAPTURE(GetnUniformfvRobustANGLE, isCallValid, context, programPacked, location,
+        ANGLE_CAPTURE(GetnUniformfvRobustANGLE, isCallValid, context, programPacked, locationPacked,
                       bufSize, length, params);
     }
 }
@@ -2272,15 +2276,16 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetnUniformivRobustANGLE(context, programPacked, location,
+                            ValidateGetnUniformivRobustANGLE(context, programPacked, locationPacked,
                                                              bufSize, length, params));
         if (isCallValid)
         {
-            context->getnUniformivRobust(programPacked, location, bufSize, length, params);
+            context->getnUniformivRobust(programPacked, locationPacked, bufSize, length, params);
         }
-        ANGLE_CAPTURE(GetnUniformivRobustANGLE, isCallValid, context, programPacked, location,
+        ANGLE_CAPTURE(GetnUniformivRobustANGLE, isCallValid, context, programPacked, locationPacked,
                       bufSize, length, params);
     }
 }
@@ -2300,16 +2305,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetnUniformuivRobustANGLE(context, programPacked, location,
-                                                              bufSize, length, params));
+                            ValidateGetnUniformuivRobustANGLE(
+                                context, programPacked, locationPacked, bufSize, length, params));
         if (isCallValid)
         {
-            context->getnUniformuivRobust(programPacked, location, bufSize, length, params);
+            context->getnUniformuivRobust(programPacked, locationPacked, bufSize, length, params);
         }
-        ANGLE_CAPTURE(GetnUniformuivRobustANGLE, isCallValid, context, programPacked, location,
-                      bufSize, length, params);
+        ANGLE_CAPTURE(GetnUniformuivRobustANGLE, isCallValid, context, programPacked,
+                      locationPacked, bufSize, length, params);
     }
 }
 
@@ -2884,16 +2890,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateBindUniformLocationCHROMIUM(context, programPacked, location, name));
+             ValidateBindUniformLocationCHROMIUM(context, programPacked, locationPacked, name));
         if (isCallValid)
         {
-            context->bindUniformLocation(programPacked, location, name);
+            context->bindUniformLocation(programPacked, locationPacked, name);
         }
-        ANGLE_CAPTURE(BindUniformLocationCHROMIUM, isCallValid, context, programPacked, location,
-                      name);
+        ANGLE_CAPTURE(BindUniformLocationCHROMIUM, isCallValid, context, programPacked,
+                      locationPacked, name);
     }
 }
 
@@ -4988,16 +4995,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateGetnUniformfvEXT(context, programPacked, location, bufSize, params));
+             ValidateGetnUniformfvEXT(context, programPacked, locationPacked, bufSize, params));
         if (isCallValid)
         {
-            context->getnUniformfv(programPacked, location, bufSize, params);
+            context->getnUniformfv(programPacked, locationPacked, bufSize, params);
         }
-        ANGLE_CAPTURE(GetnUniformfvEXT, isCallValid, context, programPacked, location, bufSize,
-                      params);
+        ANGLE_CAPTURE(GetnUniformfvEXT, isCallValid, context, programPacked, locationPacked,
+                      bufSize, params);
     }
 }
 
@@ -5012,16 +5020,17 @@
     if (context)
     {
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateGetnUniformivEXT(context, programPacked, location, bufSize, params));
+             ValidateGetnUniformivEXT(context, programPacked, locationPacked, bufSize, params));
         if (isCallValid)
         {
-            context->getnUniformiv(programPacked, location, bufSize, params);
+            context->getnUniformiv(programPacked, locationPacked, bufSize, params);
         }
-        ANGLE_CAPTURE(GetnUniformivEXT, isCallValid, context, programPacked, location, bufSize,
-                      params);
+        ANGLE_CAPTURE(GetnUniformivEXT, isCallValid, context, programPacked, locationPacked,
+                      bufSize, params);
     }
 }
 
@@ -15482,14 +15491,15 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetUniformfv(context, programPacked, location, params));
+                            ValidateGetUniformfv(context, programPacked, locationPacked, params));
         if (isCallValid)
         {
-            context->getUniformfv(programPacked, location, params);
+            context->getUniformfv(programPacked, locationPacked, params);
         }
-        ANGLE_CAPTURE(GetUniformfv, isCallValid, context, programPacked, location, params);
+        ANGLE_CAPTURE(GetUniformfv, isCallValid, context, programPacked, locationPacked, params);
     }
 }
 
@@ -15508,14 +15518,15 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetUniformiv(context, programPacked, location, params));
+                            ValidateGetUniformiv(context, programPacked, locationPacked, params));
         if (isCallValid)
         {
-            context->getUniformiv(programPacked, location, params);
+            context->getUniformiv(programPacked, locationPacked, params);
         }
-        ANGLE_CAPTURE(GetUniformiv, isCallValid, context, programPacked, location, params);
+        ANGLE_CAPTURE(GetUniformiv, isCallValid, context, programPacked, locationPacked, params);
     }
 }
 
@@ -15534,14 +15545,15 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetUniformuiv(context, programPacked, location, params));
+                            ValidateGetUniformuiv(context, programPacked, locationPacked, params));
         if (isCallValid)
         {
-            context->getUniformuiv(programPacked, location, params);
+            context->getUniformuiv(programPacked, locationPacked, params);
         }
-        ANGLE_CAPTURE(GetUniformuiv, isCallValid, context, programPacked, location, params);
+        ANGLE_CAPTURE(GetUniformuiv, isCallValid, context, programPacked, locationPacked, params);
     }
 }
 
@@ -15729,15 +15741,16 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateGetnUniformfv(context, programPacked, location, bufSize, params));
+             ValidateGetnUniformfv(context, programPacked, locationPacked, bufSize, params));
         if (isCallValid)
         {
-            context->getnUniformfv(programPacked, location, bufSize, params);
+            context->getnUniformfv(programPacked, locationPacked, bufSize, params);
         }
-        ANGLE_CAPTURE(GetnUniformfv, isCallValid, context, programPacked, location, bufSize,
+        ANGLE_CAPTURE(GetnUniformfv, isCallValid, context, programPacked, locationPacked, bufSize,
                       params);
     }
 }
@@ -15758,16 +15771,17 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateGetnUniformfvEXT(context, programPacked, location, bufSize, params));
+             ValidateGetnUniformfvEXT(context, programPacked, locationPacked, bufSize, params));
         if (isCallValid)
         {
-            context->getnUniformfv(programPacked, location, bufSize, params);
+            context->getnUniformfv(programPacked, locationPacked, bufSize, params);
         }
-        ANGLE_CAPTURE(GetnUniformfvEXT, isCallValid, context, programPacked, location, bufSize,
-                      params);
+        ANGLE_CAPTURE(GetnUniformfvEXT, isCallValid, context, programPacked, locationPacked,
+                      bufSize, params);
     }
 }
 
@@ -15787,15 +15801,16 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateGetnUniformiv(context, programPacked, location, bufSize, params));
+             ValidateGetnUniformiv(context, programPacked, locationPacked, bufSize, params));
         if (isCallValid)
         {
-            context->getnUniformiv(programPacked, location, bufSize, params);
+            context->getnUniformiv(programPacked, locationPacked, bufSize, params);
         }
-        ANGLE_CAPTURE(GetnUniformiv, isCallValid, context, programPacked, location, bufSize,
+        ANGLE_CAPTURE(GetnUniformiv, isCallValid, context, programPacked, locationPacked, bufSize,
                       params);
     }
 }
@@ -15816,16 +15831,17 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateGetnUniformivEXT(context, programPacked, location, bufSize, params));
+             ValidateGetnUniformivEXT(context, programPacked, locationPacked, bufSize, params));
         if (isCallValid)
         {
-            context->getnUniformiv(programPacked, location, bufSize, params);
+            context->getnUniformiv(programPacked, locationPacked, bufSize, params);
         }
-        ANGLE_CAPTURE(GetnUniformivEXT, isCallValid, context, programPacked, location, bufSize,
-                      params);
+        ANGLE_CAPTURE(GetnUniformivEXT, isCallValid, context, programPacked, locationPacked,
+                      bufSize, params);
     }
 }
 
@@ -15845,15 +15861,16 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateGetnUniformuiv(context, programPacked, location, bufSize, params));
+             ValidateGetnUniformuiv(context, programPacked, locationPacked, bufSize, params));
         if (isCallValid)
         {
-            context->getnUniformuiv(programPacked, location, bufSize, params);
+            context->getnUniformuiv(programPacked, locationPacked, bufSize, params);
         }
-        ANGLE_CAPTURE(GetnUniformuiv, isCallValid, context, programPacked, location, bufSize,
+        ANGLE_CAPTURE(GetnUniformuiv, isCallValid, context, programPacked, locationPacked, bufSize,
                       params);
     }
 }
@@ -18146,14 +18163,15 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform1f(context, programPacked, location, v0));
+                            ValidateProgramUniform1f(context, programPacked, locationPacked, v0));
         if (isCallValid)
         {
-            context->programUniform1f(programPacked, location, v0);
+            context->programUniform1f(programPacked, locationPacked, v0);
         }
-        ANGLE_CAPTURE(ProgramUniform1f, isCallValid, context, programPacked, location, v0);
+        ANGLE_CAPTURE(ProgramUniform1f, isCallValid, context, programPacked, locationPacked, v0);
     }
 }
 
@@ -18173,15 +18191,16 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform1fv(context, programPacked, location, count, value));
+             ValidateProgramUniform1fv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform1fv(programPacked, location, count, value);
+            context->programUniform1fv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform1fv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform1fv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -18200,14 +18219,15 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform1i(context, programPacked, location, v0));
+                            ValidateProgramUniform1i(context, programPacked, locationPacked, v0));
         if (isCallValid)
         {
-            context->programUniform1i(programPacked, location, v0);
+            context->programUniform1i(programPacked, locationPacked, v0);
         }
-        ANGLE_CAPTURE(ProgramUniform1i, isCallValid, context, programPacked, location, v0);
+        ANGLE_CAPTURE(ProgramUniform1i, isCallValid, context, programPacked, locationPacked, v0);
     }
 }
 
@@ -18227,15 +18247,16 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform1iv(context, programPacked, location, count, value));
+             ValidateProgramUniform1iv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform1iv(programPacked, location, count, value);
+            context->programUniform1iv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform1iv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform1iv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -18254,14 +18275,15 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform1ui(context, programPacked, location, v0));
+                            ValidateProgramUniform1ui(context, programPacked, locationPacked, v0));
         if (isCallValid)
         {
-            context->programUniform1ui(programPacked, location, v0);
+            context->programUniform1ui(programPacked, locationPacked, v0);
         }
-        ANGLE_CAPTURE(ProgramUniform1ui, isCallValid, context, programPacked, location, v0);
+        ANGLE_CAPTURE(ProgramUniform1ui, isCallValid, context, programPacked, locationPacked, v0);
     }
 }
 
@@ -18281,16 +18303,17 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform1uiv(context, programPacked, location, count, value));
+             ValidateProgramUniform1uiv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform1uiv(programPacked, location, count, value);
+            context->programUniform1uiv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform1uiv, isCallValid, context, programPacked, location, count,
-                      value);
+        ANGLE_CAPTURE(ProgramUniform1uiv, isCallValid, context, programPacked, locationPacked,
+                      count, value);
     }
 }
 
@@ -18310,14 +18333,17 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform2f(context, programPacked, location, v0, v1));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateProgramUniform2f(context, programPacked, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->programUniform2f(programPacked, location, v0, v1);
+            context->programUniform2f(programPacked, locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(ProgramUniform2f, isCallValid, context, programPacked, location, v0, v1);
+        ANGLE_CAPTURE(ProgramUniform2f, isCallValid, context, programPacked, locationPacked, v0,
+                      v1);
     }
 }
 
@@ -18337,15 +18363,16 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform2fv(context, programPacked, location, count, value));
+             ValidateProgramUniform2fv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform2fv(programPacked, location, count, value);
+            context->programUniform2fv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform2fv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform2fv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -18362,14 +18389,17 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform2i(context, programPacked, location, v0, v1));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateProgramUniform2i(context, programPacked, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->programUniform2i(programPacked, location, v0, v1);
+            context->programUniform2i(programPacked, locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(ProgramUniform2i, isCallValid, context, programPacked, location, v0, v1);
+        ANGLE_CAPTURE(ProgramUniform2i, isCallValid, context, programPacked, locationPacked, v0,
+                      v1);
     }
 }
 
@@ -18389,15 +18419,16 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform2iv(context, programPacked, location, count, value));
+             ValidateProgramUniform2iv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform2iv(programPacked, location, count, value);
+            context->programUniform2iv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform2iv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform2iv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -18417,14 +18448,17 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform2ui(context, programPacked, location, v0, v1));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateProgramUniform2ui(context, programPacked, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->programUniform2ui(programPacked, location, v0, v1);
+            context->programUniform2ui(programPacked, locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(ProgramUniform2ui, isCallValid, context, programPacked, location, v0, v1);
+        ANGLE_CAPTURE(ProgramUniform2ui, isCallValid, context, programPacked, locationPacked, v0,
+                      v1);
     }
 }
 
@@ -18444,16 +18478,17 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform2uiv(context, programPacked, location, count, value));
+             ValidateProgramUniform2uiv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform2uiv(programPacked, location, count, value);
+            context->programUniform2uiv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform2uiv, isCallValid, context, programPacked, location, count,
-                      value);
+        ANGLE_CAPTURE(ProgramUniform2uiv, isCallValid, context, programPacked, locationPacked,
+                      count, value);
     }
 }
 
@@ -18474,14 +18509,17 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform3f(context, programPacked, location, v0, v1, v2));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateProgramUniform3f(context, programPacked, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->programUniform3f(programPacked, location, v0, v1, v2);
+            context->programUniform3f(programPacked, locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(ProgramUniform3f, isCallValid, context, programPacked, location, v0, v1, v2);
+        ANGLE_CAPTURE(ProgramUniform3f, isCallValid, context, programPacked, locationPacked, v0, v1,
+                      v2);
     }
 }
 
@@ -18501,15 +18539,16 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform3fv(context, programPacked, location, count, value));
+             ValidateProgramUniform3fv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform3fv(programPacked, location, count, value);
+            context->programUniform3fv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform3fv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform3fv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -18531,14 +18570,17 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniform3i(context, programPacked, location, v0, v1, v2));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateProgramUniform3i(context, programPacked, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->programUniform3i(programPacked, location, v0, v1, v2);
+            context->programUniform3i(programPacked, locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(ProgramUniform3i, isCallValid, context, programPacked, location, v0, v1, v2);
+        ANGLE_CAPTURE(ProgramUniform3i, isCallValid, context, programPacked, locationPacked, v0, v1,
+                      v2);
     }
 }
 
@@ -18558,15 +18600,16 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform3iv(context, programPacked, location, count, value));
+             ValidateProgramUniform3iv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform3iv(programPacked, location, count, value);
+            context->programUniform3iv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform3iv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform3iv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -18588,15 +18631,17 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform3ui(context, programPacked, location, v0, v1, v2));
+             ValidateProgramUniform3ui(context, programPacked, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->programUniform3ui(programPacked, location, v0, v1, v2);
+            context->programUniform3ui(programPacked, locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(ProgramUniform3ui, isCallValid, context, programPacked, location, v0, v1, v2);
+        ANGLE_CAPTURE(ProgramUniform3ui, isCallValid, context, programPacked, locationPacked, v0,
+                      v1, v2);
     }
 }
 
@@ -18616,16 +18661,17 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform3uiv(context, programPacked, location, count, value));
+             ValidateProgramUniform3uiv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform3uiv(programPacked, location, count, value);
+            context->programUniform3uiv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform3uiv, isCallValid, context, programPacked, location, count,
-                      value);
+        ANGLE_CAPTURE(ProgramUniform3uiv, isCallValid, context, programPacked, locationPacked,
+                      count, value);
     }
 }
 
@@ -18647,16 +18693,17 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4f(context, programPacked, location, v0, v1, v2, v3));
+             ValidateProgramUniform4f(context, programPacked, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->programUniform4f(programPacked, location, v0, v1, v2, v3);
+            context->programUniform4f(programPacked, locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(ProgramUniform4f, isCallValid, context, programPacked, location, v0, v1, v2,
-                      v3);
+        ANGLE_CAPTURE(ProgramUniform4f, isCallValid, context, programPacked, locationPacked, v0, v1,
+                      v2, v3);
     }
 }
 
@@ -18676,15 +18723,16 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4fv(context, programPacked, location, count, value));
+             ValidateProgramUniform4fv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform4fv(programPacked, location, count, value);
+            context->programUniform4fv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform4fv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform4fv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -18707,16 +18755,17 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4i(context, programPacked, location, v0, v1, v2, v3));
+             ValidateProgramUniform4i(context, programPacked, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->programUniform4i(programPacked, location, v0, v1, v2, v3);
+            context->programUniform4i(programPacked, locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(ProgramUniform4i, isCallValid, context, programPacked, location, v0, v1, v2,
-                      v3);
+        ANGLE_CAPTURE(ProgramUniform4i, isCallValid, context, programPacked, locationPacked, v0, v1,
+                      v2, v3);
     }
 }
 
@@ -18736,15 +18785,16 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4iv(context, programPacked, location, count, value));
+             ValidateProgramUniform4iv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform4iv(programPacked, location, count, value);
+            context->programUniform4iv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform4iv, isCallValid, context, programPacked, location, count,
+        ANGLE_CAPTURE(ProgramUniform4iv, isCallValid, context, programPacked, locationPacked, count,
                       value);
     }
 }
@@ -18767,16 +18817,17 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4ui(context, programPacked, location, v0, v1, v2, v3));
+             ValidateProgramUniform4ui(context, programPacked, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->programUniform4ui(programPacked, location, v0, v1, v2, v3);
+            context->programUniform4ui(programPacked, locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(ProgramUniform4ui, isCallValid, context, programPacked, location, v0, v1, v2,
-                      v3);
+        ANGLE_CAPTURE(ProgramUniform4ui, isCallValid, context, programPacked, locationPacked, v0,
+                      v1, v2, v3);
     }
 }
 
@@ -18796,16 +18847,17 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProgramUniform4uiv(context, programPacked, location, count, value));
+             ValidateProgramUniform4uiv(context, programPacked, locationPacked, count, value));
         if (isCallValid)
         {
-            context->programUniform4uiv(programPacked, location, count, value);
+            context->programUniform4uiv(programPacked, locationPacked, count, value);
         }
-        ANGLE_CAPTURE(ProgramUniform4uiv, isCallValid, context, programPacked, location, count,
-                      value);
+        ANGLE_CAPTURE(ProgramUniform4uiv, isCallValid, context, programPacked, locationPacked,
+                      count, value);
     }
 }
 
@@ -18826,16 +18878,18 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix2fv(context, programPacked, location, count,
-                                                            transpose, value));
+                            ValidateProgramUniformMatrix2fv(context, programPacked, locationPacked,
+                                                            count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix2fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix2fv(programPacked, locationPacked, count, transpose,
+                                             value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix2fv, isCallValid, context, programPacked, location, count,
-                      transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix2fv, isCallValid, context, programPacked, locationPacked,
+                      count, transpose, value);
     }
 }
 
@@ -18856,16 +18910,18 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix2x3fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix2x3fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix2x3fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix2x3fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix2x3fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix2x3fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -18886,16 +18942,18 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix2x4fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix2x4fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix2x4fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix2x4fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix2x4fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix2x4fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -18916,16 +18974,18 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix3fv(context, programPacked, location, count,
-                                                            transpose, value));
+                            ValidateProgramUniformMatrix3fv(context, programPacked, locationPacked,
+                                                            count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix3fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix3fv(programPacked, locationPacked, count, transpose,
+                                             value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix3fv, isCallValid, context, programPacked, location, count,
-                      transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix3fv, isCallValid, context, programPacked, locationPacked,
+                      count, transpose, value);
     }
 }
 
@@ -18946,16 +19006,18 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix3x2fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix3x2fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix3x2fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix3x2fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix3x2fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix3x2fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -18976,16 +19038,18 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix3x4fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix3x4fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix3x4fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix3x4fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix3x4fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix3x4fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -19006,16 +19070,18 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix4fv(context, programPacked, location, count,
-                                                            transpose, value));
+                            ValidateProgramUniformMatrix4fv(context, programPacked, locationPacked,
+                                                            count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix4fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix4fv(programPacked, locationPacked, count, transpose,
+                                             value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix4fv, isCallValid, context, programPacked, location, count,
-                      transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix4fv, isCallValid, context, programPacked, locationPacked,
+                      count, transpose, value);
     }
 }
 
@@ -19036,16 +19102,18 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix4x2fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix4x2fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix4x2fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix4x2fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix4x2fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix4x2fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -19066,16 +19134,18 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateProgramUniformMatrix4x3fv(context, programPacked, location,
-                                                              count, transpose, value));
+                            ValidateProgramUniformMatrix4x3fv(
+                                context, programPacked, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->programUniformMatrix4x3fv(programPacked, location, count, transpose, value);
+            context->programUniformMatrix4x3fv(programPacked, locationPacked, count, transpose,
+                                               value);
         }
-        ANGLE_CAPTURE(ProgramUniformMatrix4x3fv, isCallValid, context, programPacked, location,
-                      count, transpose, value);
+        ANGLE_CAPTURE(ProgramUniformMatrix4x3fv, isCallValid, context, programPacked,
+                      locationPacked, count, transpose, value);
     }
 }
 
@@ -21630,13 +21700,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid = (context->skipValidation() || ValidateUniform1f(context, location, v0));
+        bool isCallValid =
+            (context->skipValidation() || ValidateUniform1f(context, locationPacked, v0));
         if (isCallValid)
         {
-            context->uniform1f(location, v0);
+            context->uniform1f(locationPacked, v0);
         }
-        ANGLE_CAPTURE(Uniform1f, isCallValid, context, location, v0);
+        ANGLE_CAPTURE(Uniform1f, isCallValid, context, locationPacked, v0);
     }
 }
 
@@ -21654,14 +21726,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform1fv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform1fv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform1fv(location, count, value);
+            context->uniform1fv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform1fv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform1fv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -21674,13 +21747,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid = (context->skipValidation() || ValidateUniform1i(context, location, v0));
+        bool isCallValid =
+            (context->skipValidation() || ValidateUniform1i(context, locationPacked, v0));
         if (isCallValid)
         {
-            context->uniform1i(location, v0);
+            context->uniform1i(locationPacked, v0);
         }
-        ANGLE_CAPTURE(Uniform1i, isCallValid, context, location, v0);
+        ANGLE_CAPTURE(Uniform1i, isCallValid, context, locationPacked, v0);
     }
 }
 
@@ -21699,14 +21774,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform1iv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform1iv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform1iv(location, count, value);
+            context->uniform1iv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform1iv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform1iv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -21719,13 +21795,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid = (context->skipValidation() || ValidateUniform1ui(context, location, v0));
+        bool isCallValid =
+            (context->skipValidation() || ValidateUniform1ui(context, locationPacked, v0));
         if (isCallValid)
         {
-            context->uniform1ui(location, v0);
+            context->uniform1ui(locationPacked, v0);
         }
-        ANGLE_CAPTURE(Uniform1ui, isCallValid, context, location, v0);
+        ANGLE_CAPTURE(Uniform1ui, isCallValid, context, locationPacked, v0);
     }
 }
 
@@ -21743,14 +21821,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform1uiv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform1uiv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform1uiv(location, count, value);
+            context->uniform1uiv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform1uiv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform1uiv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -21763,14 +21842,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform2f(context, location, v0, v1));
+            (context->skipValidation() || ValidateUniform2f(context, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->uniform2f(location, v0, v1);
+            context->uniform2f(locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(Uniform2f, isCallValid, context, location, v0, v1);
+        ANGLE_CAPTURE(Uniform2f, isCallValid, context, locationPacked, v0, v1);
     }
 }
 
@@ -21788,14 +21868,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform2fv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform2fv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform2fv(location, count, value);
+            context->uniform2fv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform2fv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform2fv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -21808,14 +21889,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform2i(context, location, v0, v1));
+            (context->skipValidation() || ValidateUniform2i(context, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->uniform2i(location, v0, v1);
+            context->uniform2i(locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(Uniform2i, isCallValid, context, location, v0, v1);
+        ANGLE_CAPTURE(Uniform2i, isCallValid, context, locationPacked, v0, v1);
     }
 }
 
@@ -21834,14 +21916,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform2iv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform2iv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform2iv(location, count, value);
+            context->uniform2iv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform2iv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform2iv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -21854,14 +21937,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform2ui(context, location, v0, v1));
+            (context->skipValidation() || ValidateUniform2ui(context, locationPacked, v0, v1));
         if (isCallValid)
         {
-            context->uniform2ui(location, v0, v1);
+            context->uniform2ui(locationPacked, v0, v1);
         }
-        ANGLE_CAPTURE(Uniform2ui, isCallValid, context, location, v0, v1);
+        ANGLE_CAPTURE(Uniform2ui, isCallValid, context, locationPacked, v0, v1);
     }
 }
 
@@ -21879,14 +21963,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform2uiv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform2uiv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform2uiv(location, count, value);
+            context->uniform2uiv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform2uiv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform2uiv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -21901,14 +21986,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform3f(context, location, v0, v1, v2));
+            (context->skipValidation() || ValidateUniform3f(context, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->uniform3f(location, v0, v1, v2);
+            context->uniform3f(locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(Uniform3f, isCallValid, context, location, v0, v1, v2);
+        ANGLE_CAPTURE(Uniform3f, isCallValid, context, locationPacked, v0, v1, v2);
     }
 }
 
@@ -21926,14 +22012,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform3fv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform3fv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform3fv(location, count, value);
+            context->uniform3fv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform3fv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform3fv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -21948,14 +22035,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform3i(context, location, v0, v1, v2));
+            (context->skipValidation() || ValidateUniform3i(context, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->uniform3i(location, v0, v1, v2);
+            context->uniform3i(locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(Uniform3i, isCallValid, context, location, v0, v1, v2);
+        ANGLE_CAPTURE(Uniform3i, isCallValid, context, locationPacked, v0, v1, v2);
     }
 }
 
@@ -21974,14 +22062,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform3iv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform3iv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform3iv(location, count, value);
+            context->uniform3iv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform3iv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform3iv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -21996,14 +22085,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
-            (context->skipValidation() || ValidateUniform3ui(context, location, v0, v1, v2));
+            (context->skipValidation() || ValidateUniform3ui(context, locationPacked, v0, v1, v2));
         if (isCallValid)
         {
-            context->uniform3ui(location, v0, v1, v2);
+            context->uniform3ui(locationPacked, v0, v1, v2);
         }
-        ANGLE_CAPTURE(Uniform3ui, isCallValid, context, location, v0, v1, v2);
+        ANGLE_CAPTURE(Uniform3ui, isCallValid, context, locationPacked, v0, v1, v2);
     }
 }
 
@@ -22021,14 +22111,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform3uiv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform3uiv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform3uiv(location, count, value);
+            context->uniform3uiv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform3uiv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform3uiv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -22048,14 +22139,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4f(context, location, v0, v1, v2, v3));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4f(context, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->uniform4f(location, v0, v1, v2, v3);
+            context->uniform4f(locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(Uniform4f, isCallValid, context, location, v0, v1, v2, v3);
+        ANGLE_CAPTURE(Uniform4f, isCallValid, context, locationPacked, v0, v1, v2, v3);
     }
 }
 
@@ -22073,14 +22165,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4fv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4fv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform4fv(location, count, value);
+            context->uniform4fv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform4fv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform4fv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -22096,14 +22189,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4i(context, location, v0, v1, v2, v3));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4i(context, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->uniform4i(location, v0, v1, v2, v3);
+            context->uniform4i(locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(Uniform4i, isCallValid, context, location, v0, v1, v2, v3);
+        ANGLE_CAPTURE(Uniform4i, isCallValid, context, locationPacked, v0, v1, v2, v3);
     }
 }
 
@@ -22122,14 +22216,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4iv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4iv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform4iv(location, count, value);
+            context->uniform4iv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform4iv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform4iv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -22145,14 +22240,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4ui(context, location, v0, v1, v2, v3));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4ui(context, locationPacked, v0, v1, v2, v3));
         if (isCallValid)
         {
-            context->uniform4ui(location, v0, v1, v2, v3);
+            context->uniform4ui(locationPacked, v0, v1, v2, v3);
         }
-        ANGLE_CAPTURE(Uniform4ui, isCallValid, context, location, v0, v1, v2, v3);
+        ANGLE_CAPTURE(Uniform4ui, isCallValid, context, locationPacked, v0, v1, v2, v3);
     }
 }
 
@@ -22170,14 +22266,15 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid =
-            (context->skipValidation() || ValidateUniform4uiv(context, location, count, value));
+        bool isCallValid                                      = (context->skipValidation() ||
+                            ValidateUniform4uiv(context, locationPacked, count, value));
         if (isCallValid)
         {
-            context->uniform4uiv(location, count, value);
+            context->uniform4uiv(locationPacked, count, value);
         }
-        ANGLE_CAPTURE(Uniform4uiv, isCallValid, context, location, count, value);
+        ANGLE_CAPTURE(Uniform4uiv, isCallValid, context, locationPacked, count, value);
     }
 }
 
@@ -22224,14 +22321,17 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix2fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix2fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix2fv(location, count, transpose, value);
+            context->uniformMatrix2fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix2fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix2fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -22250,14 +22350,17 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix2x3fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix2x3fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix2x3fv(location, count, transpose, value);
+            context->uniformMatrix2x3fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix2x3fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix2x3fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -22276,14 +22379,17 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix2x4fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix2x4fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix2x4fv(location, count, transpose, value);
+            context->uniformMatrix2x4fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix2x4fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix2x4fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -22302,14 +22408,17 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix3fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix3fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix3fv(location, count, transpose, value);
+            context->uniformMatrix3fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix3fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix3fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -22328,14 +22437,17 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix3x2fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix3x2fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix3x2fv(location, count, transpose, value);
+            context->uniformMatrix3x2fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix3x2fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix3x2fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -22354,14 +22466,17 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix3x4fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix3x4fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix3x4fv(location, count, transpose, value);
+            context->uniformMatrix3x4fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix3x4fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix3x4fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -22380,14 +22495,17 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix4fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix4fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix4fv(location, count, transpose, value);
+            context->uniformMatrix4fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix4fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix4fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -22406,14 +22524,17 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix4x2fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix4x2fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix4x2fv(location, count, transpose, value);
+            context->uniformMatrix4x2fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix4x2fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix4x2fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -22432,14 +22553,17 @@
     if (context)
     {
         ASSERT(context == GetValidGlobalContext());
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
-        bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateUniformMatrix4x3fv(context, location, count, transpose, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateUniformMatrix4x3fv(context, locationPacked, count, transpose, value));
         if (isCallValid)
         {
-            context->uniformMatrix4x3fv(location, count, transpose, value);
+            context->uniformMatrix4x3fv(locationPacked, count, transpose, value);
         }
-        ANGLE_CAPTURE(UniformMatrix4x3fv, isCallValid, context, location, count, transpose, value);
+        ANGLE_CAPTURE(UniformMatrix4x3fv, isCallValid, context, locationPacked, count, transpose,
+                      value);
     }
 }
 
@@ -23242,16 +23366,17 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateBindUniformLocationCHROMIUM(context, programPacked, location, name));
+             ValidateBindUniformLocationCHROMIUM(context, programPacked, locationPacked, name));
         if (isCallValid)
         {
-            context->bindUniformLocation(programPacked, location, name);
+            context->bindUniformLocation(programPacked, locationPacked, name);
         }
-        ANGLE_CAPTURE(BindUniformLocationCHROMIUM, isCallValid, context, programPacked, location,
-                      name);
+        ANGLE_CAPTURE(BindUniformLocationCHROMIUM, isCallValid, context, programPacked,
+                      locationPacked, name);
     }
 }
 
@@ -24498,15 +24623,16 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetUniformfvRobustANGLE(context, programPacked, location,
+                            ValidateGetUniformfvRobustANGLE(context, programPacked, locationPacked,
                                                             bufSize, length, params));
         if (isCallValid)
         {
-            context->getUniformfvRobust(programPacked, location, bufSize, length, params);
+            context->getUniformfvRobust(programPacked, locationPacked, bufSize, length, params);
         }
-        ANGLE_CAPTURE(GetUniformfvRobustANGLE, isCallValid, context, programPacked, location,
+        ANGLE_CAPTURE(GetUniformfvRobustANGLE, isCallValid, context, programPacked, locationPacked,
                       bufSize, length, params);
     }
 }
@@ -24528,15 +24654,16 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetUniformivRobustANGLE(context, programPacked, location,
+                            ValidateGetUniformivRobustANGLE(context, programPacked, locationPacked,
                                                             bufSize, length, params));
         if (isCallValid)
         {
-            context->getUniformivRobust(programPacked, location, bufSize, length, params);
+            context->getUniformivRobust(programPacked, locationPacked, bufSize, length, params);
         }
-        ANGLE_CAPTURE(GetUniformivRobustANGLE, isCallValid, context, programPacked, location,
+        ANGLE_CAPTURE(GetUniformivRobustANGLE, isCallValid, context, programPacked, locationPacked,
                       bufSize, length, params);
     }
 }
@@ -25298,15 +25425,16 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetUniformuivRobustANGLE(context, programPacked, location,
+                            ValidateGetUniformuivRobustANGLE(context, programPacked, locationPacked,
                                                              bufSize, length, params));
         if (isCallValid)
         {
-            context->getUniformuivRobust(programPacked, location, bufSize, length, params);
+            context->getUniformuivRobust(programPacked, locationPacked, bufSize, length, params);
         }
-        ANGLE_CAPTURE(GetUniformuivRobustANGLE, isCallValid, context, programPacked, location,
+        ANGLE_CAPTURE(GetUniformuivRobustANGLE, isCallValid, context, programPacked, locationPacked,
                       bufSize, length, params);
     }
 }
@@ -25841,15 +25969,16 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetnUniformfvRobustANGLE(context, programPacked, location,
+                            ValidateGetnUniformfvRobustANGLE(context, programPacked, locationPacked,
                                                              bufSize, length, params));
         if (isCallValid)
         {
-            context->getnUniformfvRobust(programPacked, location, bufSize, length, params);
+            context->getnUniformfvRobust(programPacked, locationPacked, bufSize, length, params);
         }
-        ANGLE_CAPTURE(GetnUniformfvRobustANGLE, isCallValid, context, programPacked, location,
+        ANGLE_CAPTURE(GetnUniformfvRobustANGLE, isCallValid, context, programPacked, locationPacked,
                       bufSize, length, params);
     }
 }
@@ -25871,15 +26000,16 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetnUniformivRobustANGLE(context, programPacked, location,
+                            ValidateGetnUniformivRobustANGLE(context, programPacked, locationPacked,
                                                              bufSize, length, params));
         if (isCallValid)
         {
-            context->getnUniformivRobust(programPacked, location, bufSize, length, params);
+            context->getnUniformivRobust(programPacked, locationPacked, bufSize, length, params);
         }
-        ANGLE_CAPTURE(GetnUniformivRobustANGLE, isCallValid, context, programPacked, location,
+        ANGLE_CAPTURE(GetnUniformivRobustANGLE, isCallValid, context, programPacked, locationPacked,
                       bufSize, length, params);
     }
 }
@@ -25901,16 +26031,17 @@
     {
         ASSERT(context == GetValidGlobalContext());
         ShaderProgramID programPacked                         = FromGL<ShaderProgramID>(program);
+        UniformLocation locationPacked                        = FromGL<UniformLocation>(location);
         std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
         bool isCallValid                                      = (context->skipValidation() ||
-                            ValidateGetnUniformuivRobustANGLE(context, programPacked, location,
-                                                              bufSize, length, params));
+                            ValidateGetnUniformuivRobustANGLE(
+                                context, programPacked, locationPacked, bufSize, length, params));
         if (isCallValid)
         {
-            context->getnUniformuivRobust(programPacked, location, bufSize, length, params);
+            context->getnUniformuivRobust(programPacked, locationPacked, bufSize, length, params);
         }
-        ANGLE_CAPTURE(GetnUniformuivRobustANGLE, isCallValid, context, programPacked, location,
-                      bufSize, length, params);
+        ANGLE_CAPTURE(GetnUniformuivRobustANGLE, isCallValid, context, programPacked,
+                      locationPacked, bufSize, length, params);
     }
 }