diff --git a/scripts/code_generation_hashes/GL_EGL_entry_points.json b/scripts/code_generation_hashes/GL_EGL_entry_points.json
index 056695325..f5c68c861 100644
--- a/scripts/code_generation_hashes/GL_EGL_entry_points.json
+++ b/scripts/code_generation_hashes/GL_EGL_entry_points.json
@@ -6,7 +6,7 @@
   "scripts/entry_point_packed_gl_enums.json":
     "1c6b036918aabb9822a638fbf33f87f4",
   "scripts/generate_entry_points.py":
-    "be46151745acdfe0c0456856e276f55a",
+    "e11309ae6a544bba2d5106e99df31315",
   "scripts/gl_angle_ext.xml":
     "49a0bf469d6f44c532098ef3a9fd087f",
   "scripts/registry_xml.py":
@@ -92,25 +92,25 @@
   "src/libANGLE/validationEGL_autogen.h":
     "4f7072f08216e8002aab76616c691d38",
   "src/libANGLE/validationES1_autogen.h":
-    "99af5e328690ae78d7724a80e94cfac5",
+    "06762456388a02b9258d6262c1bf4a1b",
   "src/libANGLE/validationES2_autogen.h":
-    "b8d463545b6f53f3fd11f020e2dbaf02",
+    "42a3c5a51ed936d5e47ab08ef2a17c9e",
   "src/libANGLE/validationES31_autogen.h":
-    "38e169b05cafd2692466653579ae44e7",
+    "1ed81afa47644b88a05e1e2bd72b3393",
   "src/libANGLE/validationES32_autogen.h":
-    "d0c353bad157ce2297adaedb9ff3e003",
+    "03fbf790c2db53d5b677747d40f5bbd6",
   "src/libANGLE/validationES3_autogen.h":
-    "ffffaca63434b2b419614ddb25a57149",
+    "29b3f384a582a4ffd45a898a481839fd",
   "src/libANGLE/validationESEXT_autogen.h":
-    "10d60bb3fcc083b27541b1f71d16e535",
+    "44ce386575af7dbe3ddcf902d704b15b",
   "src/libANGLE/validationGL1_autogen.h":
-    "31ab724bc94d19745c4783a4ab12bc4f",
+    "6024574ab4afbee4462d4a1f0c897c9a",
   "src/libANGLE/validationGL2_autogen.h":
-    "597c9ee483495310a8c5d9a433128a92",
+    "97cd7b1827278eb9abfbea6fb8cbfd97",
   "src/libANGLE/validationGL3_autogen.h":
-    "d44457c3b3bc40fc7db904a4bb433966",
+    "64d2792b07817ba99d049d6856a10271",
   "src/libANGLE/validationGL4_autogen.h":
-    "bf8566233cb2da63fbc2afbb4ffc4834",
+    "7057fa33057b1d857f902e9db3f14535",
   "src/libEGL/libEGL_autogen.cpp":
     "3bf53ca292b19b0e21b9201740d52b69",
   "src/libEGL/libEGL_autogen.def":
@@ -138,43 +138,43 @@
   "src/libGLESv2/entry_points_egl_ext_autogen.h":
     "5a212372e378e0890d2d3ac96c1a3765",
   "src/libGLESv2/entry_points_gl_1_autogen.cpp":
-    "4743bd40f9f0222153efa675a21aced6",
+    "b40ded56c7002839bce50301ffbc7bc4",
   "src/libGLESv2/entry_points_gl_1_autogen.h":
     "fc92166806eac5dc285f6a3f06e89d2b",
   "src/libGLESv2/entry_points_gl_2_autogen.cpp":
-    "cda13affb35accbf6027ee1623fa330b",
+    "abd7fae96c2022a96f2f3ce0dbaf0ac2",
   "src/libGLESv2/entry_points_gl_2_autogen.h":
     "ff42b86b47d77aeb902b6f0f5bd31758",
   "src/libGLESv2/entry_points_gl_3_autogen.cpp":
-    "4aff47410990d16fb36982ddf6574550",
+    "613a6be7d1e091e304dca5dbdbe5b962",
   "src/libGLESv2/entry_points_gl_3_autogen.h":
     "88fcf08e2c1aa73819067f28c0fd1eba",
   "src/libGLESv2/entry_points_gl_4_autogen.cpp":
-    "ab61cec77bf6ed11801fbbd86ec7c190",
+    "9510df58c1ad699a2b123145904f0877",
   "src/libGLESv2/entry_points_gl_4_autogen.h":
     "ec1171de9a494598d53bce149ba7b26d",
   "src/libGLESv2/entry_points_gles_1_0_autogen.cpp":
-    "9cf1c7684291660339f336b09d5bd7c1",
+    "9d9f2bd08db54769bb04ce15118974c7",
   "src/libGLESv2/entry_points_gles_1_0_autogen.h":
     "1d3aef77845a416497070985a8e9cb31",
   "src/libGLESv2/entry_points_gles_2_0_autogen.cpp":
-    "2e515319a77ba1cbc99795999c645bb4",
+    "417aa3c0778b3625a05f329018a9fc75",
   "src/libGLESv2/entry_points_gles_2_0_autogen.h":
     "691c60c2dfed9beca68aa1f32aa2c71b",
   "src/libGLESv2/entry_points_gles_3_0_autogen.cpp":
-    "e42af5c86b82248ddbf595c607e32592",
+    "3acd48e02ac5bb362c031b6f0b2c4b8b",
   "src/libGLESv2/entry_points_gles_3_0_autogen.h":
     "4ac2582759cdc6a30f78f83ab684d555",
   "src/libGLESv2/entry_points_gles_3_1_autogen.cpp":
-    "7d18d8de0b75ce92e5545d9cbc79941c",
+    "23c0a83b83ba21fb4530d1ccfa473a83",
   "src/libGLESv2/entry_points_gles_3_1_autogen.h":
     "a7327c330a91665fc31accbb78793b42",
   "src/libGLESv2/entry_points_gles_3_2_autogen.cpp":
-    "39f72278c805979ca0f5ed9e301f6384",
+    "5f1e7f4b2db9a22dd873dcc5200e52ac",
   "src/libGLESv2/entry_points_gles_3_2_autogen.h":
     "647f932a299cdb4726b60bbba059f0d2",
   "src/libGLESv2/entry_points_gles_ext_autogen.cpp":
-    "f4e3319d350f64336ce8dc8591508ce9",
+    "769b472281799e5360b5dc6750a124d4",
   "src/libGLESv2/entry_points_gles_ext_autogen.h":
     "f1895ec530403d4a5cee26a2a1637854",
   "src/libGLESv2/libGLESv2_autogen.cpp":
diff --git a/scripts/generate_entry_points.py b/scripts/generate_entry_points.py
index 8b43e5477..821497d95 100755
--- a/scripts/generate_entry_points.py
+++ b/scripts/generate_entry_points.py
@@ -367,7 +367,7 @@ void GL_APIENTRY GL_{name}({params})
 }}
 """
 
-TEMPLATE_GLES_PRIVATE_STATE_ENTRY_POINT_NO_RETURN = """\
+TEMPLATE_GLES_CONTEXT_PRIVATE_ENTRY_POINT_NO_RETURN = """\
 void GL_APIENTRY GL_{name}({params})
 {{
     Context *context = {context_getter};
@@ -421,7 +421,7 @@ TEMPLATE_GLES_ENTRY_POINT_WITH_RETURN = """\
 }}
 """
 
-TEMPLATE_GLES_PRIVATE_STATE_ENTRY_POINT_WITH_RETURN = """\
+TEMPLATE_GLES_CONTEXT_PRIVATE_ENTRY_POINT_WITH_RETURN = """\
 {return_type} GL_APIENTRY GL_{name}({params})
 {{
     Context *context = {context_getter};
@@ -697,6 +697,8 @@ TEMPLATE_GL_VALIDATION_HEADER = """\
 namespace gl
 {{
 class Context;
+class PrivateState;
+class ErrorSet;
 
 {prototypes}
 }}  // namespace gl
@@ -1579,13 +1581,16 @@ def is_context_private_state_command(api, name):
         [fnmatch.fnmatchcase(name, entry) for entry in CONTEXT_PRIVATE_WILDCARDS])
 
 
-def get_validation_expression(cmd_name, entry_point_name, internal_params):
+def get_validation_expression(api, cmd_name, entry_point_name, internal_params):
     name = strip_api_prefix(cmd_name)
+    private_params = ["context->getPrivateState()", "context->getMutableErrorSetForValidation()"]
+    extra_params = private_params if is_context_private_state_command(api,
+                                                                      cmd_name) else ["context"]
     expr = "Validate{name}({params})".format(
-        name=name, params=", ".join(["context", entry_point_name] + internal_params))
+        name=name, params=", ".join(extra_params + [entry_point_name] + internal_params))
     if not is_allowed_with_active_pixel_local_storage(name):
-        expr = "(ValidatePixelLocalStorageInactive(context, {entry_point_name}) && {expr})".format(
-            entry_point_name=entry_point_name, expr=expr)
+        expr = "(ValidatePixelLocalStorageInactive({extra_params}, {entry_point_name}) && {expr})".format(
+            extra_params=", ".join(private_params), entry_point_name=entry_point_name, expr=expr)
     return expr
 
 
@@ -1829,7 +1834,7 @@ def get_def_template(api, cmd_name, return_type, has_errcode_ret):
         elif api == apis.CL:
             return TEMPLATE_CL_ENTRY_POINT_NO_RETURN
         elif is_context_private_state_command(api, cmd_name):
-            return TEMPLATE_GLES_PRIVATE_STATE_ENTRY_POINT_NO_RETURN
+            return TEMPLATE_GLES_CONTEXT_PRIVATE_ENTRY_POINT_NO_RETURN
         else:
             return TEMPLATE_GLES_ENTRY_POINT_NO_RETURN
     elif return_type == "cl_int":
@@ -1843,7 +1848,7 @@ def get_def_template(api, cmd_name, return_type, has_errcode_ret):
             else:
                 return TEMPLATE_CL_ENTRY_POINT_WITH_RETURN_POINTER
         elif is_context_private_state_command(api, cmd_name):
-            return TEMPLATE_GLES_PRIVATE_STATE_ENTRY_POINT_WITH_RETURN
+            return TEMPLATE_GLES_CONTEXT_PRIVATE_ENTRY_POINT_WITH_RETURN
         else:
             return TEMPLATE_GLES_ENTRY_POINT_WITH_RETURN
 
@@ -1920,7 +1925,7 @@ def format_entry_point_def(api, command_node, cmd_name, proto, params, cmd_packe
         "egl_capture_params":
             ", ".join(["thread"] + internal_params),
         "validation_expression":
-            get_validation_expression(cmd_name, entry_point_name, internal_params),
+            get_validation_expression(api, cmd_name, entry_point_name, internal_params),
         "format_params":
             ", ".join(format_params),
         "context_getter":
@@ -2054,7 +2059,7 @@ def format_capture_method(api, command, cmd_name, proto, params, all_param_types
 
 def const_pointer_type(param, packed_gl_enums):
     type = just_the_type_packed(param, packed_gl_enums)
-    if just_the_name(param) == "errcode_ret" or "(" in type:
+    if just_the_name(param) == "errcode_ret" or type == "ErrorSet *" or "(" in type:
         return type
     elif "**" in type and "const" not in type:
         return type.replace("**", "* const *")
@@ -2145,7 +2150,10 @@ def format_validation_proto(api, cmd_name, params, cmd_packed_gl_enums, packed_p
     else:
         return_type = "bool"
     if api in [apis.GL, apis.GLES]:
-        with_extra_params = ["Context *context"] + ["angle::EntryPoint entryPoint"] + params
+        with_extra_params = ["const PrivateState &state",
+                             "ErrorSet *errors"] if is_context_private_state_command(
+                                 api, cmd_name) else ["Context *context"]
+        with_extra_params += ["angle::EntryPoint entryPoint"] + params
     elif api == apis.EGL:
         with_extra_params = ["ValidationContext *val"] + params
     else:
diff --git a/src/libANGLE/Context.h b/src/libANGLE/Context.h
index bd990ea46..28820a418 100644
--- a/src/libANGLE/Context.h
+++ b/src/libANGLE/Context.h
@@ -610,6 +610,7 @@ class Context final : public egl::LabeledObject, angle::NonCopyable, public angl
     void setShared() { mShared = true; }
 
     const State &getState() const { return mState; }
+    const PrivateState &getPrivateState() const { return mState.privateState(); }
     GLint getClientMajorVersion() const { return mState.getClientMajorVersion(); }
     GLint getClientMinorVersion() const { return mState.getClientMinorVersion(); }
     const Version &getClientVersion() const { return mState.getClientVersion(); }
diff --git a/src/libANGLE/State.h b/src/libANGLE/State.h
index 5553dcd7f..5c105a24e 100644
--- a/src/libANGLE/State.h
+++ b/src/libANGLE/State.h
@@ -242,6 +242,10 @@ class PrivateState : angle::NonCopyable
     GLint getClientMajorVersion() const { return mClientVersion.major; }
     GLint getClientMinorVersion() const { return mClientVersion.minor; }
 
+    bool isWebGL() const { return getExtensions().webglCompatibilityANGLE; }
+    bool isWebGL1() const { return isWebGL() && getClientVersion().major == 2; }
+    bool isGLES1() const { return getClientVersion() < ES_2_0; }
+
     const Caps &getCaps() const { return mCaps; }
     const TextureCapsMap &getTextureCaps() const { return mTextureCaps; }
     const Extensions &getExtensions() const { return mExtensions; }
@@ -768,11 +772,9 @@ class State : angle::NonCopyable
     const Version &getClientVersion() const { return mPrivateState.getClientVersion(); }
     egl::ShareGroup *getShareGroup() const { return mShareGroup; }
 
-    bool isWebGL() const { return getExtensions().webglCompatibilityANGLE; }
-
-    bool isWebGL1() const { return (isWebGL() && getClientVersion().major == 2); }
-
-    bool isGLES1() const { return getClientVersion() < ES_2_0; }
+    bool isWebGL() const { return mPrivateState.isWebGL(); }
+    bool isWebGL1() const { return mPrivateState.isWebGL1(); }
+    bool isGLES1() const { return mPrivateState.isGLES1(); }
 
     const Caps &getCaps() const { return mPrivateState.getCaps(); }
     const TextureCapsMap &getTextureCaps() const { return mPrivateState.getTextureCaps(); }
diff --git a/src/libANGLE/entry_points_utils.cpp b/src/libANGLE/entry_points_utils.cpp
index 639950884..6cde6922b 100644
--- a/src/libANGLE/entry_points_utils.cpp
+++ b/src/libANGLE/entry_points_utils.cpp
@@ -12,11 +12,12 @@
 
 namespace gl
 {
-bool GeneratePixelLocalStorageActiveError(const Context *context, angle::EntryPoint entryPoint)
+bool GeneratePixelLocalStorageActiveError(const PrivateState &state,
+                                          ErrorSet *errors,
+                                          angle::EntryPoint entryPoint)
 {
-    ASSERT(context->getState().getPixelLocalStorageActivePlanes() != 0);
-    context->getMutableErrorSetForValidation()->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                                err::kPLSActive);
+    ASSERT(state.getPixelLocalStorageActivePlanes() != 0);
+    errors->validationError(entryPoint, GL_INVALID_OPERATION, err::kPLSActive);
     return false;
 }
 }  // namespace gl
diff --git a/src/libANGLE/entry_points_utils.h b/src/libANGLE/entry_points_utils.h
index 43d19a599..37773c3d7 100644
--- a/src/libANGLE/entry_points_utils.h
+++ b/src/libANGLE/entry_points_utils.h
@@ -103,13 +103,16 @@ inline int CID(const Context *context)
     return context == nullptr ? 0 : static_cast<int>(context->id().value);
 }
 
-bool GeneratePixelLocalStorageActiveError(const Context *context, angle::EntryPoint entryPoint);
+bool GeneratePixelLocalStorageActiveError(const PrivateState &state,
+                                          ErrorSet *errors,
+                                          angle::EntryPoint entryPoint);
 
-ANGLE_INLINE bool ValidatePixelLocalStorageInactive(const Context *context,
+ANGLE_INLINE bool ValidatePixelLocalStorageInactive(const PrivateState &state,
+                                                    ErrorSet *errors,
                                                     angle::EntryPoint entryPoint)
 {
-    return context->getState().getPixelLocalStorageActivePlanes() == 0 ||
-           GeneratePixelLocalStorageActiveError(context, entryPoint);
+    return state.getPixelLocalStorageActivePlanes() == 0 ||
+           GeneratePixelLocalStorageActiveError(state, errors, entryPoint);
 }
 }  // namespace gl
 
diff --git a/src/libANGLE/validationES.cpp b/src/libANGLE/validationES.cpp
index 486d640a4..503145ff3 100644
--- a/src/libANGLE/validationES.cpp
+++ b/src/libANGLE/validationES.cpp
@@ -8286,11 +8286,14 @@ bool ValidateFramebufferNotMultisampled(const Context *context,
     return true;
 }
 
-bool ValidateMultitextureUnit(const Context *context, angle::EntryPoint entryPoint, GLenum texture)
+bool ValidateMultitextureUnit(const PrivateState &state,
+                              ErrorSet *errors,
+                              angle::EntryPoint entryPoint,
+                              GLenum texture)
 {
-    if (texture < GL_TEXTURE0 || texture >= GL_TEXTURE0 + context->getCaps().maxMultitextureUnits)
+    if (texture < GL_TEXTURE0 || texture >= GL_TEXTURE0 + state.getCaps().maxMultitextureUnits)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidMultitextureUnit);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidMultitextureUnit);
         return false;
     }
     return true;
@@ -8490,14 +8493,15 @@ bool ValidateGetMultisamplefvBase(const Context *context,
     return true;
 }
 
-bool ValidateSampleMaskiBase(const Context *context,
+bool ValidateSampleMaskiBase(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint maskNumber,
                              GLbitfield mask)
 {
-    if (maskNumber >= static_cast<GLuint>(context->getCaps().maxSampleMaskWords))
+    if (maskNumber >= static_cast<GLuint>(state.getCaps().maxSampleMaskWords))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidSampleMaskNumber);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSampleMaskNumber);
         return false;
     }
 
@@ -8642,7 +8646,8 @@ bool ValidateProgramExecutableXFBBuffersPresent(const Context *context,
     return true;
 }
 
-bool ValidateLogicOpCommon(const Context *context,
+bool ValidateLogicOpCommon(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            LogicalOperation opcodePacked)
 {
@@ -8666,7 +8671,7 @@ bool ValidateLogicOpCommon(const Context *context,
         case LogicalOperation::Xor:
             return true;
         default:
-            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidLogicOp);
+            errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidLogicOp);
             return false;
     }
 }
diff --git a/src/libANGLE/validationES.h b/src/libANGLE/validationES.h
index 7609d23e7..e2f4c9478 100644
--- a/src/libANGLE/validationES.h
+++ b/src/libANGLE/validationES.h
@@ -780,7 +780,10 @@ bool ValidateRobustCompressedTexImageBase(const Context *context,
                                           GLsizei imageSize,
                                           GLsizei dataSize);
 
-bool ValidateVertexAttribIndex(const Context *context, angle::EntryPoint entryPoint, GLuint index);
+bool ValidateVertexAttribIndex(const PrivateState &state,
+                               ErrorSet *errors,
+                               angle::EntryPoint entryPoint,
+                               GLuint index);
 
 bool ValidateGetActiveUniformBlockivBase(const Context *context,
                                          angle::EntryPoint entryPoint,
@@ -817,7 +820,10 @@ bool ValidateFramebufferNotMultisampled(const Context *context,
                                         const Framebuffer *framebuffer,
                                         bool checkReadBufferResourceSamples);
 
-bool ValidateMultitextureUnit(const Context *context, angle::EntryPoint entryPoint, GLenum texture);
+bool ValidateMultitextureUnit(const PrivateState &state,
+                              ErrorSet *errors,
+                              angle::EntryPoint entryPoint,
+                              GLenum texture);
 
 bool ValidateTransformFeedbackPrimitiveMode(const Context *context,
                                             angle::EntryPoint entryPoint,
@@ -918,7 +924,8 @@ bool ValidateGetMultisamplefvBase(const Context *context,
                                   GLenum pname,
                                   GLuint index,
                                   const GLfloat *val);
-bool ValidateSampleMaskiBase(const Context *context,
+bool ValidateSampleMaskiBase(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint maskNumber,
                              GLbitfield mask);
@@ -1244,20 +1251,22 @@ ANGLE_INLINE bool ValidateBindVertexArrayBase(const Context *context,
     return true;
 }
 
-ANGLE_INLINE bool ValidateVertexAttribIndex(const Context *context,
+ANGLE_INLINE bool ValidateVertexAttribIndex(const PrivateState &state,
+                                            ErrorSet *errors,
                                             angle::EntryPoint entryPoint,
                                             GLuint index)
 {
-    if (index >= static_cast<GLuint>(context->getCaps().maxVertexAttributes))
+    if (index >= static_cast<GLuint>(state.getCaps().maxVertexAttributes))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, err::kIndexExceedsMaxVertexAttribute);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, err::kIndexExceedsMaxVertexAttribute);
         return false;
     }
 
     return true;
 }
 
-bool ValidateLogicOpCommon(const Context *context,
+bool ValidateLogicOpCommon(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            LogicalOperation opcodePacked);
 }  // namespace gl
diff --git a/src/libANGLE/validationES1.cpp b/src/libANGLE/validationES1.cpp
index d308f4173..59f3d2500 100644
--- a/src/libANGLE/validationES1.cpp
+++ b/src/libANGLE/validationES1.cpp
@@ -16,21 +16,26 @@
 #include "libANGLE/queryutils.h"
 #include "libANGLE/validationES.h"
 
-#define ANGLE_VALIDATE_IS_GLES1(context, entryPoint)                                            \
-    do                                                                                          \
-    {                                                                                           \
-        if (context->getClientType() != EGL_OPENGL_API && context->getClientMajorVersion() > 1) \
-        {                                                                                       \
-            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kGLES1Only);                           \
-            return false;                                                                       \
-        }                                                                                       \
+#define ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint)                                \
+    do                                                                                    \
+    {                                                                                     \
+        if (state.getClientType() != EGL_OPENGL_API && state.getClientMajorVersion() > 1) \
+        {                                                                                 \
+            errors->validationError(entryPoint, GL_INVALID_OPERATION, kGLES1Only);        \
+            return false;                                                                 \
+        }                                                                                 \
     } while (0)
 
+#define ANGLE_VALIDATE_IS_GLES1_CONTEXT(context, entryPoint) \
+    ANGLE_VALIDATE_IS_GLES1(context->getPrivateState(),      \
+                            context->getMutableErrorSetForValidation(), entryPoint)
+
 namespace gl
 {
 using namespace err;
 
-bool ValidateAlphaFuncCommon(const Context *context,
+bool ValidateAlphaFuncCommon(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              AlphaTestFunc func)
 {
@@ -46,7 +51,7 @@ bool ValidateAlphaFuncCommon(const Context *context,
         case AlphaTestFunc::NotEqual:
             return true;
         default:
-            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumInvalid);
+            errors->validationError(entryPoint, GL_INVALID_ENUM, kEnumInvalid);
             return false;
     }
 }
@@ -55,7 +60,7 @@ bool ValidateClientStateCommon(const Context *context,
                                angle::EntryPoint entryPoint,
                                ClientVertexArrayType arrayType)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1_CONTEXT(context, entryPoint);
     switch (arrayType)
     {
         case ClientVertexArrayType::Vertex:
@@ -84,7 +89,7 @@ bool ValidateBuiltinVertexAttributeCommon(const Context *context,
                                           GLsizei stride,
                                           const void *pointer)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1_CONTEXT(context, entryPoint);
 
     if (stride < 0)
     {
@@ -166,27 +171,31 @@ bool ValidateBuiltinVertexAttributeCommon(const Context *context,
     return true;
 }
 
-bool ValidateLightCaps(const Context *context, angle::EntryPoint entryPoint, GLenum light)
+bool ValidateLightCaps(const PrivateState &state,
+                       ErrorSet *errors,
+                       angle::EntryPoint entryPoint,
+                       GLenum light)
 {
-    if (light < GL_LIGHT0 || light >= GL_LIGHT0 + context->getCaps().maxLights)
+    if (light < GL_LIGHT0 || light >= GL_LIGHT0 + state.getCaps().maxLights)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidLight);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidLight);
         return false;
     }
 
     return true;
 }
 
-bool ValidateLightCommon(const Context *context,
+bool ValidateLightCommon(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLenum light,
                          LightParameter pname,
                          const GLfloat *params)
 {
 
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
 
-    if (!ValidateLightCaps(context, entryPoint, light))
+    if (!ValidateLightCaps(state, errors, entryPoint, light))
     {
         return false;
     }
@@ -202,7 +211,7 @@ bool ValidateLightCommon(const Context *context,
         case LightParameter::SpotExponent:
             if (params[0] < 0.0f || params[0] > 128.0f)
             {
-                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kLightParameterOutOfRange);
+                errors->validationError(entryPoint, GL_INVALID_VALUE, kLightParameterOutOfRange);
                 return false;
             }
             return true;
@@ -213,7 +222,7 @@ bool ValidateLightCommon(const Context *context,
             }
             if (params[0] < 0.0f || params[0] > 90.0f)
             {
-                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kLightParameterOutOfRange);
+                errors->validationError(entryPoint, GL_INVALID_VALUE, kLightParameterOutOfRange);
                 return false;
             }
             return true;
@@ -222,37 +231,39 @@ bool ValidateLightCommon(const Context *context,
         case LightParameter::QuadraticAttenuation:
             if (params[0] < 0.0f)
             {
-                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kLightParameterOutOfRange);
+                errors->validationError(entryPoint, GL_INVALID_VALUE, kLightParameterOutOfRange);
                 return false;
             }
             return true;
         default:
-            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidLightParameter);
+            errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidLightParameter);
             return false;
     }
 }
 
-bool ValidateLightSingleComponent(const Context *context,
+bool ValidateLightSingleComponent(const PrivateState &state,
+                                  ErrorSet *errors,
                                   angle::EntryPoint entryPoint,
                                   GLenum light,
                                   LightParameter pname,
                                   GLfloat param)
 {
-    if (!ValidateLightCommon(context, entryPoint, light, pname, &param))
+    if (!ValidateLightCommon(state, errors, entryPoint, light, pname, &param))
     {
         return false;
     }
 
     if (GetLightParameterCount(pname) > 1)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidLightParameter);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidLightParameter);
         return false;
     }
 
     return true;
 }
 
-bool ValidateMaterialCommon(const Context *context,
+bool ValidateMaterialCommon(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLenum face,
                             MaterialParameter pname,
@@ -269,90 +280,97 @@ bool ValidateMaterialCommon(const Context *context,
         case MaterialParameter::Shininess:
             if (params[0] < 0.0f || params[0] > 128.0f)
             {
-                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kMaterialParameterOutOfRange);
+                errors->validationError(entryPoint, GL_INVALID_VALUE, kMaterialParameterOutOfRange);
                 return false;
             }
             return true;
         default:
-            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidMaterialParameter);
+            errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidMaterialParameter);
             return false;
     }
 }
 
-bool ValidateMaterialSetting(const Context *context,
+bool ValidateMaterialSetting(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLenum face,
                              MaterialParameter pname,
                              const GLfloat *params)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
 
     if (face != GL_FRONT_AND_BACK)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidMaterialFace);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidMaterialFace);
         return false;
     }
 
-    return ValidateMaterialCommon(context, entryPoint, face, pname, params);
+    return ValidateMaterialCommon(state, errors, entryPoint, face, pname, params);
 }
 
-bool ValidateMaterialQuery(const Context *context,
+bool ValidateMaterialQuery(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLenum face,
                            MaterialParameter pname)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
 
     if (face != GL_FRONT && face != GL_BACK)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidMaterialFace);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidMaterialFace);
         return false;
     }
 
     GLfloat validateParams[4] = {0.0f, 0.0f, 0.0f, 0.0f};
 
-    return ValidateMaterialCommon(context, entryPoint, face, pname, validateParams);
+    return ValidateMaterialCommon(state, errors, entryPoint, face, pname, validateParams);
 }
 
-bool ValidateMaterialSingleComponent(const Context *context,
+bool ValidateMaterialSingleComponent(const PrivateState &state,
+                                     ErrorSet *errors,
                                      angle::EntryPoint entryPoint,
                                      GLenum face,
                                      MaterialParameter pname,
                                      GLfloat param)
 {
-    if (!ValidateMaterialSetting(context, entryPoint, face, pname, &param))
+    if (!ValidateMaterialSetting(state, errors, entryPoint, face, pname, &param))
     {
         return false;
     }
 
     if (GetMaterialParameterCount(pname) > 1)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidMaterialParameter);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidMaterialParameter);
         return false;
     }
 
     return true;
 }
 
-bool ValidateLightModelCommon(const Context *context, angle::EntryPoint entryPoint, GLenum pname)
+bool ValidateLightModelCommon(const PrivateState &state,
+                              ErrorSet *errors,
+                              angle::EntryPoint entryPoint,
+                              GLenum pname)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     switch (pname)
     {
         case GL_LIGHT_MODEL_AMBIENT:
         case GL_LIGHT_MODEL_TWO_SIDE:
             return true;
         default:
-            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidLightModelParameter);
+            errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidLightModelParameter);
             return false;
     }
 }
 
-bool ValidateLightModelSingleComponent(const Context *context,
+bool ValidateLightModelSingleComponent(const PrivateState &state,
+                                       ErrorSet *errors,
                                        angle::EntryPoint entryPoint,
                                        GLenum pname)
 {
-    if (!ValidateLightModelCommon(context, entryPoint, pname))
+    if (!ValidateLightModelCommon(state, errors, entryPoint, pname))
     {
         return false;
     }
@@ -362,30 +380,34 @@ bool ValidateLightModelSingleComponent(const Context *context,
         case GL_LIGHT_MODEL_TWO_SIDE:
             return true;
         default:
-            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidLightModelParameter);
+            errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidLightModelParameter);
             return false;
     }
 }
 
-bool ValidateClipPlaneCommon(const Context *context, angle::EntryPoint entryPoint, GLenum plane)
+bool ValidateClipPlaneCommon(const PrivateState &state,
+                             ErrorSet *errors,
+                             angle::EntryPoint entryPoint,
+                             GLenum plane)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
 
-    if (plane < GL_CLIP_PLANE0 || plane >= GL_CLIP_PLANE0 + context->getCaps().maxClipPlanes)
+    if (plane < GL_CLIP_PLANE0 || plane >= GL_CLIP_PLANE0 + state.getCaps().maxClipPlanes)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidClipPlane);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidClipPlane);
         return false;
     }
 
     return true;
 }
 
-bool ValidateFogCommon(const Context *context,
+bool ValidateFogCommon(const PrivateState &state,
+                       ErrorSet *errors,
                        angle::EntryPoint entryPoint,
                        GLenum pname,
                        const GLfloat *params)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
 
     switch (pname)
     {
@@ -399,7 +421,7 @@ bool ValidateFogCommon(const Context *context,
                 case GL_LINEAR:
                     return true;
                 default:
-                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidFogMode);
+                    errors->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFogMode);
                     return false;
             }
         }
@@ -410,24 +432,25 @@ bool ValidateFogCommon(const Context *context,
         case GL_FOG_DENSITY:
             if (params[0] < 0.0f)
             {
-                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidFogDensity);
+                errors->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFogDensity);
                 return false;
             }
             break;
         default:
-            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFogParameter);
+            errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFogParameter);
             return false;
     }
     return true;
 }
 
-bool ValidateTexEnvCommon(const Context *context,
+bool ValidateTexEnvCommon(const PrivateState &state,
+                          ErrorSet *errors,
                           angle::EntryPoint entryPoint,
                           TextureEnvTarget target,
                           TextureEnvParameter pname,
                           const GLfloat *params)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
 
     switch (target)
     {
@@ -447,7 +470,8 @@ bool ValidateTexEnvCommon(const Context *context,
                         case TextureEnvMode::Replace:
                             break;
                         default:
-                            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureEnvMode);
+                            errors->validationError(entryPoint, GL_INVALID_VALUE,
+                                                    kInvalidTextureEnvMode);
                             return false;
                     }
                     break;
@@ -469,12 +493,14 @@ bool ValidateTexEnvCommon(const Context *context,
                         case TextureCombine::Dot3Rgba:
                             if (pname == TextureEnvParameter::CombineAlpha)
                             {
-                                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureCombine);
+                                errors->validationError(entryPoint, GL_INVALID_VALUE,
+                                                        kInvalidTextureCombine);
                                 return false;
                             }
                             break;
                         default:
-                            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureCombine);
+                            errors->validationError(entryPoint, GL_INVALID_VALUE,
+                                                    kInvalidTextureCombine);
                             return false;
                     }
                     break;
@@ -495,7 +521,8 @@ bool ValidateTexEnvCommon(const Context *context,
                         case TextureSrc::Texture:
                             break;
                         default:
-                            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureCombineSrc);
+                            errors->validationError(entryPoint, GL_INVALID_VALUE,
+                                                    kInvalidTextureCombineSrc);
                             return false;
                     }
                     break;
@@ -519,12 +546,14 @@ bool ValidateTexEnvCommon(const Context *context,
                                 pname == TextureEnvParameter::Op1Alpha ||
                                 pname == TextureEnvParameter::Op2Alpha)
                             {
-                                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureCombine);
+                                errors->validationError(entryPoint, GL_INVALID_VALUE,
+                                                        kInvalidTextureCombine);
                                 return false;
                             }
                             break;
                         default:
-                            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureCombineOp);
+                            errors->validationError(entryPoint, GL_INVALID_VALUE,
+                                                    kInvalidTextureCombineOp);
                             return false;
                     }
                     break;
@@ -533,21 +562,23 @@ bool ValidateTexEnvCommon(const Context *context,
                 case TextureEnvParameter::AlphaScale:
                     if (params[0] != 1.0f && params[0] != 2.0f && params[0] != 4.0f)
                     {
-                        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureEnvScale);
+                        errors->validationError(entryPoint, GL_INVALID_VALUE,
+                                                kInvalidTextureEnvScale);
                         return false;
                     }
                     break;
                 case TextureEnvParameter::Color:
                     break;
                 default:
-                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureEnvParameter);
+                    errors->validationError(entryPoint, GL_INVALID_ENUM,
+                                            kInvalidTextureEnvParameter);
                     return false;
             }
             break;
         case TextureEnvTarget::PointSprite:
-            if (!context->getExtensions().pointSpriteOES)
+            if (!state.getExtensions().pointSpriteOES)
             {
-                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureEnvTarget);
+                errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureEnvTarget);
                 return false;
             }
             switch (pname)
@@ -555,18 +586,20 @@ bool ValidateTexEnvCommon(const Context *context,
                 case TextureEnvParameter::PointCoordReplace:
                     break;
                 default:
-                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureEnvParameter);
+                    errors->validationError(entryPoint, GL_INVALID_ENUM,
+                                            kInvalidTextureEnvParameter);
                     return false;
             }
             break;
         default:
-            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureEnvTarget);
+            errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureEnvTarget);
             return false;
     }
     return true;
 }
 
-bool ValidateGetTexEnvCommon(const Context *context,
+bool ValidateGetTexEnvCommon(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              TextureEnvTarget target,
                              TextureEnvParameter pname)
@@ -606,15 +639,16 @@ bool ValidateGetTexEnvCommon(const Context *context,
             break;
     }
 
-    return ValidateTexEnvCommon(context, entryPoint, target, pname, validateParams);
+    return ValidateTexEnvCommon(state, errors, entryPoint, target, pname, validateParams);
 }
 
-bool ValidatePointParameterCommon(const Context *context,
+bool ValidatePointParameterCommon(const PrivateState &state,
+                                  ErrorSet *errors,
                                   angle::EntryPoint entryPoint,
                                   PointParameter pname,
                                   const GLfloat *params)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
 
     switch (pname)
     {
@@ -626,26 +660,30 @@ bool ValidatePointParameterCommon(const Context *context,
             {
                 if (params[i] < 0.0f)
                 {
-                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidPointParameterValue);
+                    errors->validationError(entryPoint, GL_INVALID_VALUE,
+                                            kInvalidPointParameterValue);
                     return false;
                 }
             }
             break;
         default:
-            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPointParameter);
+            errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPointParameter);
             return false;
     }
 
     return true;
 }
 
-bool ValidatePointSizeCommon(const Context *context, angle::EntryPoint entryPoint, GLfloat size)
+bool ValidatePointSizeCommon(const PrivateState &state,
+                             ErrorSet *errors,
+                             angle::EntryPoint entryPoint,
+                             GLfloat size)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
 
     if (size <= 0.0f)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidPointSizeValue);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kInvalidPointSizeValue);
         return false;
     }
 
@@ -657,7 +695,7 @@ bool ValidateDrawTexCommon(const Context *context,
                            float width,
                            float height)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1_CONTEXT(context, entryPoint);
 
     if (width <= 0.0f || height <= 0.0f)
     {
@@ -673,38 +711,44 @@ bool ValidateDrawTexCommon(const Context *context,
 namespace gl
 {
 
-bool ValidateAlphaFunc(const Context *context,
+bool ValidateAlphaFunc(const PrivateState &state,
+                       ErrorSet *errors,
                        angle::EntryPoint entryPoint,
                        AlphaTestFunc func,
                        GLfloat ref)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
-    return ValidateAlphaFuncCommon(context, entryPoint, func);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
+    return ValidateAlphaFuncCommon(state, errors, entryPoint, func);
 }
 
-bool ValidateAlphaFuncx(const Context *context,
+bool ValidateAlphaFuncx(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         AlphaTestFunc func,
                         GLfixed ref)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
-    return ValidateAlphaFuncCommon(context, entryPoint, func);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
+    return ValidateAlphaFuncCommon(state, errors, entryPoint, func);
 }
 
-bool ValidateClearColorx(const Context *context,
+bool ValidateClearColorx(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLfixed red,
                          GLfixed green,
                          GLfixed blue,
                          GLfixed alpha)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
-bool ValidateClearDepthx(const Context *context, angle::EntryPoint entryPoint, GLfixed depth)
+bool ValidateClearDepthx(const PrivateState &state,
+                         ErrorSet *errors,
+                         angle::EntryPoint entryPoint,
+                         GLfixed depth)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
@@ -712,56 +756,63 @@ bool ValidateClientActiveTexture(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  GLenum texture)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
-    return ValidateMultitextureUnit(context, entryPoint, texture);
+    ANGLE_VALIDATE_IS_GLES1_CONTEXT(context, entryPoint);
+    return ValidateMultitextureUnit(context->getPrivateState(),
+                                    context->getMutableErrorSetForValidation(), entryPoint,
+                                    texture);
 }
 
-bool ValidateClipPlanef(const Context *context,
+bool ValidateClipPlanef(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum plane,
                         const GLfloat *eqn)
 {
-    return ValidateClipPlaneCommon(context, entryPoint, plane);
+    return ValidateClipPlaneCommon(state, errors, entryPoint, plane);
 }
 
-bool ValidateClipPlanex(const Context *context,
+bool ValidateClipPlanex(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum plane,
                         const GLfixed *equation)
 {
-    return ValidateClipPlaneCommon(context, entryPoint, plane);
+    return ValidateClipPlaneCommon(state, errors, entryPoint, plane);
 }
 
-bool ValidateColor4f(const Context *context,
+bool ValidateColor4f(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      GLfloat red,
                      GLfloat green,
                      GLfloat blue,
                      GLfloat alpha)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
-bool ValidateColor4ub(const Context *context,
+bool ValidateColor4ub(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       GLubyte red,
                       GLubyte green,
                       GLubyte blue,
                       GLubyte alpha)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
-bool ValidateColor4x(const Context *context,
+bool ValidateColor4x(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      GLfixed red,
                      GLfixed green,
                      GLfixed blue,
                      GLfixed alpha)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
@@ -776,18 +827,25 @@ bool ValidateColorPointer(const Context *context,
                                                 size, type, stride, pointer);
 }
 
-bool ValidateCullFace(const Context *context, angle::EntryPoint entryPoint, GLenum mode)
+bool ValidateCullFace(const PrivateState &state,
+                      ErrorSet *errors,
+                      angle::EntryPoint entryPoint,
+                      GLenum mode)
 {
     UNIMPLEMENTED();
     return true;
 }
 
-bool ValidateDepthRangex(const Context *context, angle::EntryPoint entryPoint, GLfixed n, GLfixed f)
+bool ValidateDepthRangex(const PrivateState &state,
+                         ErrorSet *errors,
+                         angle::EntryPoint entryPoint,
+                         GLfixed n,
+                         GLfixed f)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
-    if (context->isWebGL() && n > f)
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
+    if (state.isWebGL() && n > f)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidDepthRange);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidDepthRange);
         return false;
     }
 
@@ -808,33 +866,43 @@ bool ValidateEnableClientState(const Context *context,
     return ValidateClientStateCommon(context, entryPoint, arrayType);
 }
 
-bool ValidateFogf(const Context *context, angle::EntryPoint entryPoint, GLenum pname, GLfloat param)
+bool ValidateFogf(const PrivateState &state,
+                  ErrorSet *errors,
+                  angle::EntryPoint entryPoint,
+                  GLenum pname,
+                  GLfloat param)
 {
-    return ValidateFogCommon(context, entryPoint, pname, &param);
+    return ValidateFogCommon(state, errors, entryPoint, pname, &param);
 }
 
-bool ValidateFogfv(const Context *context,
+bool ValidateFogfv(const PrivateState &state,
+                   ErrorSet *errors,
                    angle::EntryPoint entryPoint,
                    GLenum pname,
                    const GLfloat *params)
 {
-    return ValidateFogCommon(context, entryPoint, pname, params);
+    return ValidateFogCommon(state, errors, entryPoint, pname, params);
 }
 
-bool ValidateFogx(const Context *context, angle::EntryPoint entryPoint, GLenum pname, GLfixed param)
+bool ValidateFogx(const PrivateState &state,
+                  ErrorSet *errors,
+                  angle::EntryPoint entryPoint,
+                  GLenum pname,
+                  GLfixed param)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     GLfloat asFloat =
         pname == GL_FOG_MODE ? static_cast<GLfloat>(param) : ConvertFixedToFloat(param);
-    return ValidateFogCommon(context, entryPoint, pname, &asFloat);
+    return ValidateFogCommon(state, errors, entryPoint, pname, &asFloat);
 }
 
-bool ValidateFogxv(const Context *context,
+bool ValidateFogxv(const PrivateState &state,
+                   ErrorSet *errors,
                    angle::EntryPoint entryPoint,
                    GLenum pname,
                    const GLfixed *params)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     unsigned int paramCount = GetFogParameterCount(pname);
     GLfloat paramsf[4]      = {};
 
@@ -850,10 +918,11 @@ bool ValidateFogxv(const Context *context,
         }
     }
 
-    return ValidateFogCommon(context, entryPoint, pname, paramsf);
+    return ValidateFogCommon(state, errors, entryPoint, pname, paramsf);
 }
 
-bool ValidateFrustumf(const Context *context,
+bool ValidateFrustumf(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       GLfloat l,
                       GLfloat r,
@@ -862,16 +931,17 @@ bool ValidateFrustumf(const Context *context,
                       GLfloat n,
                       GLfloat f)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     if (l == r || b == t || n == f || n <= 0.0f || f <= 0.0f)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidProjectionMatrix);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProjectionMatrix);
         return false;
     }
     return true;
 }
 
-bool ValidateFrustumx(const Context *context,
+bool ValidateFrustumx(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       GLfixed l,
                       GLfixed r,
@@ -880,10 +950,10 @@ bool ValidateFrustumx(const Context *context,
                       GLfixed n,
                       GLfixed f)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     if (l == r || b == t || n == f || n <= 0 || f <= 0)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidProjectionMatrix);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProjectionMatrix);
         return false;
     }
     return true;
@@ -899,20 +969,22 @@ bool ValidateGetBufferParameteriv(const Context *context,
     return true;
 }
 
-bool ValidateGetClipPlanef(const Context *context,
+bool ValidateGetClipPlanef(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLenum plane,
                            const GLfloat *equation)
 {
-    return ValidateClipPlaneCommon(context, entryPoint, plane);
+    return ValidateClipPlaneCommon(state, errors, entryPoint, plane);
 }
 
-bool ValidateGetClipPlanex(const Context *context,
+bool ValidateGetClipPlanex(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLenum plane,
                            const GLfixed *equation)
 {
-    return ValidateClipPlaneCommon(context, entryPoint, plane);
+    return ValidateClipPlaneCommon(state, errors, entryPoint, plane);
 }
 
 bool ValidateGetFixedv(const Context *context,
@@ -920,75 +992,82 @@ bool ValidateGetFixedv(const Context *context,
                        GLenum pname,
                        const GLfixed *params)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1_CONTEXT(context, entryPoint);
     GLenum nativeType;
     unsigned int numParams = 0;
     return ValidateStateQuery(context, entryPoint, pname, &nativeType, &numParams);
 }
 
-bool ValidateGetLightfv(const Context *context,
+bool ValidateGetLightfv(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum light,
                         LightParameter pname,
                         const GLfloat *params)
 {
     GLfloat validateParams[4] = {0.0f, 0.0f, 0.0f, 0.0f};
-    return ValidateLightCommon(context, entryPoint, light, pname, validateParams);
+    return ValidateLightCommon(state, errors, entryPoint, light, pname, validateParams);
 }
 
-bool ValidateGetLightxv(const Context *context,
+bool ValidateGetLightxv(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum light,
                         LightParameter pname,
                         const GLfixed *params)
 {
     GLfloat validateParams[4] = {0.0f, 0.0f, 0.0f, 0.0f};
-    return ValidateLightCommon(context, entryPoint, light, pname, validateParams);
+    return ValidateLightCommon(state, errors, entryPoint, light, pname, validateParams);
 }
 
-bool ValidateGetMaterialfv(const Context *context,
+bool ValidateGetMaterialfv(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLenum face,
                            MaterialParameter pname,
                            const GLfloat *params)
 {
-    return ValidateMaterialQuery(context, entryPoint, face, pname);
+    return ValidateMaterialQuery(state, errors, entryPoint, face, pname);
 }
 
-bool ValidateGetMaterialxv(const Context *context,
+bool ValidateGetMaterialxv(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLenum face,
                            MaterialParameter pname,
                            const GLfixed *params)
 {
-    return ValidateMaterialQuery(context, entryPoint, face, pname);
+    return ValidateMaterialQuery(state, errors, entryPoint, face, pname);
 }
 
-bool ValidateGetTexEnvfv(const Context *context,
+bool ValidateGetTexEnvfv(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          TextureEnvTarget target,
                          TextureEnvParameter pname,
                          const GLfloat *params)
 {
-    return ValidateGetTexEnvCommon(context, entryPoint, target, pname);
+    return ValidateGetTexEnvCommon(state, errors, entryPoint, target, pname);
 }
 
-bool ValidateGetTexEnviv(const Context *context,
+bool ValidateGetTexEnviv(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          TextureEnvTarget target,
                          TextureEnvParameter pname,
                          const GLint *params)
 {
-    return ValidateGetTexEnvCommon(context, entryPoint, target, pname);
+    return ValidateGetTexEnvCommon(state, errors, entryPoint, target, pname);
 }
 
-bool ValidateGetTexEnvxv(const Context *context,
+bool ValidateGetTexEnvxv(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          TextureEnvTarget target,
                          TextureEnvParameter pname,
                          const GLfixed *params)
 {
-    return ValidateGetTexEnvCommon(context, entryPoint, target, pname);
+    return ValidateGetTexEnvCommon(state, errors, entryPoint, target, pname);
 }
 
 bool ValidateGetTexParameterxv(const Context *context,
@@ -997,7 +1076,7 @@ bool ValidateGetTexParameterxv(const Context *context,
                                GLenum pname,
                                const GLfixed *params)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1_CONTEXT(context, entryPoint);
 
     if (!ValidateGetTexParameterBase(context, entryPoint, target, pname, nullptr))
     {
@@ -1007,67 +1086,75 @@ bool ValidateGetTexParameterxv(const Context *context,
     return true;
 }
 
-bool ValidateLightModelf(const Context *context,
+bool ValidateLightModelf(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLenum pname,
                          GLfloat param)
 {
-    return ValidateLightModelSingleComponent(context, entryPoint, pname);
+    return ValidateLightModelSingleComponent(state, errors, entryPoint, pname);
 }
 
-bool ValidateLightModelfv(const Context *context,
+bool ValidateLightModelfv(const PrivateState &state,
+                          ErrorSet *errors,
                           angle::EntryPoint entryPoint,
                           GLenum pname,
                           const GLfloat *params)
 {
-    return ValidateLightModelCommon(context, entryPoint, pname);
+    return ValidateLightModelCommon(state, errors, entryPoint, pname);
 }
 
-bool ValidateLightModelx(const Context *context,
+bool ValidateLightModelx(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLenum pname,
                          GLfixed param)
 {
-    return ValidateLightModelSingleComponent(context, entryPoint, pname);
+    return ValidateLightModelSingleComponent(state, errors, entryPoint, pname);
 }
 
-bool ValidateLightModelxv(const Context *context,
+bool ValidateLightModelxv(const PrivateState &state,
+                          ErrorSet *errors,
                           angle::EntryPoint entryPoint,
                           GLenum pname,
                           const GLfixed *param)
 {
-    return ValidateLightModelCommon(context, entryPoint, pname);
+    return ValidateLightModelCommon(state, errors, entryPoint, pname);
 }
 
-bool ValidateLightf(const Context *context,
+bool ValidateLightf(const PrivateState &state,
+                    ErrorSet *errors,
                     angle::EntryPoint entryPoint,
                     GLenum light,
                     LightParameter pname,
                     GLfloat param)
 {
-    return ValidateLightSingleComponent(context, entryPoint, light, pname, param);
+    return ValidateLightSingleComponent(state, errors, entryPoint, light, pname, param);
 }
 
-bool ValidateLightfv(const Context *context,
+bool ValidateLightfv(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      GLenum light,
                      LightParameter pname,
                      const GLfloat *params)
 {
-    return ValidateLightCommon(context, entryPoint, light, pname, params);
+    return ValidateLightCommon(state, errors, entryPoint, light, pname, params);
 }
 
-bool ValidateLightx(const Context *context,
+bool ValidateLightx(const PrivateState &state,
+                    ErrorSet *errors,
                     angle::EntryPoint entryPoint,
                     GLenum light,
                     LightParameter pname,
                     GLfixed param)
 {
-    return ValidateLightSingleComponent(context, entryPoint, light, pname,
+    return ValidateLightSingleComponent(state, errors, entryPoint, light, pname,
                                         ConvertFixedToFloat(param));
 }
 
-bool ValidateLightxv(const Context *context,
+bool ValidateLightxv(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      GLenum light,
                      LightParameter pname,
@@ -1079,74 +1166,90 @@ bool ValidateLightxv(const Context *context,
         paramsf[i] = ConvertFixedToFloat(params[i]);
     }
 
-    return ValidateLightCommon(context, entryPoint, light, pname, paramsf);
+    return ValidateLightCommon(state, errors, entryPoint, light, pname, paramsf);
 }
 
-bool ValidateLineWidthx(const Context *context, angle::EntryPoint entryPoint, GLfixed width)
+bool ValidateLineWidthx(const PrivateState &state,
+                        ErrorSet *errors,
+                        angle::EntryPoint entryPoint,
+                        GLfixed width)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     if (width <= 0)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidWidth);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kInvalidWidth);
         return false;
     }
 
     return true;
 }
 
-bool ValidateLoadIdentity(const Context *context, angle::EntryPoint entryPoint)
+bool ValidateLoadIdentity(const PrivateState &state, ErrorSet *errors, angle::EntryPoint entryPoint)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
-bool ValidateLoadMatrixf(const Context *context, angle::EntryPoint entryPoint, const GLfloat *m)
+bool ValidateLoadMatrixf(const PrivateState &state,
+                         ErrorSet *errors,
+                         angle::EntryPoint entryPoint,
+                         const GLfloat *m)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
-bool ValidateLoadMatrixx(const Context *context, angle::EntryPoint entryPoint, const GLfixed *m)
+bool ValidateLoadMatrixx(const PrivateState &state,
+                         ErrorSet *errors,
+                         angle::EntryPoint entryPoint,
+                         const GLfixed *m)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
-bool ValidateLogicOp(const Context *context, angle::EntryPoint entryPoint, LogicalOperation opcode)
+bool ValidateLogicOp(const PrivateState &state,
+                     ErrorSet *errors,
+                     angle::EntryPoint entryPoint,
+                     LogicalOperation opcode)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
-    return ValidateLogicOpCommon(context, entryPoint, opcode);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
+    return ValidateLogicOpCommon(state, errors, entryPoint, opcode);
 }
 
-bool ValidateMaterialf(const Context *context,
+bool ValidateMaterialf(const PrivateState &state,
+                       ErrorSet *errors,
                        angle::EntryPoint entryPoint,
                        GLenum face,
                        MaterialParameter pname,
                        GLfloat param)
 {
-    return ValidateMaterialSingleComponent(context, entryPoint, face, pname, param);
+    return ValidateMaterialSingleComponent(state, errors, entryPoint, face, pname, param);
 }
 
-bool ValidateMaterialfv(const Context *context,
+bool ValidateMaterialfv(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum face,
                         MaterialParameter pname,
                         const GLfloat *params)
 {
-    return ValidateMaterialSetting(context, entryPoint, face, pname, params);
+    return ValidateMaterialSetting(state, errors, entryPoint, face, pname, params);
 }
 
-bool ValidateMaterialx(const Context *context,
+bool ValidateMaterialx(const PrivateState &state,
+                       ErrorSet *errors,
                        angle::EntryPoint entryPoint,
                        GLenum face,
                        MaterialParameter pname,
                        GLfixed param)
 {
-    return ValidateMaterialSingleComponent(context, entryPoint, face, pname,
+    return ValidateMaterialSingleComponent(state, errors, entryPoint, face, pname,
                                            ConvertFixedToFloat(param));
 }
 
-bool ValidateMaterialxv(const Context *context,
+bool ValidateMaterialxv(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum face,
                         MaterialParameter pname,
@@ -1159,12 +1262,15 @@ bool ValidateMaterialxv(const Context *context,
         paramsf[i] = ConvertFixedToFloat(params[i]);
     }
 
-    return ValidateMaterialSetting(context, entryPoint, face, pname, paramsf);
+    return ValidateMaterialSetting(state, errors, entryPoint, face, pname, paramsf);
 }
 
-bool ValidateMatrixMode(const Context *context, angle::EntryPoint entryPoint, MatrixType mode)
+bool ValidateMatrixMode(const PrivateState &state,
+                        ErrorSet *errors,
+                        angle::EntryPoint entryPoint,
+                        MatrixType mode)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     switch (mode)
     {
         case MatrixType::Projection:
@@ -1172,24 +1278,31 @@ bool ValidateMatrixMode(const Context *context, angle::EntryPoint entryPoint, Ma
         case MatrixType::Texture:
             return true;
         default:
-            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidMatrixMode);
+            errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidMatrixMode);
             return false;
     }
 }
 
-bool ValidateMultMatrixf(const Context *context, angle::EntryPoint entryPoint, const GLfloat *m)
+bool ValidateMultMatrixf(const PrivateState &state,
+                         ErrorSet *errors,
+                         angle::EntryPoint entryPoint,
+                         const GLfloat *m)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
-bool ValidateMultMatrixx(const Context *context, angle::EntryPoint entryPoint, const GLfixed *m)
+bool ValidateMultMatrixx(const PrivateState &state,
+                         ErrorSet *errors,
+                         angle::EntryPoint entryPoint,
+                         const GLfixed *m)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
-bool ValidateMultiTexCoord4f(const Context *context,
+bool ValidateMultiTexCoord4f(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLenum target,
                              GLfloat s,
@@ -1197,11 +1310,12 @@ bool ValidateMultiTexCoord4f(const Context *context,
                              GLfloat r,
                              GLfloat q)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
-    return ValidateMultitextureUnit(context, entryPoint, target);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
+    return ValidateMultitextureUnit(state, errors, entryPoint, target);
 }
 
-bool ValidateMultiTexCoord4x(const Context *context,
+bool ValidateMultiTexCoord4x(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLenum target,
                              GLfixed s,
@@ -1209,27 +1323,29 @@ bool ValidateMultiTexCoord4x(const Context *context,
                              GLfixed r,
                              GLfixed q)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
-    return ValidateMultitextureUnit(context, entryPoint, target);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
+    return ValidateMultitextureUnit(state, errors, entryPoint, target);
 }
 
-bool ValidateNormal3f(const Context *context,
+bool ValidateNormal3f(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       GLfloat nx,
                       GLfloat ny,
                       GLfloat nz)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
-bool ValidateNormal3x(const Context *context,
+bool ValidateNormal3x(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       GLfixed nx,
                       GLfixed ny,
                       GLfixed nz)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
@@ -1243,7 +1359,8 @@ bool ValidateNormalPointer(const Context *context,
                                                 3, type, stride, pointer);
 }
 
-bool ValidateOrthof(const Context *context,
+bool ValidateOrthof(const PrivateState &state,
+                    ErrorSet *errors,
                     angle::EntryPoint entryPoint,
                     GLfloat l,
                     GLfloat r,
@@ -1252,19 +1369,20 @@ bool ValidateOrthof(const Context *context,
                     GLfloat n,
                     GLfloat f)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     // [OpenGL ES 1.1.12] section 2.10.2 page 31:
     // If l is equal to r, b is equal to t, or n is equal to f, the
     // error INVALID VALUE results.
     if (l == r || b == t || n == f)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidProjectionMatrix);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProjectionMatrix);
         return false;
     }
     return true;
 }
 
-bool ValidateOrthox(const Context *context,
+bool ValidateOrthox(const PrivateState &state,
+                    ErrorSet *errors,
                     angle::EntryPoint entryPoint,
                     GLfixed l,
                     GLfixed r,
@@ -1273,16 +1391,17 @@ bool ValidateOrthox(const Context *context,
                     GLfixed n,
                     GLfixed f)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     if (l == r || b == t || n == f)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidProjectionMatrix);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProjectionMatrix);
         return false;
     }
     return true;
 }
 
-bool ValidatePointParameterf(const Context *context,
+bool ValidatePointParameterf(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              PointParameter pname,
                              GLfloat param)
@@ -1290,22 +1409,24 @@ bool ValidatePointParameterf(const Context *context,
     unsigned int paramCount = GetPointParameterCount(pname);
     if (paramCount != 1)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPointParameter);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPointParameter);
         return false;
     }
 
-    return ValidatePointParameterCommon(context, entryPoint, pname, &param);
+    return ValidatePointParameterCommon(state, errors, entryPoint, pname, &param);
 }
 
-bool ValidatePointParameterfv(const Context *context,
+bool ValidatePointParameterfv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               PointParameter pname,
                               const GLfloat *params)
 {
-    return ValidatePointParameterCommon(context, entryPoint, pname, params);
+    return ValidatePointParameterCommon(state, errors, entryPoint, pname, params);
 }
 
-bool ValidatePointParameterx(const Context *context,
+bool ValidatePointParameterx(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              PointParameter pname,
                              GLfixed param)
@@ -1313,15 +1434,16 @@ bool ValidatePointParameterx(const Context *context,
     unsigned int paramCount = GetPointParameterCount(pname);
     if (paramCount != 1)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPointParameter);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPointParameter);
         return false;
     }
 
     GLfloat paramf = ConvertFixedToFloat(param);
-    return ValidatePointParameterCommon(context, entryPoint, pname, &paramf);
+    return ValidatePointParameterCommon(state, errors, entryPoint, pname, &paramf);
 }
 
-bool ValidatePointParameterxv(const Context *context,
+bool ValidatePointParameterxv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               PointParameter pname,
                               const GLfixed *params)
@@ -1331,113 +1453,128 @@ bool ValidatePointParameterxv(const Context *context,
     {
         paramsf[i] = ConvertFixedToFloat(params[i]);
     }
-    return ValidatePointParameterCommon(context, entryPoint, pname, paramsf);
+    return ValidatePointParameterCommon(state, errors, entryPoint, pname, paramsf);
 }
 
-bool ValidatePointSize(const Context *context, angle::EntryPoint entryPoint, GLfloat size)
+bool ValidatePointSize(const PrivateState &state,
+                       ErrorSet *errors,
+                       angle::EntryPoint entryPoint,
+                       GLfloat size)
 {
-    return ValidatePointSizeCommon(context, entryPoint, size);
+    return ValidatePointSizeCommon(state, errors, entryPoint, size);
 }
 
-bool ValidatePointSizex(const Context *context, angle::EntryPoint entryPoint, GLfixed size)
+bool ValidatePointSizex(const PrivateState &state,
+                        ErrorSet *errors,
+                        angle::EntryPoint entryPoint,
+                        GLfixed size)
 {
-    return ValidatePointSizeCommon(context, entryPoint, ConvertFixedToFloat(size));
+    return ValidatePointSizeCommon(state, errors, entryPoint, ConvertFixedToFloat(size));
 }
 
-bool ValidatePolygonOffsetx(const Context *context,
+bool ValidatePolygonOffsetx(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLfixed factor,
                             GLfixed units)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
-bool ValidatePopMatrix(const Context *context, angle::EntryPoint entryPoint)
+bool ValidatePopMatrix(const PrivateState &state, ErrorSet *errors, angle::EntryPoint entryPoint)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
-    const auto &stack = context->getState().gles1().currentMatrixStack();
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
+    const auto &stack = state.gles1().currentMatrixStack();
     if (stack.size() == 1)
     {
-        ANGLE_VALIDATION_ERROR(GL_STACK_UNDERFLOW, kMatrixStackUnderflow);
+        errors->validationError(entryPoint, GL_STACK_UNDERFLOW, kMatrixStackUnderflow);
         return false;
     }
     return true;
 }
 
-bool ValidatePushMatrix(const Context *context, angle::EntryPoint entryPoint)
+bool ValidatePushMatrix(const PrivateState &state, ErrorSet *errors, angle::EntryPoint entryPoint)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
-    const auto &stack = context->getState().gles1().currentMatrixStack();
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
+    const auto &stack = state.gles1().currentMatrixStack();
     if (stack.size() == stack.max_size())
     {
-        ANGLE_VALIDATION_ERROR(GL_STACK_OVERFLOW, kMatrixStackOverflow);
+        errors->validationError(entryPoint, GL_STACK_OVERFLOW, kMatrixStackOverflow);
         return false;
     }
     return true;
 }
 
-bool ValidateRotatef(const Context *context,
+bool ValidateRotatef(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      GLfloat angle,
                      GLfloat x,
                      GLfloat y,
                      GLfloat z)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
-bool ValidateRotatex(const Context *context,
+bool ValidateRotatex(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      GLfixed angle,
                      GLfixed x,
                      GLfixed y,
                      GLfixed z)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
-bool ValidateSampleCoveragex(const Context *context,
+bool ValidateSampleCoveragex(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLclampx value,
                              GLboolean invert)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
-bool ValidateScalef(const Context *context,
+bool ValidateScalef(const PrivateState &state,
+                    ErrorSet *errors,
                     angle::EntryPoint entryPoint,
                     GLfloat x,
                     GLfloat y,
                     GLfloat z)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
-bool ValidateScalex(const Context *context,
+bool ValidateScalex(const PrivateState &state,
+                    ErrorSet *errors,
                     angle::EntryPoint entryPoint,
                     GLfixed x,
                     GLfixed y,
                     GLfixed z)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
-bool ValidateShadeModel(const Context *context, angle::EntryPoint entryPoint, ShadingModel mode)
+bool ValidateShadeModel(const PrivateState &state,
+                        ErrorSet *errors,
+                        angle::EntryPoint entryPoint,
+                        ShadingModel mode)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     switch (mode)
     {
         case ShadingModel::Flat:
         case ShadingModel::Smooth:
             return true;
         default:
-            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidShadingModel);
+            errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShadingModel);
             return false;
     }
 }
@@ -1453,35 +1590,39 @@ bool ValidateTexCoordPointer(const Context *context,
         context, entryPoint, ClientVertexArrayType::TextureCoord, size, type, stride, pointer);
 }
 
-bool ValidateTexEnvf(const Context *context,
+bool ValidateTexEnvf(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      TextureEnvTarget target,
                      TextureEnvParameter pname,
                      GLfloat param)
 {
-    return ValidateTexEnvCommon(context, entryPoint, target, pname, &param);
+    return ValidateTexEnvCommon(state, errors, entryPoint, target, pname, &param);
 }
 
-bool ValidateTexEnvfv(const Context *context,
+bool ValidateTexEnvfv(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       TextureEnvTarget target,
                       TextureEnvParameter pname,
                       const GLfloat *params)
 {
-    return ValidateTexEnvCommon(context, entryPoint, target, pname, params);
+    return ValidateTexEnvCommon(state, errors, entryPoint, target, pname, params);
 }
 
-bool ValidateTexEnvi(const Context *context,
+bool ValidateTexEnvi(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      TextureEnvTarget target,
                      TextureEnvParameter pname,
                      GLint param)
 {
     GLfloat paramf = static_cast<GLfloat>(param);
-    return ValidateTexEnvCommon(context, entryPoint, target, pname, &paramf);
+    return ValidateTexEnvCommon(state, errors, entryPoint, target, pname, &paramf);
 }
 
-bool ValidateTexEnviv(const Context *context,
+bool ValidateTexEnviv(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       TextureEnvTarget target,
                       TextureEnvParameter pname,
@@ -1492,31 +1633,33 @@ bool ValidateTexEnviv(const Context *context,
     {
         paramsf[i] = static_cast<GLfloat>(params[i]);
     }
-    return ValidateTexEnvCommon(context, entryPoint, target, pname, paramsf);
+    return ValidateTexEnvCommon(state, errors, entryPoint, target, pname, paramsf);
 }
 
-bool ValidateTexEnvx(const Context *context,
+bool ValidateTexEnvx(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      TextureEnvTarget target,
                      TextureEnvParameter pname,
                      GLfixed param)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     GLfloat paramsf[4] = {};
     ConvertTextureEnvFromFixed(pname, &param, paramsf);
-    return ValidateTexEnvCommon(context, entryPoint, target, pname, paramsf);
+    return ValidateTexEnvCommon(state, errors, entryPoint, target, pname, paramsf);
 }
 
-bool ValidateTexEnvxv(const Context *context,
+bool ValidateTexEnvxv(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       TextureEnvTarget target,
                       TextureEnvParameter pname,
                       const GLfixed *params)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     GLfloat paramsf[4] = {};
     ConvertTextureEnvFromFixed(pname, params, paramsf);
-    return ValidateTexEnvCommon(context, entryPoint, target, pname, paramsf);
+    return ValidateTexEnvCommon(state, errors, entryPoint, target, pname, paramsf);
 }
 
 bool ValidateTexParameterBaseForGLfixed(const Context *context,
@@ -1550,7 +1693,7 @@ bool ValidateTexParameterx(const Context *context,
                            GLenum pname,
                            GLfixed param)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1_CONTEXT(context, entryPoint);
     return ValidateTexParameterBaseForGLfixed(context, entryPoint, target, pname, -1, false,
                                               &param);
 }
@@ -1561,27 +1704,29 @@ bool ValidateTexParameterxv(const Context *context,
                             GLenum pname,
                             const GLfixed *params)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1_CONTEXT(context, entryPoint);
     return ValidateTexParameterBaseForGLfixed(context, entryPoint, target, pname, -1, true, params);
 }
 
-bool ValidateTranslatef(const Context *context,
+bool ValidateTranslatef(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLfloat x,
                         GLfloat y,
                         GLfloat z)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
-bool ValidateTranslatex(const Context *context,
+bool ValidateTranslatex(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLfixed x,
                         GLfixed y,
                         GLfixed z)
 {
-    ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
+    ANGLE_VALIDATE_IS_GLES1(state, errors, entryPoint);
     return true;
 }
 
diff --git a/src/libANGLE/validationES1_autogen.h b/src/libANGLE/validationES1_autogen.h
index 81f168e57..74301c768 100644
--- a/src/libANGLE/validationES1_autogen.h
+++ b/src/libANGLE/validationES1_autogen.h
@@ -17,46 +17,59 @@
 namespace gl
 {
 class Context;
+class PrivateState;
+class ErrorSet;
 
-bool ValidateAlphaFunc(const Context *context,
+bool ValidateAlphaFunc(const PrivateState &state,
+                       ErrorSet *errors,
                        angle::EntryPoint entryPoint,
                        AlphaTestFunc funcPacked,
                        GLfloat ref);
-bool ValidateAlphaFuncx(const Context *context,
+bool ValidateAlphaFuncx(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         AlphaTestFunc funcPacked,
                         GLfixed ref);
-bool ValidateClearColorx(const Context *context,
+bool ValidateClearColorx(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLfixed red,
                          GLfixed green,
                          GLfixed blue,
                          GLfixed alpha);
-bool ValidateClearDepthx(const Context *context, angle::EntryPoint entryPoint, GLfixed depth);
+bool ValidateClearDepthx(const PrivateState &state,
+                         ErrorSet *errors,
+                         angle::EntryPoint entryPoint,
+                         GLfixed depth);
 bool ValidateClientActiveTexture(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  GLenum texture);
-bool ValidateClipPlanef(const Context *context,
+bool ValidateClipPlanef(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum p,
                         const GLfloat *eqn);
-bool ValidateClipPlanex(const Context *context,
+bool ValidateClipPlanex(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum plane,
                         const GLfixed *equation);
-bool ValidateColor4f(const Context *context,
+bool ValidateColor4f(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      GLfloat red,
                      GLfloat green,
                      GLfloat blue,
                      GLfloat alpha);
-bool ValidateColor4ub(const Context *context,
+bool ValidateColor4ub(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       GLubyte red,
                       GLubyte green,
                       GLubyte blue,
                       GLubyte alpha);
-bool ValidateColor4x(const Context *context,
+bool ValidateColor4x(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      GLfixed red,
                      GLfixed green,
@@ -68,7 +81,8 @@ bool ValidateColorPointer(const Context *context,
                           VertexAttribType typePacked,
                           GLsizei stride,
                           const void *pointer);
-bool ValidateDepthRangex(const Context *context,
+bool ValidateDepthRangex(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLfixed n,
                          GLfixed f);
@@ -78,23 +92,28 @@ bool ValidateDisableClientState(const Context *context,
 bool ValidateEnableClientState(const Context *context,
                                angle::EntryPoint entryPoint,
                                ClientVertexArrayType arrayPacked);
-bool ValidateFogf(const Context *context,
+bool ValidateFogf(const PrivateState &state,
+                  ErrorSet *errors,
                   angle::EntryPoint entryPoint,
                   GLenum pname,
                   GLfloat param);
-bool ValidateFogfv(const Context *context,
+bool ValidateFogfv(const PrivateState &state,
+                   ErrorSet *errors,
                    angle::EntryPoint entryPoint,
                    GLenum pname,
                    const GLfloat *params);
-bool ValidateFogx(const Context *context,
+bool ValidateFogx(const PrivateState &state,
+                  ErrorSet *errors,
                   angle::EntryPoint entryPoint,
                   GLenum pname,
                   GLfixed param);
-bool ValidateFogxv(const Context *context,
+bool ValidateFogxv(const PrivateState &state,
+                   ErrorSet *errors,
                    angle::EntryPoint entryPoint,
                    GLenum pname,
                    const GLfixed *param);
-bool ValidateFrustumf(const Context *context,
+bool ValidateFrustumf(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       GLfloat l,
                       GLfloat r,
@@ -102,7 +121,8 @@ bool ValidateFrustumf(const Context *context,
                       GLfloat t,
                       GLfloat n,
                       GLfloat f);
-bool ValidateFrustumx(const Context *context,
+bool ValidateFrustumx(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       GLfixed l,
                       GLfixed r,
@@ -110,11 +130,13 @@ bool ValidateFrustumx(const Context *context,
                       GLfixed t,
                       GLfixed n,
                       GLfixed f);
-bool ValidateGetClipPlanef(const Context *context,
+bool ValidateGetClipPlanef(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLenum plane,
                            const GLfloat *equation);
-bool ValidateGetClipPlanex(const Context *context,
+bool ValidateGetClipPlanex(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLenum plane,
                            const GLfixed *equation);
@@ -122,37 +144,44 @@ bool ValidateGetFixedv(const Context *context,
                        angle::EntryPoint entryPoint,
                        GLenum pname,
                        const GLfixed *params);
-bool ValidateGetLightfv(const Context *context,
+bool ValidateGetLightfv(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum light,
                         LightParameter pnamePacked,
                         const GLfloat *params);
-bool ValidateGetLightxv(const Context *context,
+bool ValidateGetLightxv(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum light,
                         LightParameter pnamePacked,
                         const GLfixed *params);
-bool ValidateGetMaterialfv(const Context *context,
+bool ValidateGetMaterialfv(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLenum face,
                            MaterialParameter pnamePacked,
                            const GLfloat *params);
-bool ValidateGetMaterialxv(const Context *context,
+bool ValidateGetMaterialxv(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLenum face,
                            MaterialParameter pnamePacked,
                            const GLfixed *params);
-bool ValidateGetTexEnvfv(const Context *context,
+bool ValidateGetTexEnvfv(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          TextureEnvTarget targetPacked,
                          TextureEnvParameter pnamePacked,
                          const GLfloat *params);
-bool ValidateGetTexEnviv(const Context *context,
+bool ValidateGetTexEnviv(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          TextureEnvTarget targetPacked,
                          TextureEnvParameter pnamePacked,
                          const GLint *params);
-bool ValidateGetTexEnvxv(const Context *context,
+bool ValidateGetTexEnvxv(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          TextureEnvTarget targetPacked,
                          TextureEnvParameter pnamePacked,
@@ -162,94 +191,129 @@ bool ValidateGetTexParameterxv(const Context *context,
                                TextureType targetPacked,
                                GLenum pname,
                                const GLfixed *params);
-bool ValidateLightModelf(const Context *context,
+bool ValidateLightModelf(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLenum pname,
                          GLfloat param);
-bool ValidateLightModelfv(const Context *context,
+bool ValidateLightModelfv(const PrivateState &state,
+                          ErrorSet *errors,
                           angle::EntryPoint entryPoint,
                           GLenum pname,
                           const GLfloat *params);
-bool ValidateLightModelx(const Context *context,
+bool ValidateLightModelx(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLenum pname,
                          GLfixed param);
-bool ValidateLightModelxv(const Context *context,
+bool ValidateLightModelxv(const PrivateState &state,
+                          ErrorSet *errors,
                           angle::EntryPoint entryPoint,
                           GLenum pname,
                           const GLfixed *param);
-bool ValidateLightf(const Context *context,
+bool ValidateLightf(const PrivateState &state,
+                    ErrorSet *errors,
                     angle::EntryPoint entryPoint,
                     GLenum light,
                     LightParameter pnamePacked,
                     GLfloat param);
-bool ValidateLightfv(const Context *context,
+bool ValidateLightfv(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      GLenum light,
                      LightParameter pnamePacked,
                      const GLfloat *params);
-bool ValidateLightx(const Context *context,
+bool ValidateLightx(const PrivateState &state,
+                    ErrorSet *errors,
                     angle::EntryPoint entryPoint,
                     GLenum light,
                     LightParameter pnamePacked,
                     GLfixed param);
-bool ValidateLightxv(const Context *context,
+bool ValidateLightxv(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      GLenum light,
                      LightParameter pnamePacked,
                      const GLfixed *params);
-bool ValidateLineWidthx(const Context *context, angle::EntryPoint entryPoint, GLfixed width);
-bool ValidateLoadIdentity(const Context *context, angle::EntryPoint entryPoint);
-bool ValidateLoadMatrixf(const Context *context, angle::EntryPoint entryPoint, const GLfloat *m);
-bool ValidateLoadMatrixx(const Context *context, angle::EntryPoint entryPoint, const GLfixed *m);
-bool ValidateLogicOp(const Context *context,
+bool ValidateLineWidthx(const PrivateState &state,
+                        ErrorSet *errors,
+                        angle::EntryPoint entryPoint,
+                        GLfixed width);
+bool ValidateLoadIdentity(const PrivateState &state,
+                          ErrorSet *errors,
+                          angle::EntryPoint entryPoint);
+bool ValidateLoadMatrixf(const PrivateState &state,
+                         ErrorSet *errors,
+                         angle::EntryPoint entryPoint,
+                         const GLfloat *m);
+bool ValidateLoadMatrixx(const PrivateState &state,
+                         ErrorSet *errors,
+                         angle::EntryPoint entryPoint,
+                         const GLfixed *m);
+bool ValidateLogicOp(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      LogicalOperation opcodePacked);
-bool ValidateMaterialf(const Context *context,
+bool ValidateMaterialf(const PrivateState &state,
+                       ErrorSet *errors,
                        angle::EntryPoint entryPoint,
                        GLenum face,
                        MaterialParameter pnamePacked,
                        GLfloat param);
-bool ValidateMaterialfv(const Context *context,
+bool ValidateMaterialfv(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum face,
                         MaterialParameter pnamePacked,
                         const GLfloat *params);
-bool ValidateMaterialx(const Context *context,
+bool ValidateMaterialx(const PrivateState &state,
+                       ErrorSet *errors,
                        angle::EntryPoint entryPoint,
                        GLenum face,
                        MaterialParameter pnamePacked,
                        GLfixed param);
-bool ValidateMaterialxv(const Context *context,
+bool ValidateMaterialxv(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum face,
                         MaterialParameter pnamePacked,
                         const GLfixed *param);
-bool ValidateMatrixMode(const Context *context,
+bool ValidateMatrixMode(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         MatrixType modePacked);
-bool ValidateMultMatrixf(const Context *context, angle::EntryPoint entryPoint, const GLfloat *m);
-bool ValidateMultMatrixx(const Context *context, angle::EntryPoint entryPoint, const GLfixed *m);
-bool ValidateMultiTexCoord4f(const Context *context,
+bool ValidateMultMatrixf(const PrivateState &state,
+                         ErrorSet *errors,
+                         angle::EntryPoint entryPoint,
+                         const GLfloat *m);
+bool ValidateMultMatrixx(const PrivateState &state,
+                         ErrorSet *errors,
+                         angle::EntryPoint entryPoint,
+                         const GLfixed *m);
+bool ValidateMultiTexCoord4f(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLenum target,
                              GLfloat s,
                              GLfloat t,
                              GLfloat r,
                              GLfloat q);
-bool ValidateMultiTexCoord4x(const Context *context,
+bool ValidateMultiTexCoord4x(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLenum texture,
                              GLfixed s,
                              GLfixed t,
                              GLfixed r,
                              GLfixed q);
-bool ValidateNormal3f(const Context *context,
+bool ValidateNormal3f(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       GLfloat nx,
                       GLfloat ny,
                       GLfloat nz);
-bool ValidateNormal3x(const Context *context,
+bool ValidateNormal3x(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       GLfixed nx,
                       GLfixed ny,
@@ -259,7 +323,8 @@ bool ValidateNormalPointer(const Context *context,
                            VertexAttribType typePacked,
                            GLsizei stride,
                            const void *pointer);
-bool ValidateOrthof(const Context *context,
+bool ValidateOrthof(const PrivateState &state,
+                    ErrorSet *errors,
                     angle::EntryPoint entryPoint,
                     GLfloat l,
                     GLfloat r,
@@ -267,7 +332,8 @@ bool ValidateOrthof(const Context *context,
                     GLfloat t,
                     GLfloat n,
                     GLfloat f);
-bool ValidateOrthox(const Context *context,
+bool ValidateOrthox(const PrivateState &state,
+                    ErrorSet *errors,
                     angle::EntryPoint entryPoint,
                     GLfixed l,
                     GLfixed r,
@@ -275,57 +341,74 @@ bool ValidateOrthox(const Context *context,
                     GLfixed t,
                     GLfixed n,
                     GLfixed f);
-bool ValidatePointParameterf(const Context *context,
+bool ValidatePointParameterf(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              PointParameter pnamePacked,
                              GLfloat param);
-bool ValidatePointParameterfv(const Context *context,
+bool ValidatePointParameterfv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               PointParameter pnamePacked,
                               const GLfloat *params);
-bool ValidatePointParameterx(const Context *context,
+bool ValidatePointParameterx(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              PointParameter pnamePacked,
                              GLfixed param);
-bool ValidatePointParameterxv(const Context *context,
+bool ValidatePointParameterxv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               PointParameter pnamePacked,
                               const GLfixed *params);
-bool ValidatePointSize(const Context *context, angle::EntryPoint entryPoint, GLfloat size);
-bool ValidatePointSizex(const Context *context, angle::EntryPoint entryPoint, GLfixed size);
-bool ValidatePolygonOffsetx(const Context *context,
+bool ValidatePointSize(const PrivateState &state,
+                       ErrorSet *errors,
+                       angle::EntryPoint entryPoint,
+                       GLfloat size);
+bool ValidatePointSizex(const PrivateState &state,
+                        ErrorSet *errors,
+                        angle::EntryPoint entryPoint,
+                        GLfixed size);
+bool ValidatePolygonOffsetx(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLfixed factor,
                             GLfixed units);
-bool ValidatePopMatrix(const Context *context, angle::EntryPoint entryPoint);
-bool ValidatePushMatrix(const Context *context, angle::EntryPoint entryPoint);
-bool ValidateRotatef(const Context *context,
+bool ValidatePopMatrix(const PrivateState &state, ErrorSet *errors, angle::EntryPoint entryPoint);
+bool ValidatePushMatrix(const PrivateState &state, ErrorSet *errors, angle::EntryPoint entryPoint);
+bool ValidateRotatef(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      GLfloat angle,
                      GLfloat x,
                      GLfloat y,
                      GLfloat z);
-bool ValidateRotatex(const Context *context,
+bool ValidateRotatex(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      GLfixed angle,
                      GLfixed x,
                      GLfixed y,
                      GLfixed z);
-bool ValidateSampleCoveragex(const Context *context,
+bool ValidateSampleCoveragex(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLclampx value,
                              GLboolean invert);
-bool ValidateScalef(const Context *context,
+bool ValidateScalef(const PrivateState &state,
+                    ErrorSet *errors,
                     angle::EntryPoint entryPoint,
                     GLfloat x,
                     GLfloat y,
                     GLfloat z);
-bool ValidateScalex(const Context *context,
+bool ValidateScalex(const PrivateState &state,
+                    ErrorSet *errors,
                     angle::EntryPoint entryPoint,
                     GLfixed x,
                     GLfixed y,
                     GLfixed z);
-bool ValidateShadeModel(const Context *context,
+bool ValidateShadeModel(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         ShadingModel modePacked);
 bool ValidateTexCoordPointer(const Context *context,
@@ -334,32 +417,38 @@ bool ValidateTexCoordPointer(const Context *context,
                              VertexAttribType typePacked,
                              GLsizei stride,
                              const void *pointer);
-bool ValidateTexEnvf(const Context *context,
+bool ValidateTexEnvf(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      TextureEnvTarget targetPacked,
                      TextureEnvParameter pnamePacked,
                      GLfloat param);
-bool ValidateTexEnvfv(const Context *context,
+bool ValidateTexEnvfv(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       TextureEnvTarget targetPacked,
                       TextureEnvParameter pnamePacked,
                       const GLfloat *params);
-bool ValidateTexEnvi(const Context *context,
+bool ValidateTexEnvi(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      TextureEnvTarget targetPacked,
                      TextureEnvParameter pnamePacked,
                      GLint param);
-bool ValidateTexEnviv(const Context *context,
+bool ValidateTexEnviv(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       TextureEnvTarget targetPacked,
                       TextureEnvParameter pnamePacked,
                       const GLint *params);
-bool ValidateTexEnvx(const Context *context,
+bool ValidateTexEnvx(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      TextureEnvTarget targetPacked,
                      TextureEnvParameter pnamePacked,
                      GLfixed param);
-bool ValidateTexEnvxv(const Context *context,
+bool ValidateTexEnvxv(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       TextureEnvTarget targetPacked,
                       TextureEnvParameter pnamePacked,
@@ -374,12 +463,14 @@ bool ValidateTexParameterxv(const Context *context,
                             TextureType targetPacked,
                             GLenum pname,
                             const GLfixed *params);
-bool ValidateTranslatef(const Context *context,
+bool ValidateTranslatef(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLfloat x,
                         GLfloat y,
                         GLfloat z);
-bool ValidateTranslatex(const Context *context,
+bool ValidateTranslatex(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLfixed x,
                         GLfixed y,
diff --git a/src/libANGLE/validationES2.cpp b/src/libANGLE/validationES2.cpp
index 6f4c28e01..b4c39e5e7 100644
--- a/src/libANGLE/validationES2.cpp
+++ b/src/libANGLE/validationES2.cpp
@@ -598,14 +598,14 @@ static bool IsCapBannedWithActivePLS(GLenum cap)
     }
 }
 
-bool ValidCap(const Context *context, GLenum cap, bool queryOnly)
+bool ValidCap(const PrivateState &state, ErrorSet *errors, GLenum cap, bool queryOnly)
 {
     switch (cap)
     {
         // EXT_multisample_compatibility
         case GL_MULTISAMPLE_EXT:
         case GL_SAMPLE_ALPHA_TO_ONE_EXT:
-            return context->getExtensions().multisampleCompatibilityEXT;
+            return state.getExtensions().multisampleCompatibilityEXT;
 
         case GL_CULL_FACE:
         case GL_POLYGON_OFFSET_FILL:
@@ -619,38 +619,38 @@ bool ValidCap(const Context *context, GLenum cap, bool queryOnly)
             return true;
 
         case GL_POLYGON_OFFSET_POINT_NV:
-            return context->getExtensions().polygonModeNV;
+            return state.getExtensions().polygonModeNV;
         case GL_POLYGON_OFFSET_LINE_NV:  // = GL_POLYGON_OFFSET_LINE_ANGLE
-            return context->getExtensions().polygonModeAny();
+            return state.getExtensions().polygonModeAny();
 
         case GL_DEPTH_CLAMP_EXT:
-            return context->getExtensions().depthClampEXT;
+            return state.getExtensions().depthClampEXT;
 
         case GL_PRIMITIVE_RESTART_FIXED_INDEX:
         case GL_RASTERIZER_DISCARD:
-            return (context->getClientMajorVersion() >= 3);
+            return (state.getClientMajorVersion() >= 3);
 
         case GL_DEBUG_OUTPUT_SYNCHRONOUS:
         case GL_DEBUG_OUTPUT:
-            return context->getExtensions().debugKHR;
+            return state.getExtensions().debugKHR;
 
         case GL_BIND_GENERATES_RESOURCE_CHROMIUM:
-            return queryOnly && context->getExtensions().bindGeneratesResourceCHROMIUM;
+            return queryOnly && state.getExtensions().bindGeneratesResourceCHROMIUM;
 
         case GL_CLIENT_ARRAYS_ANGLE:
-            return queryOnly && context->getExtensions().clientArraysANGLE;
+            return queryOnly && state.getExtensions().clientArraysANGLE;
 
         case GL_FRAMEBUFFER_SRGB_EXT:
-            return context->getExtensions().sRGBWriteControlEXT;
+            return state.getExtensions().sRGBWriteControlEXT;
 
         case GL_SAMPLE_MASK:
-            return context->getClientVersion() >= Version(3, 1);
+            return state.getClientVersion() >= Version(3, 1);
 
         case GL_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
-            return queryOnly && context->getExtensions().robustResourceInitializationANGLE;
+            return queryOnly && state.getExtensions().robustResourceInitializationANGLE;
 
         case GL_TEXTURE_RECTANGLE_ANGLE:
-            return context->isWebGL();
+            return state.isWebGL();
 
         // GL_APPLE_clip_distance / GL_EXT_clip_cull_distance / GL_ANGLE_clip_cull_distance
         case GL_CLIP_DISTANCE0_EXT:
@@ -661,34 +661,33 @@ bool ValidCap(const Context *context, GLenum cap, bool queryOnly)
         case GL_CLIP_DISTANCE5_EXT:
         case GL_CLIP_DISTANCE6_EXT:
         case GL_CLIP_DISTANCE7_EXT:
-            if (context->getExtensions().clipDistanceAPPLE ||
-                context->getExtensions().clipCullDistanceAny())
+            if (state.getExtensions().clipDistanceAPPLE ||
+                state.getExtensions().clipCullDistanceAny())
             {
                 return true;
             }
             break;
         case GL_SAMPLE_SHADING:
-            return context->getExtensions().sampleShadingOES;
+            return state.getExtensions().sampleShadingOES;
         case GL_SHADING_RATE_PRESERVE_ASPECT_RATIO_QCOM:
-            return context->getExtensions().shadingRateQCOM;
+            return state.getExtensions().shadingRateQCOM;
 
         // COLOR_LOGIC_OP is in GLES1, but exposed through an ANGLE extension.
         case GL_COLOR_LOGIC_OP:
-            return context->getClientVersion() < Version(2, 0) ||
-                   context->getExtensions().logicOpANGLE;
+            return state.getClientVersion() < Version(2, 0) || state.getExtensions().logicOpANGLE;
 
         case GL_FETCH_PER_SAMPLE_ARM:
-            return context->getExtensions().shaderFramebufferFetchARM;
+            return state.getExtensions().shaderFramebufferFetchARM;
 
         case GL_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM:
-            return queryOnly && context->getExtensions().shaderFramebufferFetchARM;
+            return queryOnly && state.getExtensions().shaderFramebufferFetchARM;
 
         default:
             break;
     }
 
     // GLES1 emulation: GLES1-specific caps after this point
-    if (context->getClientVersion().major != 1)
+    if (state.getClientVersion().major != 1)
     {
         return false;
     }
@@ -722,16 +721,15 @@ bool ValidCap(const Context *context, GLenum cap, bool queryOnly)
         case GL_FOG:
         case GL_POINT_SMOOTH:
         case GL_LINE_SMOOTH:
-            return context->getClientVersion() < Version(2, 0);
+            return state.getClientVersion() < Version(2, 0);
         case GL_POINT_SIZE_ARRAY_OES:
-            return context->getClientVersion() < Version(2, 0) &&
-                   context->getExtensions().pointSizeArrayOES;
+            return state.getClientVersion() < Version(2, 0) &&
+                   state.getExtensions().pointSizeArrayOES;
         case GL_TEXTURE_CUBE_MAP:
-            return context->getClientVersion() < Version(2, 0) &&
-                   context->getExtensions().textureCubeMapOES;
+            return state.getClientVersion() < Version(2, 0) &&
+                   state.getExtensions().textureCubeMapOES;
         case GL_POINT_SPRITE_OES:
-            return context->getClientVersion() < Version(2, 0) &&
-                   context->getExtensions().pointSpriteOES;
+            return state.getClientVersion() < Version(2, 0) && state.getExtensions().pointSpriteOES;
         default:
             return false;
     }
@@ -811,7 +809,10 @@ bool ValidateWebGLNameLength(const Context *context, angle::EntryPoint entryPoin
     return true;
 }
 
-bool ValidateSrcBlendFunc(const Context *context, angle::EntryPoint entryPoint, GLenum val)
+bool ValidateSrcBlendFunc(const PrivateState &state,
+                          ErrorSet *errors,
+                          angle::EntryPoint entryPoint,
+                          GLenum val)
 {
     switch (val)
     {
@@ -838,39 +839,43 @@ bool ValidateSrcBlendFunc(const Context *context, angle::EntryPoint entryPoint,
         case GL_SRC1_ALPHA_EXT:
         case GL_ONE_MINUS_SRC1_COLOR_EXT:
         case GL_ONE_MINUS_SRC1_ALPHA_EXT:
-            if (!context->getExtensions().blendFuncExtendedEXT)
+            if (!state.getExtensions().blendFuncExtendedEXT)
             {
                 break;
             }
-            if (context->getState().getPixelLocalStorageActivePlanes() != 0)
+            if (state.getPixelLocalStorageActivePlanes() != 0)
             {
                 // INVALID_OPERATION is generated by BlendFunci*() and BlendFuncSeparatei*() if
                 // <srcRGB>, <dstRGB>, <srcAlpha>, or <dstAlpha> is a blend function requiring the
                 // secondary color input, as specified in EXT_blend_func_extended (SRC1_COLOR_EXT,
                 // ONE_MINUS_SRC1_COLOR_EXT, SRC1_ALPHA_EXT, ONE_MINUS_SRC1_ALPHA_EXT).
-                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSSecondaryBlendNotSupported);
+                errors->validationError(entryPoint, GL_INVALID_OPERATION,
+                                        kPLSSecondaryBlendNotSupported);
                 return false;
             }
             return true;
     }
 
-    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBlendFunction);
+    errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBlendFunction);
     return false;
 }
 
-bool ValidateDstBlendFunc(const Context *context, angle::EntryPoint entryPoint, GLenum val)
+bool ValidateDstBlendFunc(const PrivateState &state,
+                          ErrorSet *errors,
+                          angle::EntryPoint entryPoint,
+                          GLenum val)
 {
     if (val == GL_SRC_ALPHA_SATURATE)
     {
         // Unextended ES2 does not allow GL_SRC_ALPHA_SATURATE as a dst blend func.
-        if (context->getClientMajorVersion() < 3 && !context->getExtensions().blendFuncExtendedEXT)
+        if (state.getClientMajorVersion() < 3 && !state.getExtensions().blendFuncExtendedEXT)
         {
-            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBlendFunction);
+            errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBlendFunction);
             return false;
         }
     }
 
-    return ValidateSrcBlendFunc(context, entryPoint, val);
+    return ValidateSrcBlendFunc(state, errors, entryPoint, val);
 }
 
 bool ValidateES2TexImageParameters(const Context *context,
@@ -3137,13 +3142,14 @@ bool ValidateBindUniformLocationCHROMIUM(const Context *context,
     return true;
 }
 
-bool ValidateCoverageModulationCHROMIUM(const Context *context,
+bool ValidateCoverageModulationCHROMIUM(const PrivateState &state,
+                                        ErrorSet *errors,
                                         angle::EntryPoint entryPoint,
                                         GLenum components)
 {
-    if (!context->getExtensions().framebufferMixedSamplesCHROMIUM)
+    if (!state.getExtensions().framebufferMixedSamplesCHROMIUM)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     switch (components)
@@ -3154,7 +3160,7 @@ bool ValidateCoverageModulationCHROMIUM(const Context *context,
         case GL_NONE:
             break;
         default:
-            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidCoverageComponents);
+            errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidCoverageComponents);
             return false;
     }
 
@@ -3704,18 +3710,21 @@ bool ValidateDisableExtensionANGLE(const Context *context,
     return true;
 }
 
-bool ValidateActiveTexture(const Context *context, angle::EntryPoint entryPoint, GLenum texture)
+bool ValidateActiveTexture(const PrivateState &state,
+                           ErrorSet *errors,
+                           angle::EntryPoint entryPoint,
+                           GLenum texture)
 {
-    if (context->getClientMajorVersion() < 2)
+    if (state.getClientMajorVersion() < 2)
     {
-        return ValidateMultitextureUnit(context, entryPoint, texture);
+        return ValidateMultitextureUnit(state, errors, entryPoint, texture);
     }
 
     if (texture < GL_TEXTURE0 ||
         texture >
-            GL_TEXTURE0 + static_cast<GLuint>(context->getCaps().maxCombinedTextureImageUnits) - 1)
+            GL_TEXTURE0 + static_cast<GLuint>(state.getCaps().maxCombinedTextureImageUnits) - 1)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidCombinedImageUnit);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidCombinedImageUnit);
         return false;
     }
 
@@ -3804,7 +3813,7 @@ bool ValidateBindRenderbuffer(const Context *context,
     return ValidateBindRenderbufferBase(context, entryPoint, target, renderbuffer);
 }
 
-static bool ValidBlendEquationMode(const Context *context, GLenum mode)
+static bool ValidBlendEquationMode(const PrivateState &state, ErrorSet *errors, GLenum mode)
 {
     switch (mode)
     {
@@ -3815,14 +3824,14 @@ static bool ValidBlendEquationMode(const Context *context, GLenum mode)
 
         case GL_MIN:
         case GL_MAX:
-            return context->getClientVersion() >= ES_3_0 || context->getExtensions().blendMinmaxEXT;
+            return state.getClientVersion() >= ES_3_0 || state.getExtensions().blendMinmaxEXT;
 
         default:
             return false;
     }
 }
 
-static bool ValidAdvancedBlendEquationMode(const Context *context, GLenum mode)
+static bool ValidAdvancedBlendEquationMode(const PrivateState &state, GLenum mode)
 {
     switch (mode)
     {
@@ -3841,15 +3850,16 @@ static bool ValidAdvancedBlendEquationMode(const Context *context, GLenum mode)
         case GL_HSL_SATURATION_KHR:
         case GL_HSL_COLOR_KHR:
         case GL_HSL_LUMINOSITY_KHR:
-            return context->getClientVersion() >= ES_3_2 ||
-                   context->getExtensions().blendEquationAdvancedKHR;
+            return state.getClientVersion() >= ES_3_2 ||
+                   state.getExtensions().blendEquationAdvancedKHR;
 
         default:
             return false;
     }
 }
 
-bool ValidateBlendColor(const Context *context,
+bool ValidateBlendColor(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLfloat red,
                         GLfloat green,
@@ -3859,74 +3869,80 @@ bool ValidateBlendColor(const Context *context,
     return true;
 }
 
-bool ValidateBlendEquation(const Context *context, angle::EntryPoint entryPoint, GLenum mode)
+bool ValidateBlendEquation(const PrivateState &state,
+                           ErrorSet *errors,
+                           angle::EntryPoint entryPoint,
+                           GLenum mode)
 {
-    if (ValidBlendEquationMode(context, mode))
+    if (ValidBlendEquationMode(state, errors, mode))
     {
         return true;
     }
 
-    if (ValidAdvancedBlendEquationMode(context, mode))
+    if (ValidAdvancedBlendEquationMode(state, mode))
     {
-        if (context->getState().getPixelLocalStorageActivePlanes() != 0)
+        if (state.getPixelLocalStorageActivePlanes() != 0)
         {
             // INVALID_OPERATION is generated by BlendEquationi*() if <mode> is one of the advanced
             // blend equations defined in KHR_blend_equation_advanced.
-            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSAdvancedBlendNotSupported);
+            errors->validationError(entryPoint, GL_INVALID_OPERATION,
+                                    kPLSAdvancedBlendNotSupported);
             return false;
         }
         return true;
     }
 
-    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBlendEquation);
+    errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBlendEquation);
     return false;
 }
 
-bool ValidateBlendEquationSeparate(const Context *context,
+bool ValidateBlendEquationSeparate(const PrivateState &state,
+                                   ErrorSet *errors,
                                    angle::EntryPoint entryPoint,
                                    GLenum modeRGB,
                                    GLenum modeAlpha)
 {
-    if (!ValidBlendEquationMode(context, modeRGB))
+    if (!ValidBlendEquationMode(state, errors, modeRGB))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBlendEquation);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBlendEquation);
         return false;
     }
 
-    if (!ValidBlendEquationMode(context, modeAlpha))
+    if (!ValidBlendEquationMode(state, errors, modeAlpha))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBlendEquation);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBlendEquation);
         return false;
     }
 
     return true;
 }
 
-bool ValidateBlendFunc(const Context *context,
+bool ValidateBlendFunc(const PrivateState &state,
+                       ErrorSet *errors,
                        angle::EntryPoint entryPoint,
                        GLenum sfactor,
                        GLenum dfactor)
 {
-    return ValidateBlendFuncSeparate(context, entryPoint, sfactor, dfactor, sfactor, dfactor);
+    return ValidateBlendFuncSeparate(state, errors, entryPoint, sfactor, dfactor, sfactor, dfactor);
 }
 
-bool ValidateBlendFuncSeparate(const Context *context,
+bool ValidateBlendFuncSeparate(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLenum srcRGB,
                                GLenum dstRGB,
                                GLenum srcAlpha,
                                GLenum dstAlpha)
 {
-    if (!ValidateSrcBlendFunc(context, entryPoint, srcRGB) ||
-        !ValidateDstBlendFunc(context, entryPoint, dstRGB) ||
-        !ValidateSrcBlendFunc(context, entryPoint, srcAlpha) ||
-        !ValidateDstBlendFunc(context, entryPoint, dstAlpha))
+    if (!ValidateSrcBlendFunc(state, errors, entryPoint, srcRGB) ||
+        !ValidateDstBlendFunc(state, errors, entryPoint, dstRGB) ||
+        !ValidateSrcBlendFunc(state, errors, entryPoint, srcAlpha) ||
+        !ValidateDstBlendFunc(state, errors, entryPoint, dstAlpha))
     {
         return false;
     }
 
-    if (context->getLimitations().noSimultaneousConstantColorAndAlphaBlendFunc ||
-        context->isWebGL())
+    if (state.getLimitations().noSimultaneousConstantColorAndAlphaBlendFunc || state.isWebGL())
     {
         bool constantColorUsed =
             (srcRGB == GL_CONSTANT_COLOR || srcRGB == GL_ONE_MINUS_CONSTANT_COLOR ||
@@ -3938,14 +3954,15 @@ bool ValidateBlendFuncSeparate(const Context *context,
 
         if (constantColorUsed && constantAlphaUsed)
         {
-            if (context->isWebGL())
+            if (state.isWebGL())
             {
-                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidConstantColor);
+                errors->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidConstantColor);
                 return false;
             }
 
             WARN() << kConstantColorAlphaLimitation;
-            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kConstantColorAlphaLimitation);
+            errors->validationError(entryPoint, GL_INVALID_OPERATION,
+                                    kConstantColorAlphaLimitation);
             return false;
         }
     }
@@ -3988,25 +4005,29 @@ bool ValidateGetString(const Context *context, angle::EntryPoint entryPoint, GLe
     return true;
 }
 
-bool ValidateLineWidth(const Context *context, angle::EntryPoint entryPoint, GLfloat width)
+bool ValidateLineWidth(const PrivateState &state,
+                       ErrorSet *errors,
+                       angle::EntryPoint entryPoint,
+                       GLfloat width)
 {
     if (width <= 0.0f || isNaN(width))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidWidth);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kInvalidWidth);
         return false;
     }
 
     return true;
 }
 
-bool ValidateDepthRangef(const Context *context,
+bool ValidateDepthRangef(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLfloat zNear,
                          GLfloat zFar)
 {
-    if (context->isWebGL() && zNear > zFar)
+    if (state.isWebGL() && zNear > zFar)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidDepthRange);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidDepthRange);
         return false;
     }
 
@@ -4078,7 +4099,8 @@ bool ValidateCheckFramebufferStatus(const Context *context,
     return true;
 }
 
-bool ValidateClearColor(const Context *context,
+bool ValidateClearColor(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLfloat red,
                         GLfloat green,
@@ -4088,17 +4110,24 @@ bool ValidateClearColor(const Context *context,
     return true;
 }
 
-bool ValidateClearDepthf(const Context *context, angle::EntryPoint entryPoint, GLfloat depth)
+bool ValidateClearDepthf(const PrivateState &state,
+                         ErrorSet *errors,
+                         angle::EntryPoint entryPoint,
+                         GLfloat depth)
 {
     return true;
 }
 
-bool ValidateClearStencil(const Context *context, angle::EntryPoint entryPoint, GLint s)
+bool ValidateClearStencil(const PrivateState &state,
+                          ErrorSet *errors,
+                          angle::EntryPoint entryPoint,
+                          GLint s)
 {
     return true;
 }
 
-bool ValidateColorMask(const Context *context,
+bool ValidateColorMask(const PrivateState &state,
+                       ErrorSet *errors,
                        angle::EntryPoint entryPoint,
                        GLboolean red,
                        GLboolean green,
@@ -4120,7 +4149,10 @@ bool ValidateCreateProgram(const Context *context, angle::EntryPoint entryPoint)
     return true;
 }
 
-bool ValidateCullFace(const Context *context, angle::EntryPoint entryPoint, CullFaceMode mode)
+bool ValidateCullFace(const PrivateState &state,
+                      ErrorSet *errors,
+                      angle::EntryPoint entryPoint,
+                      CullFaceMode mode)
 {
     switch (mode)
     {
@@ -4130,7 +4162,7 @@ bool ValidateCullFace(const Context *context, angle::EntryPoint entryPoint, Cull
             break;
 
         default:
-            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidCullMode);
+            errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidCullMode);
             return false;
     }
 
@@ -4189,7 +4221,10 @@ bool ValidateDeleteShader(const Context *context,
     return true;
 }
 
-bool ValidateDepthFunc(const Context *context, angle::EntryPoint entryPoint, GLenum func)
+bool ValidateDepthFunc(const PrivateState &state,
+                       ErrorSet *errors,
+                       angle::EntryPoint entryPoint,
+                       GLenum func)
 {
     switch (func)
     {
@@ -4204,14 +4239,17 @@ bool ValidateDepthFunc(const Context *context, angle::EntryPoint entryPoint, GLe
             break;
 
         default:
-            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, func);
+            errors->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, func);
             return false;
     }
 
     return true;
 }
 
-bool ValidateDepthMask(const Context *context, angle::EntryPoint entryPoint, GLboolean flag)
+bool ValidateDepthMask(const PrivateState &state,
+                       ErrorSet *errors,
+                       angle::EntryPoint entryPoint,
+                       GLboolean flag)
 {
     return true;
 }
@@ -4279,7 +4317,10 @@ bool ValidateFlush(const Context *context, angle::EntryPoint entryPoint)
     return true;
 }
 
-bool ValidateFrontFace(const Context *context, angle::EntryPoint entryPoint, GLenum mode)
+bool ValidateFrontFace(const PrivateState &state,
+                       ErrorSet *errors,
+                       angle::EntryPoint entryPoint,
+                       GLenum mode)
 {
     switch (mode)
     {
@@ -4287,7 +4328,7 @@ bool ValidateFrontFace(const Context *context, angle::EntryPoint entryPoint, GLe
         case GL_CCW:
             break;
         default:
-            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, mode);
+            errors->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, mode);
             return false;
     }
 
@@ -4600,7 +4641,11 @@ bool ValidateGetUniformLocation(const Context *context,
     return true;
 }
 
-bool ValidateHint(const Context *context, angle::EntryPoint entryPoint, GLenum target, GLenum mode)
+bool ValidateHint(const PrivateState &state,
+                  ErrorSet *errors,
+                  angle::EntryPoint entryPoint,
+                  GLenum target,
+                  GLenum mode)
 {
     switch (mode)
     {
@@ -4610,7 +4655,7 @@ bool ValidateHint(const Context *context, angle::EntryPoint entryPoint, GLenum t
             break;
 
         default:
-            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, mode);
+            errors->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, mode);
             return false;
     }
 
@@ -4620,18 +4665,17 @@ bool ValidateHint(const Context *context, angle::EntryPoint entryPoint, GLenum t
             break;
 
         case GL_TEXTURE_FILTERING_HINT_CHROMIUM:
-            if (!context->getExtensions().textureFilteringHintCHROMIUM)
+            if (!state.getExtensions().textureFilteringHintCHROMIUM)
             {
-                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, target);
+                errors->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
                 return false;
             }
             break;
 
         case GL_FRAGMENT_SHADER_DERIVATIVE_HINT:
-            if (context->getClientVersion() < ES_3_0 &&
-                !context->getExtensions().standardDerivativesOES)
+            if (state.getClientVersion() < ES_3_0 && !state.getExtensions().standardDerivativesOES)
             {
-                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, target);
+                errors->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
                 return false;
             }
             break;
@@ -4640,15 +4684,15 @@ bool ValidateHint(const Context *context, angle::EntryPoint entryPoint, GLenum t
         case GL_POINT_SMOOTH_HINT:
         case GL_LINE_SMOOTH_HINT:
         case GL_FOG_HINT:
-            if (context->getClientMajorVersion() >= 2)
+            if (state.getClientMajorVersion() >= 2)
             {
-                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, target);
+                errors->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
                 return false;
             }
             break;
 
         default:
-            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, target);
+            errors->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
             return false;
     }
 
@@ -4691,26 +4735,27 @@ bool ValidateIsTexture(const Context *context, angle::EntryPoint entryPoint, Tex
     return true;
 }
 
-bool ValidatePixelStorei(const Context *context,
+bool ValidatePixelStorei(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLenum pname,
                          GLint param)
 {
-    if (context->getClientMajorVersion() < 3)
+    if (state.getClientMajorVersion() < 3)
     {
         switch (pname)
         {
             case GL_UNPACK_IMAGE_HEIGHT:
             case GL_UNPACK_SKIP_IMAGES:
-                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
+                errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
                 return false;
 
             case GL_UNPACK_ROW_LENGTH:
             case GL_UNPACK_SKIP_ROWS:
             case GL_UNPACK_SKIP_PIXELS:
-                if (!context->getExtensions().unpackSubimageEXT)
+                if (!state.getExtensions().unpackSubimageEXT)
                 {
-                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
+                    errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
                     return false;
                 }
                 break;
@@ -4718,9 +4763,9 @@ bool ValidatePixelStorei(const Context *context,
             case GL_PACK_ROW_LENGTH:
             case GL_PACK_SKIP_ROWS:
             case GL_PACK_SKIP_PIXELS:
-                if (!context->getExtensions().packSubimageNV)
+                if (!state.getExtensions().packSubimageNV)
                 {
-                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
+                    errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
                     return false;
                 }
                 break;
@@ -4729,7 +4774,7 @@ bool ValidatePixelStorei(const Context *context,
 
     if (param < 0)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeParam);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kNegativeParam);
         return false;
     }
 
@@ -4738,7 +4783,7 @@ bool ValidatePixelStorei(const Context *context,
         case GL_UNPACK_ALIGNMENT:
             if (param != 1 && param != 2 && param != 4 && param != 8)
             {
-                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidUnpackAlignment);
+                errors->validationError(entryPoint, GL_INVALID_VALUE, kInvalidUnpackAlignment);
                 return false;
             }
             break;
@@ -4746,15 +4791,15 @@ bool ValidatePixelStorei(const Context *context,
         case GL_PACK_ALIGNMENT:
             if (param != 1 && param != 2 && param != 4 && param != 8)
             {
-                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidUnpackAlignment);
+                errors->validationError(entryPoint, GL_INVALID_VALUE, kInvalidUnpackAlignment);
                 return false;
             }
             break;
 
         case GL_PACK_REVERSE_ROW_ORDER_ANGLE:
-            if (!context->getExtensions().packReverseRowOrderANGLE)
+            if (!state.getExtensions().packReverseRowOrderANGLE)
             {
-                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
+                errors->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
             }
             break;
 
@@ -4769,14 +4814,15 @@ bool ValidatePixelStorei(const Context *context,
             break;
 
         default:
-            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
+            errors->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
 
     return true;
 }
 
-bool ValidatePolygonOffset(const Context *context,
+bool ValidatePolygonOffset(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLfloat factor,
                            GLfloat units)
@@ -4789,7 +4835,8 @@ bool ValidateReleaseShaderCompiler(const Context *context, angle::EntryPoint ent
     return true;
 }
 
-bool ValidateSampleCoverage(const Context *context,
+bool ValidateSampleCoverage(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLfloat value,
                             GLboolean invert)
@@ -4797,7 +4844,8 @@ bool ValidateSampleCoverage(const Context *context,
     return true;
 }
 
-bool ValidateScissor(const Context *context,
+bool ValidateScissor(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      GLint x,
                      GLint y,
@@ -4806,7 +4854,7 @@ bool ValidateScissor(const Context *context,
 {
     if (width < 0 || height < 0)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeSize);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize);
         return false;
     }
 
@@ -4901,7 +4949,8 @@ bool ValidateShaderSource(const Context *context,
     return true;
 }
 
-bool ValidateStencilFunc(const Context *context,
+bool ValidateStencilFunc(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLenum func,
                          GLint ref,
@@ -4909,14 +4958,15 @@ bool ValidateStencilFunc(const Context *context,
 {
     if (!IsValidStencilFunc(func))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidStencil);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil);
         return false;
     }
 
     return true;
 }
 
-bool ValidateStencilFuncSeparate(const Context *context,
+bool ValidateStencilFuncSeparate(const PrivateState &state,
+                                 ErrorSet *errors,
                                  angle::EntryPoint entryPoint,
                                  GLenum face,
                                  GLenum func,
@@ -4925,39 +4975,44 @@ bool ValidateStencilFuncSeparate(const Context *context,
 {
     if (!IsValidStencilFace(face))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidStencil);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil);
         return false;
     }
 
     if (!IsValidStencilFunc(func))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidStencil);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil);
         return false;
     }
 
     return true;
 }
 
-bool ValidateStencilMask(const Context *context, angle::EntryPoint entryPoint, GLuint mask)
+bool ValidateStencilMask(const PrivateState &state,
+                         ErrorSet *errors,
+                         angle::EntryPoint entryPoint,
+                         GLuint mask)
 {
     return true;
 }
 
-bool ValidateStencilMaskSeparate(const Context *context,
+bool ValidateStencilMaskSeparate(const PrivateState &state,
+                                 ErrorSet *errors,
                                  angle::EntryPoint entryPoint,
                                  GLenum face,
                                  GLuint mask)
 {
     if (!IsValidStencilFace(face))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidStencil);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil);
         return false;
     }
 
     return true;
 }
 
-bool ValidateStencilOp(const Context *context,
+bool ValidateStencilOp(const PrivateState &state,
+                       ErrorSet *errors,
                        angle::EntryPoint entryPoint,
                        GLenum fail,
                        GLenum zfail,
@@ -4965,26 +5020,27 @@ bool ValidateStencilOp(const Context *context,
 {
     if (!IsValidStencilOp(fail))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidStencil);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil);
         return false;
     }
 
     if (!IsValidStencilOp(zfail))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidStencil);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil);
         return false;
     }
 
     if (!IsValidStencilOp(zpass))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidStencil);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil);
         return false;
     }
 
     return true;
 }
 
-bool ValidateStencilOpSeparate(const Context *context,
+bool ValidateStencilOpSeparate(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLenum face,
                                GLenum fail,
@@ -4993,11 +5049,11 @@ bool ValidateStencilOpSeparate(const Context *context,
 {
     if (!IsValidStencilFace(face))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidStencil);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil);
         return false;
     }
 
-    return ValidateStencilOp(context, entryPoint, fail, zfail, zpass);
+    return ValidateStencilOp(state, errors, entryPoint, fail, zfail, zpass);
 }
 
 bool ValidateUniform1f(const Context *context,
@@ -5174,58 +5230,65 @@ bool ValidateValidateProgram(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib1f(const Context *context,
+bool ValidateVertexAttrib1f(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLfloat x)
 {
-    return ValidateVertexAttribIndex(context, entryPoint, index);
+    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
 }
 
-bool ValidateVertexAttrib1fv(const Context *context,
+bool ValidateVertexAttrib1fv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLfloat *values)
 {
-    return ValidateVertexAttribIndex(context, entryPoint, index);
+    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
 }
 
-bool ValidateVertexAttrib2f(const Context *context,
+bool ValidateVertexAttrib2f(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLfloat x,
                             GLfloat y)
 {
-    return ValidateVertexAttribIndex(context, entryPoint, index);
+    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
 }
 
-bool ValidateVertexAttrib2fv(const Context *context,
+bool ValidateVertexAttrib2fv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLfloat *values)
 {
-    return ValidateVertexAttribIndex(context, entryPoint, index);
+    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
 }
 
-bool ValidateVertexAttrib3f(const Context *context,
+bool ValidateVertexAttrib3f(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLfloat x,
                             GLfloat y,
                             GLfloat z)
 {
-    return ValidateVertexAttribIndex(context, entryPoint, index);
+    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
 }
 
-bool ValidateVertexAttrib3fv(const Context *context,
+bool ValidateVertexAttrib3fv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLfloat *values)
 {
-    return ValidateVertexAttribIndex(context, entryPoint, index);
+    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
 }
 
-bool ValidateVertexAttrib4f(const Context *context,
+bool ValidateVertexAttrib4f(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLfloat x,
@@ -5233,18 +5296,20 @@ bool ValidateVertexAttrib4f(const Context *context,
                             GLfloat z,
                             GLfloat w)
 {
-    return ValidateVertexAttribIndex(context, entryPoint, index);
+    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
 }
 
-bool ValidateVertexAttrib4fv(const Context *context,
+bool ValidateVertexAttrib4fv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLfloat *values)
 {
-    return ValidateVertexAttribIndex(context, entryPoint, index);
+    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
 }
 
-bool ValidateViewport(const Context *context,
+bool ValidateViewport(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       GLint x,
                       GLint y,
@@ -5253,7 +5318,7 @@ bool ValidateViewport(const Context *context,
 {
     if (width < 0 || height < 0)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kViewportNegativeSize);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kViewportNegativeSize);
         return false;
     }
 
@@ -5371,19 +5436,22 @@ bool ValidateDeleteTextures(const Context *context,
     return ValidateGenOrDelete(context, entryPoint, n);
 }
 
-bool ValidateDisable(const Context *context, angle::EntryPoint entryPoint, GLenum cap)
+bool ValidateDisable(const PrivateState &state,
+                     ErrorSet *errors,
+                     angle::EntryPoint entryPoint,
+                     GLenum cap)
 {
-    if (!ValidCap(context, cap, false))
+    if (!ValidCap(state, errors, cap, false))
     {
-        ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, cap);
+        errors->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, cap);
         return false;
     }
 
-    if (context->getState().getPixelLocalStorageActivePlanes() != 0)
+    if (state.getPixelLocalStorageActivePlanes() != 0)
     {
         if (IsCapBannedWithActivePLS(cap))
         {
-            ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kPLSCapNotAllowed, cap);
+            errors->validationErrorF(entryPoint, GL_INVALID_OPERATION, kPLSCapNotAllowed, cap);
             return false;
         }
     }
@@ -5391,18 +5459,21 @@ bool ValidateDisable(const Context *context, angle::EntryPoint entryPoint, GLenu
     return true;
 }
 
-bool ValidateEnable(const Context *context, angle::EntryPoint entryPoint, GLenum cap)
+bool ValidateEnable(const PrivateState &state,
+                    ErrorSet *errors,
+                    angle::EntryPoint entryPoint,
+                    GLenum cap)
 {
-    if (!ValidCap(context, cap, false))
+    if (!ValidCap(state, errors, cap, false))
     {
-        ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, cap);
+        errors->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, cap);
         return false;
     }
 
-    if (context->getLimitations().noSampleAlphaToCoverageSupport &&
-        cap == GL_SAMPLE_ALPHA_TO_COVERAGE)
+    if (state.getLimitations().noSampleAlphaToCoverageSupport && cap == GL_SAMPLE_ALPHA_TO_COVERAGE)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNoSampleAlphaToCoveragesLimitation);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION,
+                                kNoSampleAlphaToCoveragesLimitation);
 
         // We also output an error message to the debugger window if tracing is active, so that
         // developers can see the error message.
@@ -5410,11 +5481,11 @@ bool ValidateEnable(const Context *context, angle::EntryPoint entryPoint, GLenum
         return false;
     }
 
-    if (context->getState().getPixelLocalStorageActivePlanes() != 0)
+    if (state.getPixelLocalStorageActivePlanes() != 0)
     {
         if (IsCapBannedWithActivePLS(cap))
         {
-            ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kPLSCapNotAllowed, cap);
+            errors->validationErrorF(entryPoint, GL_INVALID_OPERATION, kPLSCapNotAllowed, cap);
             return false;
         }
     }
@@ -5795,11 +5866,14 @@ bool ValidateGetVertexAttribPointerv(const Context *context,
     return ValidateGetVertexAttribBase(context, entryPoint, index, pname, nullptr, true, false);
 }
 
-bool ValidateIsEnabled(const Context *context, angle::EntryPoint entryPoint, GLenum cap)
+bool ValidateIsEnabled(const PrivateState &state,
+                       ErrorSet *errors,
+                       angle::EntryPoint entryPoint,
+                       GLenum cap)
 {
-    if (!ValidCap(context, cap, true))
+    if (!ValidCap(state, errors, cap, true))
     {
-        ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, cap);
+        errors->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, cap);
         return false;
     }
 
diff --git a/src/libANGLE/validationES2_autogen.h b/src/libANGLE/validationES2_autogen.h
index 335139fe7..01535cd53 100644
--- a/src/libANGLE/validationES2_autogen.h
+++ b/src/libANGLE/validationES2_autogen.h
@@ -17,8 +17,13 @@
 namespace gl
 {
 class Context;
+class PrivateState;
+class ErrorSet;
 
-bool ValidateActiveTexture(const Context *context, angle::EntryPoint entryPoint, GLenum texture);
+bool ValidateActiveTexture(const PrivateState &state,
+                           ErrorSet *errors,
+                           angle::EntryPoint entryPoint,
+                           GLenum texture);
 bool ValidateAttachShader(const Context *context,
                           angle::EntryPoint entryPoint,
                           ShaderProgramID programPacked,
@@ -44,22 +49,29 @@ bool ValidateBindTexture(const Context *context,
                          angle::EntryPoint entryPoint,
                          TextureType targetPacked,
                          TextureID texturePacked);
-bool ValidateBlendColor(const Context *context,
+bool ValidateBlendColor(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLfloat red,
                         GLfloat green,
                         GLfloat blue,
                         GLfloat alpha);
-bool ValidateBlendEquation(const Context *context, angle::EntryPoint entryPoint, GLenum mode);
-bool ValidateBlendEquationSeparate(const Context *context,
+bool ValidateBlendEquation(const PrivateState &state,
+                           ErrorSet *errors,
+                           angle::EntryPoint entryPoint,
+                           GLenum mode);
+bool ValidateBlendEquationSeparate(const PrivateState &state,
+                                   ErrorSet *errors,
                                    angle::EntryPoint entryPoint,
                                    GLenum modeRGB,
                                    GLenum modeAlpha);
-bool ValidateBlendFunc(const Context *context,
+bool ValidateBlendFunc(const PrivateState &state,
+                       ErrorSet *errors,
                        angle::EntryPoint entryPoint,
                        GLenum sfactor,
                        GLenum dfactor);
-bool ValidateBlendFuncSeparate(const Context *context,
+bool ValidateBlendFuncSeparate(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLenum sfactorRGB,
                                GLenum dfactorRGB,
@@ -81,15 +93,23 @@ bool ValidateCheckFramebufferStatus(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     GLenum target);
 bool ValidateClear(const Context *context, angle::EntryPoint entryPoint, GLbitfield mask);
-bool ValidateClearColor(const Context *context,
+bool ValidateClearColor(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLfloat red,
                         GLfloat green,
                         GLfloat blue,
                         GLfloat alpha);
-bool ValidateClearDepthf(const Context *context, angle::EntryPoint entryPoint, GLfloat d);
-bool ValidateClearStencil(const Context *context, angle::EntryPoint entryPoint, GLint s);
-bool ValidateColorMask(const Context *context,
+bool ValidateClearDepthf(const PrivateState &state,
+                         ErrorSet *errors,
+                         angle::EntryPoint entryPoint,
+                         GLfloat d);
+bool ValidateClearStencil(const PrivateState &state,
+                          ErrorSet *errors,
+                          angle::EntryPoint entryPoint,
+                          GLint s);
+bool ValidateColorMask(const PrivateState &state,
+                       ErrorSet *errors,
                        angle::EntryPoint entryPoint,
                        GLboolean red,
                        GLboolean green,
@@ -143,7 +163,8 @@ bool ValidateCreateProgram(const Context *context, angle::EntryPoint entryPoint)
 bool ValidateCreateShader(const Context *context,
                           angle::EntryPoint entryPoint,
                           ShaderType typePacked);
-bool ValidateCullFace(const Context *context,
+bool ValidateCullFace(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       CullFaceMode modePacked);
 bool ValidateDeleteBuffers(const Context *context,
@@ -168,9 +189,16 @@ bool ValidateDeleteTextures(const Context *context,
                             angle::EntryPoint entryPoint,
                             GLsizei n,
                             const TextureID *texturesPacked);
-bool ValidateDepthFunc(const Context *context, angle::EntryPoint entryPoint, GLenum func);
-bool ValidateDepthMask(const Context *context, angle::EntryPoint entryPoint, GLboolean flag);
-bool ValidateDepthRangef(const Context *context,
+bool ValidateDepthFunc(const PrivateState &state,
+                       ErrorSet *errors,
+                       angle::EntryPoint entryPoint,
+                       GLenum func);
+bool ValidateDepthMask(const PrivateState &state,
+                       ErrorSet *errors,
+                       angle::EntryPoint entryPoint,
+                       GLboolean flag);
+bool ValidateDepthRangef(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLfloat n,
                          GLfloat f);
@@ -178,7 +206,10 @@ bool ValidateDetachShader(const Context *context,
                           angle::EntryPoint entryPoint,
                           ShaderProgramID programPacked,
                           ShaderProgramID shaderPacked);
-bool ValidateDisable(const Context *context, angle::EntryPoint entryPoint, GLenum cap);
+bool ValidateDisable(const PrivateState &state,
+                     ErrorSet *errors,
+                     angle::EntryPoint entryPoint,
+                     GLenum cap);
 bool ValidateDisableVertexAttribArray(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       GLuint index);
@@ -193,7 +224,10 @@ bool ValidateDrawElements(const Context *context,
                           GLsizei count,
                           DrawElementsType typePacked,
                           const void *indices);
-bool ValidateEnable(const Context *context, angle::EntryPoint entryPoint, GLenum cap);
+bool ValidateEnable(const PrivateState &state,
+                    ErrorSet *errors,
+                    angle::EntryPoint entryPoint,
+                    GLenum cap);
 bool ValidateEnableVertexAttribArray(const Context *context,
                                      angle::EntryPoint entryPoint,
                                      GLuint index);
@@ -212,7 +246,10 @@ bool ValidateFramebufferTexture2D(const Context *context,
                                   TextureTarget textargetPacked,
                                   TextureID texturePacked,
                                   GLint level);
-bool ValidateFrontFace(const Context *context, angle::EntryPoint entryPoint, GLenum mode);
+bool ValidateFrontFace(const PrivateState &state,
+                       ErrorSet *errors,
+                       angle::EntryPoint entryPoint,
+                       GLenum mode);
 bool ValidateGenBuffers(const Context *context,
                         angle::EntryPoint entryPoint,
                         GLsizei n,
@@ -363,9 +400,16 @@ bool ValidateGetVertexAttribiv(const Context *context,
                                GLuint index,
                                GLenum pname,
                                const GLint *params);
-bool ValidateHint(const Context *context, angle::EntryPoint entryPoint, GLenum target, GLenum mode);
+bool ValidateHint(const PrivateState &state,
+                  ErrorSet *errors,
+                  angle::EntryPoint entryPoint,
+                  GLenum target,
+                  GLenum mode);
 bool ValidateIsBuffer(const Context *context, angle::EntryPoint entryPoint, BufferID bufferPacked);
-bool ValidateIsEnabled(const Context *context, angle::EntryPoint entryPoint, GLenum cap);
+bool ValidateIsEnabled(const PrivateState &state,
+                       ErrorSet *errors,
+                       angle::EntryPoint entryPoint,
+                       GLenum cap);
 bool ValidateIsFramebuffer(const Context *context,
                            angle::EntryPoint entryPoint,
                            FramebufferID framebufferPacked);
@@ -381,15 +425,20 @@ bool ValidateIsShader(const Context *context,
 bool ValidateIsTexture(const Context *context,
                        angle::EntryPoint entryPoint,
                        TextureID texturePacked);
-bool ValidateLineWidth(const Context *context, angle::EntryPoint entryPoint, GLfloat width);
+bool ValidateLineWidth(const PrivateState &state,
+                       ErrorSet *errors,
+                       angle::EntryPoint entryPoint,
+                       GLfloat width);
 bool ValidateLinkProgram(const Context *context,
                          angle::EntryPoint entryPoint,
                          ShaderProgramID programPacked);
-bool ValidatePixelStorei(const Context *context,
+bool ValidatePixelStorei(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLenum pname,
                          GLint param);
-bool ValidatePolygonOffset(const Context *context,
+bool ValidatePolygonOffset(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLfloat factor,
                            GLfloat units);
@@ -409,11 +458,13 @@ bool ValidateRenderbufferStorage(const Context *context,
                                  GLenum internalformat,
                                  GLsizei width,
                                  GLsizei height);
-bool ValidateSampleCoverage(const Context *context,
+bool ValidateSampleCoverage(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLfloat value,
                             GLboolean invert);
-bool ValidateScissor(const Context *context,
+bool ValidateScissor(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      GLint x,
                      GLint y,
@@ -432,28 +483,36 @@ bool ValidateShaderSource(const Context *context,
                           GLsizei count,
                           const GLchar *const *string,
                           const GLint *length);
-bool ValidateStencilFunc(const Context *context,
+bool ValidateStencilFunc(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLenum func,
                          GLint ref,
                          GLuint mask);
-bool ValidateStencilFuncSeparate(const Context *context,
+bool ValidateStencilFuncSeparate(const PrivateState &state,
+                                 ErrorSet *errors,
                                  angle::EntryPoint entryPoint,
                                  GLenum face,
                                  GLenum func,
                                  GLint ref,
                                  GLuint mask);
-bool ValidateStencilMask(const Context *context, angle::EntryPoint entryPoint, GLuint mask);
-bool ValidateStencilMaskSeparate(const Context *context,
+bool ValidateStencilMask(const PrivateState &state,
+                         ErrorSet *errors,
+                         angle::EntryPoint entryPoint,
+                         GLuint mask);
+bool ValidateStencilMaskSeparate(const PrivateState &state,
+                                 ErrorSet *errors,
                                  angle::EntryPoint entryPoint,
                                  GLenum face,
                                  GLuint mask);
-bool ValidateStencilOp(const Context *context,
+bool ValidateStencilOp(const PrivateState &state,
+                       ErrorSet *errors,
                        angle::EntryPoint entryPoint,
                        GLenum fail,
                        GLenum zfail,
                        GLenum zpass);
-bool ValidateStencilOpSeparate(const Context *context,
+bool ValidateStencilOpSeparate(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLenum face,
                                GLenum sfail,
@@ -609,41 +668,49 @@ bool ValidateUseProgram(const Context *context,
 bool ValidateValidateProgram(const Context *context,
                              angle::EntryPoint entryPoint,
                              ShaderProgramID programPacked);
-bool ValidateVertexAttrib1f(const Context *context,
+bool ValidateVertexAttrib1f(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLfloat x);
-bool ValidateVertexAttrib1fv(const Context *context,
+bool ValidateVertexAttrib1fv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLfloat *v);
-bool ValidateVertexAttrib2f(const Context *context,
+bool ValidateVertexAttrib2f(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLfloat x,
                             GLfloat y);
-bool ValidateVertexAttrib2fv(const Context *context,
+bool ValidateVertexAttrib2fv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLfloat *v);
-bool ValidateVertexAttrib3f(const Context *context,
+bool ValidateVertexAttrib3f(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLfloat x,
                             GLfloat y,
                             GLfloat z);
-bool ValidateVertexAttrib3fv(const Context *context,
+bool ValidateVertexAttrib3fv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLfloat *v);
-bool ValidateVertexAttrib4f(const Context *context,
+bool ValidateVertexAttrib4f(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLfloat x,
                             GLfloat y,
                             GLfloat z,
                             GLfloat w);
-bool ValidateVertexAttrib4fv(const Context *context,
+bool ValidateVertexAttrib4fv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLfloat *v);
@@ -655,7 +722,8 @@ bool ValidateVertexAttribPointer(const Context *context,
                                  GLboolean normalized,
                                  GLsizei stride,
                                  const void *pointer);
-bool ValidateViewport(const Context *context,
+bool ValidateViewport(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       GLint x,
                       GLint y,
diff --git a/src/libANGLE/validationES3.cpp b/src/libANGLE/validationES3.cpp
index 66e576396..1df952365 100644
--- a/src/libANGLE/validationES3.cpp
+++ b/src/libANGLE/validationES3.cpp
@@ -2378,7 +2378,9 @@ bool ValidateClearBufferiv(const Context *context,
     switch (buffer)
     {
         case GL_COLOR:
-            if (!ValidateDrawBufferIndexIfActivePLS(context, entryPoint, drawbuffer, "drawbuffer"))
+            if (!ValidateDrawBufferIndexIfActivePLS(context->getPrivateState(),
+                                                    context->getMutableErrorSetForValidation(),
+                                                    entryPoint, drawbuffer, "drawbuffer"))
             {
                 return false;
             }
@@ -2430,7 +2432,9 @@ bool ValidateClearBufferuiv(const Context *context,
     switch (buffer)
     {
         case GL_COLOR:
-            if (!ValidateDrawBufferIndexIfActivePLS(context, entryPoint, drawbuffer, "drawbuffer"))
+            if (!ValidateDrawBufferIndexIfActivePLS(context->getPrivateState(),
+                                                    context->getMutableErrorSetForValidation(),
+                                                    entryPoint, drawbuffer, "drawbuffer"))
             {
                 return false;
             }
@@ -2474,7 +2478,9 @@ bool ValidateClearBufferfv(const Context *context,
     switch (buffer)
     {
         case GL_COLOR:
-            if (!ValidateDrawBufferIndexIfActivePLS(context, entryPoint, drawbuffer, "drawbuffer"))
+            if (!ValidateDrawBufferIndexIfActivePLS(context->getPrivateState(),
+                                                    context->getMutableErrorSetForValidation(),
+                                                    entryPoint, drawbuffer, "drawbuffer"))
             {
                 return false;
             }
@@ -4380,7 +4386,8 @@ bool ValidateResumeTransformFeedback(const Context *context, angle::EntryPoint e
     return true;
 }
 
-bool ValidateVertexAttribI4i(const Context *context,
+bool ValidateVertexAttribI4i(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              GLint x,
@@ -4388,16 +4395,17 @@ bool ValidateVertexAttribI4i(const Context *context,
                              GLint z,
                              GLint w)
 {
-    if (context->getClientMajorVersion() < 3)
+    if (state.getClientMajorVersion() < 3)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
-    return ValidateVertexAttribIndex(context, entryPoint, index);
+    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
 }
 
-bool ValidateVertexAttribI4ui(const Context *context,
+bool ValidateVertexAttribI4ui(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLuint x,
@@ -4405,41 +4413,43 @@ bool ValidateVertexAttribI4ui(const Context *context,
                               GLuint z,
                               GLuint w)
 {
-    if (context->getClientMajorVersion() < 3)
+    if (state.getClientMajorVersion() < 3)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
-    return ValidateVertexAttribIndex(context, entryPoint, index);
+    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
 }
 
-bool ValidateVertexAttribI4iv(const Context *context,
+bool ValidateVertexAttribI4iv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLint *v)
 {
-    if (context->getClientMajorVersion() < 3)
+    if (state.getClientMajorVersion() < 3)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
-    return ValidateVertexAttribIndex(context, entryPoint, index);
+    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
 }
 
-bool ValidateVertexAttribI4uiv(const Context *context,
+bool ValidateVertexAttribI4uiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLuint *v)
 {
-    if (context->getClientMajorVersion() < 3)
+    if (state.getClientMajorVersion() < 3)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
-    return ValidateVertexAttribIndex(context, entryPoint, index);
+    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
 }
 
 bool ValidateGetFragDataLocation(const Context *context,
@@ -4861,7 +4871,8 @@ bool ValidateVertexAttribDivisor(const Context *context,
         return false;
     }
 
-    return ValidateVertexAttribIndex(context, entryPoint, index);
+    return ValidateVertexAttribIndex(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(), entryPoint, index);
 }
 
 bool ValidateTexStorage2D(const Context *context,
@@ -5220,26 +5231,29 @@ bool ValidateGetMultisamplefvANGLE(const Context *context,
     return ValidateGetMultisamplefvBase(context, entryPoint, pname, index, val);
 }
 
-bool ValidateSampleMaskiANGLE(const Context *context,
+bool ValidateSampleMaskiANGLE(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint maskNumber,
                               GLbitfield mask)
 {
-    if (!context->getExtensions().textureMultisampleANGLE)
+    if (!state.getExtensions().textureMultisampleANGLE)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMultisampleTextureExtensionOrES31Required);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION,
+                                kMultisampleTextureExtensionOrES31Required);
         return false;
     }
 
-    return ValidateSampleMaskiBase(context, entryPoint, maskNumber, mask);
+    return ValidateSampleMaskiBase(state, errors, entryPoint, maskNumber, mask);
 }
 
-bool ValidateDrawBufferIndexIfActivePLS(const Context *context,
+bool ValidateDrawBufferIndexIfActivePLS(const PrivateState &state,
+                                        ErrorSet *errors,
                                         angle::EntryPoint entryPoint,
                                         GLuint drawBufferIdx,
                                         const char *argumentName)
 {
-    int numPLSPlanes = context->getState().getPixelLocalStorageActivePlanes();
+    int numPLSPlanes = state.getPixelLocalStorageActivePlanes();
     if (numPLSPlanes != 0)
     {
         // INVALID_OPERATION is generated ... if any of the following are true:
@@ -5248,17 +5262,17 @@ bool ValidateDrawBufferIndexIfActivePLS(const Context *context,
         //   <drawBufferIdx> >= (MAX_COMBINED_DRAW_BUFFERS_AND_PIXEL_LOCAL_STORAGE_PLANES_ANGLE -
         //                       ACTIVE_PIXEL_LOCAL_STORAGE_PLANES_ANGLE)
         //
-        if (drawBufferIdx >= context->getCaps().maxColorAttachmentsWithActivePixelLocalStorage)
+        if (drawBufferIdx >= state.getCaps().maxColorAttachmentsWithActivePixelLocalStorage)
         {
-            ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kPLSDrawBufferExceedsAttachmentLimit,
-                                    argumentName);
+            errors->validationErrorF(entryPoint, GL_INVALID_OPERATION,
+                                     kPLSDrawBufferExceedsAttachmentLimit, argumentName);
             return false;
         }
         if (drawBufferIdx >=
-            context->getCaps().maxCombinedDrawBuffersAndPixelLocalStoragePlanes - numPLSPlanes)
+            state.getCaps().maxCombinedDrawBuffersAndPixelLocalStoragePlanes - numPLSPlanes)
         {
-            ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION,
-                                    kPLSDrawBufferExceedsCombinedAttachmentLimit, argumentName);
+            errors->validationErrorF(entryPoint, GL_INVALID_OPERATION,
+                                     kPLSDrawBufferExceedsCombinedAttachmentLimit, argumentName);
             return false;
         }
     }
diff --git a/src/libANGLE/validationES3.h b/src/libANGLE/validationES3.h
index e47c676da..fff4c17b0 100644
--- a/src/libANGLE/validationES3.h
+++ b/src/libANGLE/validationES3.h
@@ -75,7 +75,8 @@ bool ValidateProgramParameteriBase(const Context *context,
 //   <drawBufferIdx> < (MAX_COMBINED_DRAW_BUFFERS_AND_PIXEL_LOCAL_STORAGE_PLANES_ANGLE -
 //                      ACTIVE_PIXEL_LOCAL_STORAGE_PLANES_ANGLE)
 //
-bool ValidateDrawBufferIndexIfActivePLS(const Context *,
+bool ValidateDrawBufferIndexIfActivePLS(const PrivateState &state,
+                                        ErrorSet *errors,
                                         angle::EntryPoint,
                                         GLuint drawBufferIdx,
                                         const char *argumentName);
diff --git a/src/libANGLE/validationES31.cpp b/src/libANGLE/validationES31.cpp
index d6b04b51c..23670d95b 100644
--- a/src/libANGLE/validationES31.cpp
+++ b/src/libANGLE/validationES31.cpp
@@ -2757,27 +2757,29 @@ bool ValidateMemoryBarrierByRegion(const Context *context,
     return true;
 }
 
-bool ValidateSampleMaski(const Context *context,
+bool ValidateSampleMaski(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLuint maskNumber,
                          GLbitfield mask)
 {
-    if (context->getClientVersion() < ES_3_1)
+    if (state.getClientVersion() < ES_3_1)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
-    return ValidateSampleMaskiBase(context, entryPoint, maskNumber, mask);
+    return ValidateSampleMaskiBase(state, errors, entryPoint, maskNumber, mask);
 }
 
-bool ValidateMinSampleShadingOES(const Context *context,
+bool ValidateMinSampleShadingOES(const PrivateState &state,
+                                 ErrorSet *errors,
                                  angle::EntryPoint entryPoint,
                                  GLfloat value)
 {
-    if (!context->getExtensions().sampleShadingOES)
+    if (!state.getExtensions().sampleShadingOES)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
diff --git a/src/libANGLE/validationES31_autogen.h b/src/libANGLE/validationES31_autogen.h
index 3e2adb50d..34daa4ab9 100644
--- a/src/libANGLE/validationES31_autogen.h
+++ b/src/libANGLE/validationES31_autogen.h
@@ -17,6 +17,8 @@
 namespace gl
 {
 class Context;
+class PrivateState;
+class ErrorSet;
 
 bool ValidateActiveShaderProgram(const Context *context,
                                  angle::EntryPoint entryPoint,
@@ -369,7 +371,8 @@ bool ValidateProgramUniformMatrix4x3fv(const Context *context,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLfloat *value);
-bool ValidateSampleMaski(const Context *context,
+bool ValidateSampleMaski(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLuint maskNumber,
                          GLbitfield mask);
diff --git a/src/libANGLE/validationES32.cpp b/src/libANGLE/validationES32.cpp
index 6d1ccfb4e..5065cbffb 100644
--- a/src/libANGLE/validationES32.cpp
+++ b/src/libANGLE/validationES32.cpp
@@ -50,24 +50,25 @@ bool ValidateBlendBarrier(const Context *context, angle::EntryPoint entryPoint)
     return true;
 }
 
-bool ValidateBlendEquationSeparatei(const Context *context,
+bool ValidateBlendEquationSeparatei(const PrivateState &state,
+                                    ErrorSet *errors,
                                     angle::EntryPoint entryPoint,
                                     GLuint buf,
                                     GLenum modeRGB,
                                     GLenum modeAlpha)
 {
-    if (!ValidateDrawBufferIndexIfActivePLS(context, entryPoint, buf, "buf"))
+    if (!ValidateDrawBufferIndexIfActivePLS(state, errors, entryPoint, buf, "buf"))
     {
         return false;
     }
 
-    if (buf >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
+    if (buf >= static_cast<GLuint>(state.getCaps().maxDrawBuffers))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
         return false;
     }
 
-    if (!ValidateBlendEquationSeparate(context, entryPoint, modeRGB, modeAlpha))
+    if (!ValidateBlendEquationSeparate(state, errors, entryPoint, modeRGB, modeAlpha))
     {
         // error already generated
         return false;
@@ -76,23 +77,24 @@ bool ValidateBlendEquationSeparatei(const Context *context,
     return true;
 }
 
-bool ValidateBlendEquationi(const Context *context,
+bool ValidateBlendEquationi(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint buf,
                             GLenum mode)
 {
-    if (!ValidateDrawBufferIndexIfActivePLS(context, entryPoint, buf, "buf"))
+    if (!ValidateDrawBufferIndexIfActivePLS(state, errors, entryPoint, buf, "buf"))
     {
         return false;
     }
 
-    if (buf >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
+    if (buf >= static_cast<GLuint>(state.getCaps().maxDrawBuffers))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
         return false;
     }
 
-    if (!ValidateBlendEquation(context, entryPoint, mode))
+    if (!ValidateBlendEquation(state, errors, entryPoint, mode))
     {
         // error already generated
         return false;
@@ -101,7 +103,8 @@ bool ValidateBlendEquationi(const Context *context,
     return true;
 }
 
-bool ValidateBlendFuncSeparatei(const Context *context,
+bool ValidateBlendFuncSeparatei(const PrivateState &state,
+                                ErrorSet *errors,
                                 angle::EntryPoint entryPoint,
                                 GLuint buf,
                                 GLenum srcRGB,
@@ -109,18 +112,18 @@ bool ValidateBlendFuncSeparatei(const Context *context,
                                 GLenum srcAlpha,
                                 GLenum dstAlpha)
 {
-    if (!ValidateDrawBufferIndexIfActivePLS(context, entryPoint, buf, "buf"))
+    if (!ValidateDrawBufferIndexIfActivePLS(state, errors, entryPoint, buf, "buf"))
     {
         return false;
     }
 
-    if (buf >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
+    if (buf >= static_cast<GLuint>(state.getCaps().maxDrawBuffers))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
         return false;
     }
 
-    if (!ValidateBlendFuncSeparate(context, entryPoint, srcRGB, dstRGB, srcAlpha, dstAlpha))
+    if (!ValidateBlendFuncSeparate(state, errors, entryPoint, srcRGB, dstRGB, srcAlpha, dstAlpha))
     {
         // error already generated
         return false;
@@ -129,24 +132,25 @@ bool ValidateBlendFuncSeparatei(const Context *context,
     return true;
 }
 
-bool ValidateBlendFunci(const Context *context,
+bool ValidateBlendFunci(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLuint buf,
                         GLenum src,
                         GLenum dst)
 {
-    if (!ValidateDrawBufferIndexIfActivePLS(context, entryPoint, buf, "buf"))
+    if (!ValidateDrawBufferIndexIfActivePLS(state, errors, entryPoint, buf, "buf"))
     {
         return false;
     }
 
-    if (buf >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
+    if (buf >= static_cast<GLuint>(state.getCaps().maxDrawBuffers))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
         return false;
     }
 
-    if (!ValidateBlendFunc(context, entryPoint, src, dst))
+    if (!ValidateBlendFunc(state, errors, entryPoint, src, dst))
     {
         // error already generated
         return false;
@@ -155,7 +159,8 @@ bool ValidateBlendFunci(const Context *context,
     return true;
 }
 
-bool ValidateColorMaski(const Context *context,
+bool ValidateColorMaski(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLuint buf,
                         GLboolean r,
@@ -163,14 +168,14 @@ bool ValidateColorMaski(const Context *context,
                         GLboolean b,
                         GLboolean a)
 {
-    if (!ValidateDrawBufferIndexIfActivePLS(context, entryPoint, buf, "buf"))
+    if (!ValidateDrawBufferIndexIfActivePLS(state, errors, entryPoint, buf, "buf"))
     {
         return false;
     }
 
-    if (buf >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
+    if (buf >= static_cast<GLuint>(state.getCaps().maxDrawBuffers))
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
         return false;
     }
 
@@ -238,21 +243,22 @@ bool ValidateDebugMessageInsert(const Context *context,
     return true;
 }
 
-bool ValidateDisablei(const Context *context,
+bool ValidateDisablei(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       GLenum target,
                       GLuint index)
 {
-    int numPLSPlanes = context->getState().getPixelLocalStorageActivePlanes();
+    int numPLSPlanes = state.getPixelLocalStorageActivePlanes();
     if (numPLSPlanes != 0)
     {
         if (IsIndexedCapBannedWithActivePLS(target))
         {
-            ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kPLSCapNotAllowed, target);
+            errors->validationErrorF(entryPoint, GL_INVALID_OPERATION, kPLSCapNotAllowed, target);
             return false;
         }
         if (target == GL_BLEND &&
-            !ValidateDrawBufferIndexIfActivePLS(context, entryPoint, index, "index"))
+            !ValidateDrawBufferIndexIfActivePLS(state, errors, entryPoint, index, "index"))
         {
             return false;
         }
@@ -261,14 +267,14 @@ bool ValidateDisablei(const Context *context,
     switch (target)
     {
         case GL_BLEND:
-            if (index >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
+            if (index >= static_cast<GLuint>(state.getCaps().maxDrawBuffers))
             {
-                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
+                errors->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
                 return false;
             }
             break;
         default:
-            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, target);
+            errors->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
             return false;
     }
     return true;
@@ -328,21 +334,22 @@ bool ValidateDrawRangeElementsBaseVertex(const Context *context,
     return true;
 }
 
-bool ValidateEnablei(const Context *context,
+bool ValidateEnablei(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      GLenum target,
                      GLuint index)
 {
-    int numPLSPlanes = context->getState().getPixelLocalStorageActivePlanes();
+    int numPLSPlanes = state.getPixelLocalStorageActivePlanes();
     if (numPLSPlanes != 0)
     {
         if (IsIndexedCapBannedWithActivePLS(target))
         {
-            ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kPLSCapNotAllowed, target);
+            errors->validationErrorF(entryPoint, GL_INVALID_OPERATION, kPLSCapNotAllowed, target);
             return false;
         }
         if (target == GL_BLEND &&
-            !ValidateDrawBufferIndexIfActivePLS(context, entryPoint, index, "index"))
+            !ValidateDrawBufferIndexIfActivePLS(state, errors, entryPoint, index, "index"))
         {
             return false;
         }
@@ -351,14 +358,14 @@ bool ValidateEnablei(const Context *context,
     switch (target)
     {
         case GL_BLEND:
-            if (index >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
+            if (index >= static_cast<GLuint>(state.getCaps().maxDrawBuffers))
             {
-                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
+                errors->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
                 return false;
             }
             break;
         default:
-            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, target);
+            errors->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
             return false;
     }
     return true;
@@ -521,7 +528,8 @@ bool ValidateGetnUniformuiv(const Context *context,
     return ValidateSizedGetUniform(context, entryPoint, program, location, bufSize, nullptr);
 }
 
-bool ValidateIsEnabledi(const Context *context,
+bool ValidateIsEnabledi(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum target,
                         GLuint index)
@@ -529,20 +537,23 @@ bool ValidateIsEnabledi(const Context *context,
     switch (target)
     {
         case GL_BLEND:
-            if (index >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
+            if (index >= static_cast<GLuint>(state.getCaps().maxDrawBuffers))
             {
-                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
+                errors->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
                 return false;
             }
             break;
         default:
-            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, target);
+            errors->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
             return false;
     }
     return true;
 }
 
-bool ValidateMinSampleShading(const Context *context, angle::EntryPoint entryPoint, GLfloat value)
+bool ValidateMinSampleShading(const PrivateState &state,
+                              ErrorSet *errors,
+                              angle::EntryPoint entryPoint,
+                              GLfloat value)
 {
     return true;
 }
@@ -566,7 +577,8 @@ bool ValidateObjectPtrLabel(const Context *context,
     return true;
 }
 
-bool ValidatePatchParameteri(const Context *context,
+bool ValidatePatchParameteri(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLenum pname,
                              GLint value)
@@ -579,7 +591,8 @@ bool ValidatePopDebugGroup(const Context *context, angle::EntryPoint entryPoint)
     return ValidatePopDebugGroupBase(context, entryPoint);
 }
 
-bool ValidatePrimitiveBoundingBox(const Context *context,
+bool ValidatePrimitiveBoundingBox(const PrivateState &state,
+                                  ErrorSet *errors,
                                   angle::EntryPoint entryPoint,
                                   GLfloat minX,
                                   GLfloat minY,
diff --git a/src/libANGLE/validationES32_autogen.h b/src/libANGLE/validationES32_autogen.h
index 171f94d55..a3a7c5480 100644
--- a/src/libANGLE/validationES32_autogen.h
+++ b/src/libANGLE/validationES32_autogen.h
@@ -17,30 +17,37 @@
 namespace gl
 {
 class Context;
+class PrivateState;
+class ErrorSet;
 
 bool ValidateBlendBarrier(const Context *context, angle::EntryPoint entryPoint);
-bool ValidateBlendEquationSeparatei(const Context *context,
+bool ValidateBlendEquationSeparatei(const PrivateState &state,
+                                    ErrorSet *errors,
                                     angle::EntryPoint entryPoint,
                                     GLuint buf,
                                     GLenum modeRGB,
                                     GLenum modeAlpha);
-bool ValidateBlendEquationi(const Context *context,
+bool ValidateBlendEquationi(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint buf,
                             GLenum mode);
-bool ValidateBlendFuncSeparatei(const Context *context,
+bool ValidateBlendFuncSeparatei(const PrivateState &state,
+                                ErrorSet *errors,
                                 angle::EntryPoint entryPoint,
                                 GLuint buf,
                                 GLenum srcRGB,
                                 GLenum dstRGB,
                                 GLenum srcAlpha,
                                 GLenum dstAlpha);
-bool ValidateBlendFunci(const Context *context,
+bool ValidateBlendFunci(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLuint buf,
                         GLenum src,
                         GLenum dst);
-bool ValidateColorMaski(const Context *context,
+bool ValidateColorMaski(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLuint index,
                         GLboolean r,
@@ -84,7 +91,8 @@ bool ValidateDebugMessageInsert(const Context *context,
                                 GLenum severity,
                                 GLsizei length,
                                 const GLchar *buf);
-bool ValidateDisablei(const Context *context,
+bool ValidateDisablei(const PrivateState &state,
+                      ErrorSet *errors,
                       angle::EntryPoint entryPoint,
                       GLenum target,
                       GLuint index);
@@ -112,7 +120,8 @@ bool ValidateDrawRangeElementsBaseVertex(const Context *context,
                                          DrawElementsType typePacked,
                                          const void *indices,
                                          GLint basevertex);
-bool ValidateEnablei(const Context *context,
+bool ValidateEnablei(const PrivateState &state,
+                     ErrorSet *errors,
                      angle::EntryPoint entryPoint,
                      GLenum target,
                      GLuint index);
@@ -188,11 +197,15 @@ bool ValidateGetnUniformuiv(const Context *context,
                             UniformLocation locationPacked,
                             GLsizei bufSize,
                             const GLuint *params);
-bool ValidateIsEnabledi(const Context *context,
+bool ValidateIsEnabledi(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum target,
                         GLuint index);
-bool ValidateMinSampleShading(const Context *context, angle::EntryPoint entryPoint, GLfloat value);
+bool ValidateMinSampleShading(const PrivateState &state,
+                              ErrorSet *errors,
+                              angle::EntryPoint entryPoint,
+                              GLfloat value);
 bool ValidateObjectLabel(const Context *context,
                          angle::EntryPoint entryPoint,
                          GLenum identifier,
@@ -204,12 +217,14 @@ bool ValidateObjectPtrLabel(const Context *context,
                             const void *ptr,
                             GLsizei length,
                             const GLchar *label);
-bool ValidatePatchParameteri(const Context *context,
+bool ValidatePatchParameteri(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLenum pname,
                              GLint value);
 bool ValidatePopDebugGroup(const Context *context, angle::EntryPoint entryPoint);
-bool ValidatePrimitiveBoundingBox(const Context *context,
+bool ValidatePrimitiveBoundingBox(const PrivateState &state,
+                                  ErrorSet *errors,
                                   angle::EntryPoint entryPoint,
                                   GLfloat minX,
                                   GLfloat minY,
diff --git a/src/libANGLE/validationES3_autogen.h b/src/libANGLE/validationES3_autogen.h
index 270f86866..714797204 100644
--- a/src/libANGLE/validationES3_autogen.h
+++ b/src/libANGLE/validationES3_autogen.h
@@ -17,6 +17,8 @@
 namespace gl
 {
 class Context;
+class PrivateState;
+class ErrorSet;
 
 bool ValidateBeginQuery(const Context *context,
                         angle::EntryPoint entryPoint,
@@ -539,25 +541,29 @@ bool ValidateVertexAttribDivisor(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  GLuint index,
                                  GLuint divisor);
-bool ValidateVertexAttribI4i(const Context *context,
+bool ValidateVertexAttribI4i(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              GLint x,
                              GLint y,
                              GLint z,
                              GLint w);
-bool ValidateVertexAttribI4iv(const Context *context,
+bool ValidateVertexAttribI4iv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLint *v);
-bool ValidateVertexAttribI4ui(const Context *context,
+bool ValidateVertexAttribI4ui(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLuint x,
                               GLuint y,
                               GLuint z,
                               GLuint w);
-bool ValidateVertexAttribI4uiv(const Context *context,
+bool ValidateVertexAttribI4uiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLuint *v);
diff --git a/src/libANGLE/validationESEXT.cpp b/src/libANGLE/validationESEXT.cpp
index 011be06d5..9478a09d2 100644
--- a/src/libANGLE/validationESEXT.cpp
+++ b/src/libANGLE/validationESEXT.cpp
@@ -682,36 +682,39 @@ bool ValidateBlendBarrierKHR(const Context *context, angle::EntryPoint entryPoin
     return true;
 }
 
-bool ValidateBlendEquationSeparateiEXT(const Context *context,
+bool ValidateBlendEquationSeparateiEXT(const PrivateState &state,
+                                       ErrorSet *errors,
                                        angle::EntryPoint entryPoint,
                                        GLuint buf,
                                        GLenum modeRGB,
                                        GLenum modeAlpha)
 {
-    if (!context->getExtensions().drawBuffersIndexedEXT)
+    if (!state.getExtensions().drawBuffersIndexedEXT)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
-    return ValidateBlendEquationSeparatei(context, entryPoint, buf, modeRGB, modeAlpha);
+    return ValidateBlendEquationSeparatei(state, errors, entryPoint, buf, modeRGB, modeAlpha);
 }
 
-bool ValidateBlendEquationiEXT(const Context *context,
+bool ValidateBlendEquationiEXT(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint buf,
                                GLenum mode)
 {
-    if (!context->getExtensions().drawBuffersIndexedEXT)
+    if (!state.getExtensions().drawBuffersIndexedEXT)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
-    return ValidateBlendEquationi(context, entryPoint, buf, mode);
+    return ValidateBlendEquationi(state, errors, entryPoint, buf, mode);
 }
 
-bool ValidateBlendFuncSeparateiEXT(const Context *context,
+bool ValidateBlendFuncSeparateiEXT(const PrivateState &state,
+                                   ErrorSet *errors,
                                    angle::EntryPoint entryPoint,
                                    GLuint buf,
                                    GLenum srcRGB,
@@ -719,31 +722,34 @@ bool ValidateBlendFuncSeparateiEXT(const Context *context,
                                    GLenum srcAlpha,
                                    GLenum dstAlpha)
 {
-    if (!context->getExtensions().drawBuffersIndexedEXT)
+    if (!state.getExtensions().drawBuffersIndexedEXT)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
-    return ValidateBlendFuncSeparatei(context, entryPoint, buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
+    return ValidateBlendFuncSeparatei(state, errors, entryPoint, buf, srcRGB, dstRGB, srcAlpha,
+                                      dstAlpha);
 }
 
-bool ValidateBlendFunciEXT(const Context *context,
+bool ValidateBlendFunciEXT(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLuint buf,
                            GLenum src,
                            GLenum dst)
 {
-    if (!context->getExtensions().drawBuffersIndexedEXT)
+    if (!state.getExtensions().drawBuffersIndexedEXT)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
-    return ValidateBlendFunci(context, entryPoint, buf, src, dst);
+    return ValidateBlendFunci(state, errors, entryPoint, buf, src, dst);
 }
 
-bool ValidateColorMaskiEXT(const Context *context,
+bool ValidateColorMaskiEXT(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLuint index,
                            GLboolean r,
@@ -751,87 +757,93 @@ bool ValidateColorMaskiEXT(const Context *context,
                            GLboolean b,
                            GLboolean a)
 {
-    if (!context->getExtensions().drawBuffersIndexedEXT)
+    if (!state.getExtensions().drawBuffersIndexedEXT)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
-    return ValidateColorMaski(context, entryPoint, index, r, g, b, a);
+    return ValidateColorMaski(state, errors, entryPoint, index, r, g, b, a);
 }
 
-bool ValidateDisableiEXT(const Context *context,
+bool ValidateDisableiEXT(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLenum target,
                          GLuint index)
 {
-    if (!context->getExtensions().drawBuffersIndexedEXT)
+    if (!state.getExtensions().drawBuffersIndexedEXT)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
-    return ValidateDisablei(context, entryPoint, target, index);
+    return ValidateDisablei(state, errors, entryPoint, target, index);
 }
 
-bool ValidateEnableiEXT(const Context *context,
+bool ValidateEnableiEXT(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum target,
                         GLuint index)
 {
-    if (!context->getExtensions().drawBuffersIndexedEXT)
+    if (!state.getExtensions().drawBuffersIndexedEXT)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
-    return ValidateEnablei(context, entryPoint, target, index);
+    return ValidateEnablei(state, errors, entryPoint, target, index);
 }
 
-bool ValidateIsEnablediEXT(const Context *context,
+bool ValidateIsEnablediEXT(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLenum target,
                            GLuint index)
 {
-    if (!context->getExtensions().drawBuffersIndexedEXT)
+    if (!state.getExtensions().drawBuffersIndexedEXT)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
-    return ValidateIsEnabledi(context, entryPoint, target, index);
+    return ValidateIsEnabledi(state, errors, entryPoint, target, index);
 }
 
-bool ValidateBlendEquationSeparateiOES(const Context *context,
+bool ValidateBlendEquationSeparateiOES(const PrivateState &state,
+                                       ErrorSet *errors,
                                        angle::EntryPoint entryPoint,
                                        GLuint buf,
                                        GLenum modeRGB,
                                        GLenum modeAlpha)
 {
-    if (!context->getExtensions().drawBuffersIndexedOES)
+    if (!state.getExtensions().drawBuffersIndexedOES)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
-    return ValidateBlendEquationSeparatei(context, entryPoint, buf, modeRGB, modeAlpha);
+    return ValidateBlendEquationSeparatei(state, errors, entryPoint, buf, modeRGB, modeAlpha);
 }
 
-bool ValidateBlendEquationiOES(const Context *context,
+bool ValidateBlendEquationiOES(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint buf,
                                GLenum mode)
 {
-    if (!context->getExtensions().drawBuffersIndexedOES)
+    if (!state.getExtensions().drawBuffersIndexedOES)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
-    return ValidateBlendEquationi(context, entryPoint, buf, mode);
+    return ValidateBlendEquationi(state, errors, entryPoint, buf, mode);
 }
 
-bool ValidateBlendFuncSeparateiOES(const Context *context,
+bool ValidateBlendFuncSeparateiOES(const PrivateState &state,
+                                   ErrorSet *errors,
                                    angle::EntryPoint entryPoint,
                                    GLuint buf,
                                    GLenum srcRGB,
@@ -839,31 +851,34 @@ bool ValidateBlendFuncSeparateiOES(const Context *context,
                                    GLenum srcAlpha,
                                    GLenum dstAlpha)
 {
-    if (!context->getExtensions().drawBuffersIndexedOES)
+    if (!state.getExtensions().drawBuffersIndexedOES)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
-    return ValidateBlendFuncSeparatei(context, entryPoint, buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
+    return ValidateBlendFuncSeparatei(state, errors, entryPoint, buf, srcRGB, dstRGB, srcAlpha,
+                                      dstAlpha);
 }
 
-bool ValidateBlendFunciOES(const Context *context,
+bool ValidateBlendFunciOES(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLuint buf,
                            GLenum src,
                            GLenum dst)
 {
-    if (!context->getExtensions().drawBuffersIndexedOES)
+    if (!state.getExtensions().drawBuffersIndexedOES)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
-    return ValidateBlendFunci(context, entryPoint, buf, src, dst);
+    return ValidateBlendFunci(state, errors, entryPoint, buf, src, dst);
 }
 
-bool ValidateColorMaskiOES(const Context *context,
+bool ValidateColorMaskiOES(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLuint index,
                            GLboolean r,
@@ -871,64 +886,68 @@ bool ValidateColorMaskiOES(const Context *context,
                            GLboolean b,
                            GLboolean a)
 {
-    if (!context->getExtensions().drawBuffersIndexedOES)
+    if (!state.getExtensions().drawBuffersIndexedOES)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
-    return ValidateColorMaski(context, entryPoint, index, r, g, b, a);
+    return ValidateColorMaski(state, errors, entryPoint, index, r, g, b, a);
 }
 
-bool ValidateDisableiOES(const Context *context,
+bool ValidateDisableiOES(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLenum target,
                          GLuint index)
 {
-    if (!context->getExtensions().drawBuffersIndexedOES)
+    if (!state.getExtensions().drawBuffersIndexedOES)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
-    return ValidateDisablei(context, entryPoint, target, index);
+    return ValidateDisablei(state, errors, entryPoint, target, index);
 }
 
-bool ValidateEnableiOES(const Context *context,
+bool ValidateEnableiOES(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum target,
                         GLuint index)
 {
-    if (!context->getExtensions().drawBuffersIndexedOES)
+    if (!state.getExtensions().drawBuffersIndexedOES)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
-    return ValidateEnablei(context, entryPoint, target, index);
+    return ValidateEnablei(state, errors, entryPoint, target, index);
 }
 
-bool ValidateIsEnablediOES(const Context *context,
+bool ValidateIsEnablediOES(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLenum target,
                            GLuint index)
 {
-    if (!context->getExtensions().drawBuffersIndexedOES)
+    if (!state.getExtensions().drawBuffersIndexedOES)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
-    return ValidateIsEnabledi(context, entryPoint, target, index);
+    return ValidateIsEnabledi(state, errors, entryPoint, target, index);
 }
 
-bool ValidateProvokingVertexANGLE(const Context *context,
+bool ValidateProvokingVertexANGLE(const PrivateState &state,
+                                  ErrorSet *errors,
                                   angle::EntryPoint entryPoint,
                                   ProvokingVertexConvention provokeModePacked)
 {
-    if (!context->getExtensions().provokingVertexANGLE)
+    if (!state.getExtensions().provokingVertexANGLE)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -938,7 +957,7 @@ bool ValidateProvokingVertexANGLE(const Context *context,
         case ProvokingVertexConvention::LastVertexConvention:
             break;
         default:
-            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidProvokingVertex);
+            errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProvokingVertex);
             return false;
     }
 
@@ -2349,32 +2368,34 @@ bool ValidateFramebufferFetchBarrierEXT(const Context *context, angle::EntryPoin
     return true;
 }
 
-bool ValidatePatchParameteriEXT(const Context *context,
+bool ValidatePatchParameteriEXT(const PrivateState &state,
+                                ErrorSet *errors,
                                 angle::EntryPoint entryPoint,
                                 GLenum pname,
                                 GLint value)
 {
-    if (!context->getExtensions().tessellationShaderEXT)
+    if (!state.getExtensions().tessellationShaderEXT)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTessellationShaderExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION,
+                                kTessellationShaderExtensionNotEnabled);
         return false;
     }
 
     if (pname != GL_PATCH_VERTICES)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
         return false;
     }
 
     if (value <= 0)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidValueNonPositive);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kInvalidValueNonPositive);
         return false;
     }
 
-    if (value > context->getCaps().maxPatchVertices)
+    if (value > state.getCaps().maxPatchVertices)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidValueExceedsMaxPatchSize);
+        errors->validationError(entryPoint, GL_INVALID_VALUE, kInvalidValueExceedsMaxPatchSize);
         return false;
     }
 
@@ -2554,26 +2575,27 @@ bool ValidateBufferStorageEXT(const Context *context,
 }
 
 // GL_EXT_clip_control
-bool ValidateClipControlEXT(const Context *context,
+bool ValidateClipControlEXT(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             ClipOrigin originPacked,
                             ClipDepthMode depthPacked)
 {
-    if (!context->getExtensions().clipControlEXT)
+    if (!state.getExtensions().clipControlEXT)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (originPacked == ClipOrigin::InvalidEnum)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidOriginEnum);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidOriginEnum);
         return false;
     }
 
     if (depthPacked == ClipDepthMode::InvalidEnum)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidDepthEnum);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDepthEnum);
         return false;
     }
 
@@ -2622,26 +2644,27 @@ bool ValidateNamedBufferStorageExternalEXT(const Context *context,
 }
 
 // GL_ANGLE_polygon_mode
-bool ValidatePolygonModeANGLE(const Context *context,
+bool ValidatePolygonModeANGLE(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLenum face,
                               PolygonMode modePacked)
 {
-    if (!context->getExtensions().polygonModeANGLE)
+    if (!state.getExtensions().polygonModeANGLE)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (face != GL_FRONT_AND_BACK)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidCullMode);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidCullMode);
         return false;
     }
 
     if (modePacked == PolygonMode::Point || modePacked == PolygonMode::InvalidEnum)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPolygonMode);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPolygonMode);
         return false;
     }
 
@@ -2649,26 +2672,27 @@ bool ValidatePolygonModeANGLE(const Context *context,
 }
 
 // GL_NV_polygon_mode
-bool ValidatePolygonModeNV(const Context *context,
+bool ValidatePolygonModeNV(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLenum face,
                            PolygonMode modePacked)
 {
-    if (!context->getExtensions().polygonModeNV)
+    if (!state.getExtensions().polygonModeNV)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (face != GL_FRONT_AND_BACK)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidCullMode);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidCullMode);
         return false;
     }
 
     if (modePacked == PolygonMode::InvalidEnum)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPolygonMode);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPolygonMode);
         return false;
     }
 
@@ -2676,15 +2700,16 @@ bool ValidatePolygonModeNV(const Context *context,
 }
 
 // GL_EXT_polygon_offset_clamp
-bool ValidatePolygonOffsetClampEXT(const Context *context,
+bool ValidatePolygonOffsetClampEXT(const PrivateState &state,
+                                   ErrorSet *errors,
                                    angle::EntryPoint entryPoint,
                                    GLfloat factor,
                                    GLfloat units,
                                    GLfloat clamp)
 {
-    if (!context->getExtensions().polygonOffsetClampEXT)
+    if (!state.getExtensions().polygonOffsetClampEXT)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2692,7 +2717,8 @@ bool ValidatePolygonOffsetClampEXT(const Context *context,
 }
 
 // GL_EXT_primitive_bounding_box
-bool ValidatePrimitiveBoundingBoxEXT(const Context *context,
+bool ValidatePrimitiveBoundingBoxEXT(const PrivateState &state,
+                                     ErrorSet *errors,
                                      angle::EntryPoint entryPoint,
                                      GLfloat minX,
                                      GLfloat minY,
@@ -2703,9 +2729,9 @@ bool ValidatePrimitiveBoundingBoxEXT(const Context *context,
                                      GLfloat maxZ,
                                      GLfloat maxW)
 {
-    if (!context->getExtensions().primitiveBoundingBoxEXT)
+    if (!state.getExtensions().primitiveBoundingBoxEXT)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2713,7 +2739,8 @@ bool ValidatePrimitiveBoundingBoxEXT(const Context *context,
 }
 
 // GL_OES_primitive_bounding_box
-bool ValidatePrimitiveBoundingBoxOES(const Context *context,
+bool ValidatePrimitiveBoundingBoxOES(const PrivateState &state,
+                                     ErrorSet *errors,
                                      angle::EntryPoint entryPoint,
                                      GLfloat minX,
                                      GLfloat minY,
@@ -2724,9 +2751,9 @@ bool ValidatePrimitiveBoundingBoxOES(const Context *context,
                                      GLfloat maxZ,
                                      GLfloat maxW)
 {
-    if (!context->getExtensions().primitiveBoundingBoxOES)
+    if (!state.getExtensions().primitiveBoundingBoxOES)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3936,34 +3963,38 @@ bool ValidateSelectPerfMonitorCountersAMD(const Context *context,
     return false;
 }
 
-bool ValidateShadingRateQCOM(const Context *context, angle::EntryPoint entryPoint, GLenum rate)
+bool ValidateShadingRateQCOM(const PrivateState &state,
+                             ErrorSet *errors,
+                             angle::EntryPoint entryPoint,
+                             GLenum rate)
 {
-    if (!context->getExtensions().shadingRateQCOM)
+    if (!state.getExtensions().shadingRateQCOM)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     gl::ShadingRate shadingRate = gl::FromGLenum<gl::ShadingRate>(rate);
     if (shadingRate == gl::ShadingRate::Undefined || shadingRate == gl::ShadingRate::InvalidEnum)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidShadingRate);
+        errors->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShadingRate);
         return false;
     }
 
     return true;
 }
 
-bool ValidateLogicOpANGLE(const Context *context,
+bool ValidateLogicOpANGLE(const PrivateState &state,
+                          ErrorSet *errors,
                           angle::EntryPoint entryPoint,
                           LogicalOperation opcodePacked)
 {
-    if (!context->getExtensions().logicOpANGLE)
+    if (!state.getExtensions().logicOpANGLE)
     {
-        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+        errors->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
-    return ValidateLogicOpCommon(context, entryPoint, opcodePacked);
+    return ValidateLogicOpCommon(state, errors, entryPoint, opcodePacked);
 }
 }  // namespace gl
diff --git a/src/libANGLE/validationESEXT_autogen.h b/src/libANGLE/validationESEXT_autogen.h
index c05d87a77..4f813fe4e 100644
--- a/src/libANGLE/validationESEXT_autogen.h
+++ b/src/libANGLE/validationESEXT_autogen.h
@@ -17,6 +17,8 @@
 namespace gl
 {
 class Context;
+class PrivateState;
+class ErrorSet;
 
 // GL_AMD_performance_monitor
 bool ValidateBeginPerfMonitorAMD(const Context *context,
@@ -231,7 +233,8 @@ bool ValidateVertexAttribDivisorANGLE(const Context *context,
                                       GLuint divisor);
 
 // GL_ANGLE_logic_op
-bool ValidateLogicOpANGLE(const Context *context,
+bool ValidateLogicOpANGLE(const PrivateState &state,
+                          ErrorSet *errors,
                           angle::EntryPoint entryPoint,
                           LogicalOperation opcodePacked);
 
@@ -330,7 +333,8 @@ bool ValidateMultiDrawElementsInstancedANGLE(const Context *context,
 // GL_ANGLE_pack_reverse_row_order
 
 // GL_ANGLE_polygon_mode
-bool ValidatePolygonModeANGLE(const Context *context,
+bool ValidatePolygonModeANGLE(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLenum face,
                               PolygonMode modePacked);
@@ -338,7 +342,8 @@ bool ValidatePolygonModeANGLE(const Context *context,
 // GL_ANGLE_program_binary
 
 // GL_ANGLE_provoking_vertex
-bool ValidateProvokingVertexANGLE(const Context *context,
+bool ValidateProvokingVertexANGLE(const PrivateState &state,
+                                  ErrorSet *errors,
                                   angle::EntryPoint entryPoint,
                                   ProvokingVertexConvention provokeModePacked);
 
@@ -956,7 +961,8 @@ bool ValidateGetMultisamplefvANGLE(const Context *context,
                                    GLenum pname,
                                    GLuint index,
                                    const GLfloat *val);
-bool ValidateSampleMaskiANGLE(const Context *context,
+bool ValidateSampleMaskiANGLE(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint maskNumber,
                               GLbitfield mask);
@@ -1033,7 +1039,8 @@ bool ValidateCopySubTextureCHROMIUM(const Context *context,
                                     GLboolean unpackUnmultiplyAlpha);
 
 // GL_CHROMIUM_framebuffer_mixed_samples
-bool ValidateCoverageModulationCHROMIUM(const Context *context,
+bool ValidateCoverageModulationCHROMIUM(const PrivateState &state,
+                                        ErrorSet *errors,
                                         angle::EntryPoint entryPoint,
                                         GLenum components);
 
@@ -1118,7 +1125,8 @@ bool ValidateBufferStorageEXT(const Context *context,
                               GLbitfield flags);
 
 // GL_EXT_clip_control
-bool ValidateClipControlEXT(const Context *context,
+bool ValidateClipControlEXT(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             ClipOrigin originPacked,
                             ClipDepthMode depthPacked);
@@ -1243,43 +1251,51 @@ bool ValidateDrawBuffersEXT(const Context *context,
                             const GLenum *bufs);
 
 // GL_EXT_draw_buffers_indexed
-bool ValidateBlendEquationSeparateiEXT(const Context *context,
+bool ValidateBlendEquationSeparateiEXT(const PrivateState &state,
+                                       ErrorSet *errors,
                                        angle::EntryPoint entryPoint,
                                        GLuint buf,
                                        GLenum modeRGB,
                                        GLenum modeAlpha);
-bool ValidateBlendEquationiEXT(const Context *context,
+bool ValidateBlendEquationiEXT(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint buf,
                                GLenum mode);
-bool ValidateBlendFuncSeparateiEXT(const Context *context,
+bool ValidateBlendFuncSeparateiEXT(const PrivateState &state,
+                                   ErrorSet *errors,
                                    angle::EntryPoint entryPoint,
                                    GLuint buf,
                                    GLenum srcRGB,
                                    GLenum dstRGB,
                                    GLenum srcAlpha,
                                    GLenum dstAlpha);
-bool ValidateBlendFunciEXT(const Context *context,
+bool ValidateBlendFunciEXT(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLuint buf,
                            GLenum src,
                            GLenum dst);
-bool ValidateColorMaskiEXT(const Context *context,
+bool ValidateColorMaskiEXT(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLuint index,
                            GLboolean r,
                            GLboolean g,
                            GLboolean b,
                            GLboolean a);
-bool ValidateDisableiEXT(const Context *context,
+bool ValidateDisableiEXT(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLenum target,
                          GLuint index);
-bool ValidateEnableiEXT(const Context *context,
+bool ValidateEnableiEXT(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum target,
                         GLuint index);
-bool ValidateIsEnablediEXT(const Context *context,
+bool ValidateIsEnablediEXT(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLenum target,
                            GLuint index);
@@ -1501,14 +1517,16 @@ bool ValidateRenderbufferStorageMultisampleEXT(const Context *context,
 // GL_EXT_occlusion_query_boolean
 
 // GL_EXT_polygon_offset_clamp
-bool ValidatePolygonOffsetClampEXT(const Context *context,
+bool ValidatePolygonOffsetClampEXT(const PrivateState &state,
+                                   ErrorSet *errors,
                                    angle::EntryPoint entryPoint,
                                    GLfloat factor,
                                    GLfloat units,
                                    GLfloat clamp);
 
 // GL_EXT_primitive_bounding_box
-bool ValidatePrimitiveBoundingBoxEXT(const Context *context,
+bool ValidatePrimitiveBoundingBoxEXT(const PrivateState &state,
+                                     ErrorSet *errors,
                                      angle::EntryPoint entryPoint,
                                      GLfloat minX,
                                      GLfloat minY,
@@ -1878,7 +1896,8 @@ bool ValidateFramebufferFetchBarrierEXT(const Context *context, angle::EntryPoin
 // GL_EXT_shadow_samplers
 
 // GL_EXT_tessellation_shader
-bool ValidatePatchParameteriEXT(const Context *context,
+bool ValidatePatchParameteriEXT(const PrivateState &state,
+                                ErrorSet *errors,
                                 angle::EntryPoint entryPoint,
                                 GLenum pname,
                                 GLint value);
@@ -2144,7 +2163,8 @@ bool ValidateBlitFramebufferNV(const Context *context,
 // GL_NV_pixel_buffer_object
 
 // GL_NV_polygon_mode
-bool ValidatePolygonModeNV(const Context *context,
+bool ValidatePolygonModeNV(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLenum face,
                            PolygonMode modePacked);
@@ -2203,43 +2223,51 @@ bool ValidateCopyImageSubDataOES(const Context *context,
 // GL_OES_depth_texture
 
 // GL_OES_draw_buffers_indexed
-bool ValidateBlendEquationSeparateiOES(const Context *context,
+bool ValidateBlendEquationSeparateiOES(const PrivateState &state,
+                                       ErrorSet *errors,
                                        angle::EntryPoint entryPoint,
                                        GLuint buf,
                                        GLenum modeRGB,
                                        GLenum modeAlpha);
-bool ValidateBlendEquationiOES(const Context *context,
+bool ValidateBlendEquationiOES(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint buf,
                                GLenum mode);
-bool ValidateBlendFuncSeparateiOES(const Context *context,
+bool ValidateBlendFuncSeparateiOES(const PrivateState &state,
+                                   ErrorSet *errors,
                                    angle::EntryPoint entryPoint,
                                    GLuint buf,
                                    GLenum srcRGB,
                                    GLenum dstRGB,
                                    GLenum srcAlpha,
                                    GLenum dstAlpha);
-bool ValidateBlendFunciOES(const Context *context,
+bool ValidateBlendFunciOES(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLuint buf,
                            GLenum src,
                            GLenum dst);
-bool ValidateColorMaskiOES(const Context *context,
+bool ValidateColorMaskiOES(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLuint index,
                            GLboolean r,
                            GLboolean g,
                            GLboolean b,
                            GLboolean a);
-bool ValidateDisableiOES(const Context *context,
+bool ValidateDisableiOES(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLenum target,
                          GLuint index);
-bool ValidateEnableiOES(const Context *context,
+bool ValidateEnableiOES(const PrivateState &state,
+                        ErrorSet *errors,
                         angle::EntryPoint entryPoint,
                         GLenum target,
                         GLuint index);
-bool ValidateIsEnablediOES(const Context *context,
+bool ValidateIsEnablediOES(const PrivateState &state,
+                           ErrorSet *errors,
                            angle::EntryPoint entryPoint,
                            GLenum target,
                            GLuint index);
@@ -2452,7 +2480,8 @@ bool ValidatePointSizePointerOES(const Context *context,
 // GL_OES_point_sprite
 
 // GL_OES_primitive_bounding_box
-bool ValidatePrimitiveBoundingBoxOES(const Context *context,
+bool ValidatePrimitiveBoundingBoxOES(const PrivateState &state,
+                                     ErrorSet *errors,
                                      angle::EntryPoint entryPoint,
                                      GLfloat minX,
                                      GLfloat minY,
@@ -2472,7 +2501,8 @@ bool ValidateQueryMatrixxOES(const Context *context,
 // GL_OES_rgb8_rgba8
 
 // GL_OES_sample_shading
-bool ValidateMinSampleShadingOES(const Context *context,
+bool ValidateMinSampleShadingOES(const PrivateState &state,
+                                 ErrorSet *errors,
                                  angle::EntryPoint entryPoint,
                                  GLfloat value);
 
@@ -2723,7 +2753,10 @@ bool ValidateFramebufferTextureMultiviewOVR(const Context *context,
 // GL_QCOM_render_shared_exponent
 
 // GL_QCOM_shading_rate
-bool ValidateShadingRateQCOM(const Context *context, angle::EntryPoint entryPoint, GLenum rate);
+bool ValidateShadingRateQCOM(const PrivateState &state,
+                             ErrorSet *errors,
+                             angle::EntryPoint entryPoint,
+                             GLenum rate);
 }  // namespace gl
 
 #endif  // LIBANGLE_VALIDATION_ESEXT_AUTOGEN_H_
diff --git a/src/libANGLE/validationGL1.cpp b/src/libANGLE/validationGL1.cpp
index b7dd1cde8..1db8b84f9 100644
--- a/src/libANGLE/validationGL1.cpp
+++ b/src/libANGLE/validationGL1.cpp
@@ -949,7 +949,8 @@ bool ValidatePixelZoom(const Context *,
     return true;
 }
 
-bool ValidatePolygonMode(const Context *,
+bool ValidatePolygonMode(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLenum face,
                          PolygonMode modePacked)
diff --git a/src/libANGLE/validationGL1_autogen.h b/src/libANGLE/validationGL1_autogen.h
index 6820c665b..e2bf6c5ea 100644
--- a/src/libANGLE/validationGL1_autogen.h
+++ b/src/libANGLE/validationGL1_autogen.h
@@ -17,6 +17,8 @@
 namespace gl
 {
 class Context;
+class PrivateState;
+class ErrorSet;
 
 // GL 1.0
 bool ValidateAccum(const Context *context, angle::EntryPoint entryPoint, GLenum op, GLfloat value);
@@ -470,7 +472,8 @@ bool ValidatePixelZoom(const Context *context,
                        angle::EntryPoint entryPoint,
                        GLfloat xfactor,
                        GLfloat yfactor);
-bool ValidatePolygonMode(const Context *context,
+bool ValidatePolygonMode(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          GLenum face,
                          PolygonMode modePacked);
diff --git a/src/libANGLE/validationGL2.cpp b/src/libANGLE/validationGL2.cpp
index 9eb97b2f9..093996a19 100644
--- a/src/libANGLE/validationGL2.cpp
+++ b/src/libANGLE/validationGL2.cpp
@@ -20,7 +20,8 @@ bool ValidateGetVertexAttribdv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib1d(const Context *context,
+bool ValidateVertexAttrib1d(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLdouble x)
@@ -28,7 +29,8 @@ bool ValidateVertexAttrib1d(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib1dv(const Context *context,
+bool ValidateVertexAttrib1dv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLdouble *v)
@@ -36,7 +38,8 @@ bool ValidateVertexAttrib1dv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib1s(const Context *context,
+bool ValidateVertexAttrib1s(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLshort x)
@@ -44,7 +47,8 @@ bool ValidateVertexAttrib1s(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib1sv(const Context *context,
+bool ValidateVertexAttrib1sv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLshort *v)
@@ -52,7 +56,8 @@ bool ValidateVertexAttrib1sv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib2d(const Context *context,
+bool ValidateVertexAttrib2d(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLdouble x,
@@ -61,7 +66,8 @@ bool ValidateVertexAttrib2d(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib2dv(const Context *context,
+bool ValidateVertexAttrib2dv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLdouble *v)
@@ -69,7 +75,8 @@ bool ValidateVertexAttrib2dv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib2s(const Context *context,
+bool ValidateVertexAttrib2s(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLshort x,
@@ -78,7 +85,8 @@ bool ValidateVertexAttrib2s(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib2sv(const Context *context,
+bool ValidateVertexAttrib2sv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLshort *v)
@@ -86,7 +94,8 @@ bool ValidateVertexAttrib2sv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib3d(const Context *context,
+bool ValidateVertexAttrib3d(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLdouble x,
@@ -96,7 +105,8 @@ bool ValidateVertexAttrib3d(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib3dv(const Context *context,
+bool ValidateVertexAttrib3dv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLdouble *v)
@@ -104,7 +114,8 @@ bool ValidateVertexAttrib3dv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib3s(const Context *context,
+bool ValidateVertexAttrib3s(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLshort x,
@@ -114,7 +125,8 @@ bool ValidateVertexAttrib3s(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib3sv(const Context *context,
+bool ValidateVertexAttrib3sv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLshort *v)
@@ -122,7 +134,8 @@ bool ValidateVertexAttrib3sv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib4Nbv(const Context *context,
+bool ValidateVertexAttrib4Nbv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLbyte *v)
@@ -130,7 +143,8 @@ bool ValidateVertexAttrib4Nbv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib4Niv(const Context *context,
+bool ValidateVertexAttrib4Niv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLint *v)
@@ -138,7 +152,8 @@ bool ValidateVertexAttrib4Niv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib4Nsv(const Context *context,
+bool ValidateVertexAttrib4Nsv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLshort *v)
@@ -146,7 +161,8 @@ bool ValidateVertexAttrib4Nsv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib4Nub(const Context *context,
+bool ValidateVertexAttrib4Nub(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLubyte x,
@@ -157,7 +173,8 @@ bool ValidateVertexAttrib4Nub(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib4Nubv(const Context *context,
+bool ValidateVertexAttrib4Nubv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLubyte *v)
@@ -165,7 +182,8 @@ bool ValidateVertexAttrib4Nubv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib4Nuiv(const Context *context,
+bool ValidateVertexAttrib4Nuiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLuint *v)
@@ -173,7 +191,8 @@ bool ValidateVertexAttrib4Nuiv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib4Nusv(const Context *context,
+bool ValidateVertexAttrib4Nusv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLushort *v)
@@ -181,7 +200,8 @@ bool ValidateVertexAttrib4Nusv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib4bv(const Context *context,
+bool ValidateVertexAttrib4bv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLbyte *v)
@@ -189,7 +209,8 @@ bool ValidateVertexAttrib4bv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib4d(const Context *context,
+bool ValidateVertexAttrib4d(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLdouble x,
@@ -200,7 +221,8 @@ bool ValidateVertexAttrib4d(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib4dv(const Context *context,
+bool ValidateVertexAttrib4dv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLdouble *v)
@@ -208,7 +230,8 @@ bool ValidateVertexAttrib4dv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib4iv(const Context *context,
+bool ValidateVertexAttrib4iv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLint *v)
@@ -216,7 +239,8 @@ bool ValidateVertexAttrib4iv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib4s(const Context *context,
+bool ValidateVertexAttrib4s(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLshort x,
@@ -227,7 +251,8 @@ bool ValidateVertexAttrib4s(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib4sv(const Context *context,
+bool ValidateVertexAttrib4sv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLshort *v)
@@ -235,7 +260,8 @@ bool ValidateVertexAttrib4sv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib4ubv(const Context *context,
+bool ValidateVertexAttrib4ubv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLubyte *v)
@@ -243,7 +269,8 @@ bool ValidateVertexAttrib4ubv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib4uiv(const Context *context,
+bool ValidateVertexAttrib4uiv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLuint *v)
@@ -251,7 +278,8 @@ bool ValidateVertexAttrib4uiv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttrib4usv(const Context *context,
+bool ValidateVertexAttrib4usv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLushort *v)
diff --git a/src/libANGLE/validationGL2_autogen.h b/src/libANGLE/validationGL2_autogen.h
index 5a6e0b375..2cffbafe7 100644
--- a/src/libANGLE/validationGL2_autogen.h
+++ b/src/libANGLE/validationGL2_autogen.h
@@ -17,6 +17,8 @@
 namespace gl
 {
 class Context;
+class PrivateState;
+class ErrorSet;
 
 // GL 2.0
 bool ValidateGetVertexAttribdv(const Context *context,
@@ -24,130 +26,158 @@ bool ValidateGetVertexAttribdv(const Context *context,
                                GLuint index,
                                GLenum pname,
                                const GLdouble *params);
-bool ValidateVertexAttrib1d(const Context *context,
+bool ValidateVertexAttrib1d(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLdouble x);
-bool ValidateVertexAttrib1dv(const Context *context,
+bool ValidateVertexAttrib1dv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLdouble *v);
-bool ValidateVertexAttrib1s(const Context *context,
+bool ValidateVertexAttrib1s(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLshort x);
-bool ValidateVertexAttrib1sv(const Context *context,
+bool ValidateVertexAttrib1sv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLshort *v);
-bool ValidateVertexAttrib2d(const Context *context,
+bool ValidateVertexAttrib2d(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLdouble x,
                             GLdouble y);
-bool ValidateVertexAttrib2dv(const Context *context,
+bool ValidateVertexAttrib2dv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLdouble *v);
-bool ValidateVertexAttrib2s(const Context *context,
+bool ValidateVertexAttrib2s(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLshort x,
                             GLshort y);
-bool ValidateVertexAttrib2sv(const Context *context,
+bool ValidateVertexAttrib2sv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLshort *v);
-bool ValidateVertexAttrib3d(const Context *context,
+bool ValidateVertexAttrib3d(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLdouble x,
                             GLdouble y,
                             GLdouble z);
-bool ValidateVertexAttrib3dv(const Context *context,
+bool ValidateVertexAttrib3dv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLdouble *v);
-bool ValidateVertexAttrib3s(const Context *context,
+bool ValidateVertexAttrib3s(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLshort x,
                             GLshort y,
                             GLshort z);
-bool ValidateVertexAttrib3sv(const Context *context,
+bool ValidateVertexAttrib3sv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLshort *v);
-bool ValidateVertexAttrib4Nbv(const Context *context,
+bool ValidateVertexAttrib4Nbv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLbyte *v);
-bool ValidateVertexAttrib4Niv(const Context *context,
+bool ValidateVertexAttrib4Niv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLint *v);
-bool ValidateVertexAttrib4Nsv(const Context *context,
+bool ValidateVertexAttrib4Nsv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLshort *v);
-bool ValidateVertexAttrib4Nub(const Context *context,
+bool ValidateVertexAttrib4Nub(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLubyte x,
                               GLubyte y,
                               GLubyte z,
                               GLubyte w);
-bool ValidateVertexAttrib4Nubv(const Context *context,
+bool ValidateVertexAttrib4Nubv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLubyte *v);
-bool ValidateVertexAttrib4Nuiv(const Context *context,
+bool ValidateVertexAttrib4Nuiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLuint *v);
-bool ValidateVertexAttrib4Nusv(const Context *context,
+bool ValidateVertexAttrib4Nusv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLushort *v);
-bool ValidateVertexAttrib4bv(const Context *context,
+bool ValidateVertexAttrib4bv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLbyte *v);
-bool ValidateVertexAttrib4d(const Context *context,
+bool ValidateVertexAttrib4d(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLdouble x,
                             GLdouble y,
                             GLdouble z,
                             GLdouble w);
-bool ValidateVertexAttrib4dv(const Context *context,
+bool ValidateVertexAttrib4dv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLdouble *v);
-bool ValidateVertexAttrib4iv(const Context *context,
+bool ValidateVertexAttrib4iv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLint *v);
-bool ValidateVertexAttrib4s(const Context *context,
+bool ValidateVertexAttrib4s(const PrivateState &state,
+                            ErrorSet *errors,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLshort x,
                             GLshort y,
                             GLshort z,
                             GLshort w);
-bool ValidateVertexAttrib4sv(const Context *context,
+bool ValidateVertexAttrib4sv(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLshort *v);
-bool ValidateVertexAttrib4ubv(const Context *context,
+bool ValidateVertexAttrib4ubv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLubyte *v);
-bool ValidateVertexAttrib4uiv(const Context *context,
+bool ValidateVertexAttrib4uiv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLuint *v);
-bool ValidateVertexAttrib4usv(const Context *context,
+bool ValidateVertexAttrib4usv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLushort *v);
diff --git a/src/libANGLE/validationGL3.cpp b/src/libANGLE/validationGL3.cpp
index 1e452bd0f..67dc6d899 100644
--- a/src/libANGLE/validationGL3.cpp
+++ b/src/libANGLE/validationGL3.cpp
@@ -63,7 +63,8 @@ bool ValidateFramebufferTexture3D(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribI1i(const Context *context,
+bool ValidateVertexAttribI1i(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              GLint x)
@@ -71,7 +72,8 @@ bool ValidateVertexAttribI1i(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribI1iv(const Context *context,
+bool ValidateVertexAttribI1iv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLint *v)
@@ -79,7 +81,8 @@ bool ValidateVertexAttribI1iv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribI1ui(const Context *context,
+bool ValidateVertexAttribI1ui(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLuint x)
@@ -87,7 +90,8 @@ bool ValidateVertexAttribI1ui(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribI1uiv(const Context *context,
+bool ValidateVertexAttribI1uiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLuint *v)
@@ -95,7 +99,8 @@ bool ValidateVertexAttribI1uiv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribI2i(const Context *context,
+bool ValidateVertexAttribI2i(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              GLint x,
@@ -104,7 +109,8 @@ bool ValidateVertexAttribI2i(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribI2iv(const Context *context,
+bool ValidateVertexAttribI2iv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLint *v)
@@ -112,7 +118,8 @@ bool ValidateVertexAttribI2iv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribI2ui(const Context *context,
+bool ValidateVertexAttribI2ui(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLuint x,
@@ -121,7 +128,8 @@ bool ValidateVertexAttribI2ui(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribI2uiv(const Context *context,
+bool ValidateVertexAttribI2uiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLuint *v)
@@ -129,7 +137,8 @@ bool ValidateVertexAttribI2uiv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribI3i(const Context *context,
+bool ValidateVertexAttribI3i(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              GLint x,
@@ -139,7 +148,8 @@ bool ValidateVertexAttribI3i(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribI3iv(const Context *context,
+bool ValidateVertexAttribI3iv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLint *v)
@@ -147,7 +157,8 @@ bool ValidateVertexAttribI3iv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribI3ui(const Context *context,
+bool ValidateVertexAttribI3ui(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLuint x,
@@ -157,7 +168,8 @@ bool ValidateVertexAttribI3ui(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribI3uiv(const Context *context,
+bool ValidateVertexAttribI3uiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLuint *v)
@@ -165,7 +177,8 @@ bool ValidateVertexAttribI3uiv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribI4bv(const Context *context,
+bool ValidateVertexAttribI4bv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLbyte *v)
@@ -173,7 +186,8 @@ bool ValidateVertexAttribI4bv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribI4sv(const Context *context,
+bool ValidateVertexAttribI4sv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLshort *v)
@@ -181,7 +195,8 @@ bool ValidateVertexAttribI4sv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribI4ubv(const Context *context,
+bool ValidateVertexAttribI4ubv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLubyte *v)
@@ -189,7 +204,8 @@ bool ValidateVertexAttribI4ubv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribI4usv(const Context *context,
+bool ValidateVertexAttribI4usv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLushort *v)
@@ -227,7 +243,8 @@ bool ValidateMultiDrawElementsBaseVertex(const Context *context,
     return true;
 }
 
-bool ValidateProvokingVertex(const Context *context,
+bool ValidateProvokingVertex(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              ProvokingVertexConvention modePacked)
 {
@@ -503,7 +520,8 @@ bool ValidateTexCoordP4uiv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribP1ui(const Context *context,
+bool ValidateVertexAttribP1ui(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLenum type,
@@ -513,7 +531,8 @@ bool ValidateVertexAttribP1ui(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribP1uiv(const Context *context,
+bool ValidateVertexAttribP1uiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                GLenum type,
@@ -523,7 +542,8 @@ bool ValidateVertexAttribP1uiv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribP2ui(const Context *context,
+bool ValidateVertexAttribP2ui(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLenum type,
@@ -533,7 +553,8 @@ bool ValidateVertexAttribP2ui(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribP2uiv(const Context *context,
+bool ValidateVertexAttribP2uiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                GLenum type,
@@ -543,7 +564,8 @@ bool ValidateVertexAttribP2uiv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribP3ui(const Context *context,
+bool ValidateVertexAttribP3ui(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLenum type,
@@ -553,7 +575,8 @@ bool ValidateVertexAttribP3ui(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribP3uiv(const Context *context,
+bool ValidateVertexAttribP3uiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                GLenum type,
@@ -563,7 +586,8 @@ bool ValidateVertexAttribP3uiv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribP4ui(const Context *context,
+bool ValidateVertexAttribP4ui(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLenum type,
@@ -573,7 +597,8 @@ bool ValidateVertexAttribP4ui(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribP4uiv(const Context *context,
+bool ValidateVertexAttribP4uiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                GLenum type,
diff --git a/src/libANGLE/validationGL3_autogen.h b/src/libANGLE/validationGL3_autogen.h
index 1f71153cb..fb7887f7c 100644
--- a/src/libANGLE/validationGL3_autogen.h
+++ b/src/libANGLE/validationGL3_autogen.h
@@ -17,6 +17,8 @@
 namespace gl
 {
 class Context;
+class PrivateState;
+class ErrorSet;
 
 // GL 3.0
 bool ValidateBeginConditionalRender(const Context *context,
@@ -48,73 +50,89 @@ bool ValidateFramebufferTexture3D(const Context *context,
                                   TextureID texturePacked,
                                   GLint level,
                                   GLint zoffset);
-bool ValidateVertexAttribI1i(const Context *context,
+bool ValidateVertexAttribI1i(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              GLint x);
-bool ValidateVertexAttribI1iv(const Context *context,
+bool ValidateVertexAttribI1iv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLint *v);
-bool ValidateVertexAttribI1ui(const Context *context,
+bool ValidateVertexAttribI1ui(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLuint x);
-bool ValidateVertexAttribI1uiv(const Context *context,
+bool ValidateVertexAttribI1uiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLuint *v);
-bool ValidateVertexAttribI2i(const Context *context,
+bool ValidateVertexAttribI2i(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              GLint x,
                              GLint y);
-bool ValidateVertexAttribI2iv(const Context *context,
+bool ValidateVertexAttribI2iv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLint *v);
-bool ValidateVertexAttribI2ui(const Context *context,
+bool ValidateVertexAttribI2ui(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLuint x,
                               GLuint y);
-bool ValidateVertexAttribI2uiv(const Context *context,
+bool ValidateVertexAttribI2uiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLuint *v);
-bool ValidateVertexAttribI3i(const Context *context,
+bool ValidateVertexAttribI3i(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              GLint x,
                              GLint y,
                              GLint z);
-bool ValidateVertexAttribI3iv(const Context *context,
+bool ValidateVertexAttribI3iv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLint *v);
-bool ValidateVertexAttribI3ui(const Context *context,
+bool ValidateVertexAttribI3ui(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLuint x,
                               GLuint y,
                               GLuint z);
-bool ValidateVertexAttribI3uiv(const Context *context,
+bool ValidateVertexAttribI3uiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLuint *v);
-bool ValidateVertexAttribI4bv(const Context *context,
+bool ValidateVertexAttribI4bv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLbyte *v);
-bool ValidateVertexAttribI4sv(const Context *context,
+bool ValidateVertexAttribI4sv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLshort *v);
-bool ValidateVertexAttribI4ubv(const Context *context,
+bool ValidateVertexAttribI4ubv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLubyte *v);
-bool ValidateVertexAttribI4usv(const Context *context,
+bool ValidateVertexAttribI4usv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                const GLushort *v);
@@ -140,7 +158,8 @@ bool ValidateMultiDrawElementsBaseVertex(const Context *context,
                                          const void *const *indices,
                                          GLsizei drawcount,
                                          const GLint *basevertex);
-bool ValidateProvokingVertex(const Context *context,
+bool ValidateProvokingVertex(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              ProvokingVertexConvention modePacked);
 bool ValidateTexImage2DMultisample(const Context *context,
@@ -290,49 +309,57 @@ bool ValidateTexCoordP4uiv(const Context *context,
                            angle::EntryPoint entryPoint,
                            GLenum type,
                            const GLuint *coords);
-bool ValidateVertexAttribP1ui(const Context *context,
+bool ValidateVertexAttribP1ui(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLenum type,
                               GLboolean normalized,
                               GLuint value);
-bool ValidateVertexAttribP1uiv(const Context *context,
+bool ValidateVertexAttribP1uiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                GLenum type,
                                GLboolean normalized,
                                const GLuint *value);
-bool ValidateVertexAttribP2ui(const Context *context,
+bool ValidateVertexAttribP2ui(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLenum type,
                               GLboolean normalized,
                               GLuint value);
-bool ValidateVertexAttribP2uiv(const Context *context,
+bool ValidateVertexAttribP2uiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                GLenum type,
                                GLboolean normalized,
                                const GLuint *value);
-bool ValidateVertexAttribP3ui(const Context *context,
+bool ValidateVertexAttribP3ui(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLenum type,
                               GLboolean normalized,
                               GLuint value);
-bool ValidateVertexAttribP3uiv(const Context *context,
+bool ValidateVertexAttribP3uiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                GLenum type,
                                GLboolean normalized,
                                const GLuint *value);
-bool ValidateVertexAttribP4ui(const Context *context,
+bool ValidateVertexAttribP4ui(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               GLenum type,
                               GLboolean normalized,
                               GLuint value);
-bool ValidateVertexAttribP4uiv(const Context *context,
+bool ValidateVertexAttribP4uiv(const PrivateState &state,
+                               ErrorSet *errors,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                GLenum type,
diff --git a/src/libANGLE/validationGL4.cpp b/src/libANGLE/validationGL4.cpp
index f4f1c30b9..c1cf8cb9c 100644
--- a/src/libANGLE/validationGL4.cpp
+++ b/src/libANGLE/validationGL4.cpp
@@ -571,7 +571,8 @@ bool ValidateScissorIndexedv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribL1d(const Context *context,
+bool ValidateVertexAttribL1d(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              GLdouble x)
@@ -579,7 +580,8 @@ bool ValidateVertexAttribL1d(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribL1dv(const Context *context,
+bool ValidateVertexAttribL1dv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLdouble *v)
@@ -587,7 +589,8 @@ bool ValidateVertexAttribL1dv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribL2d(const Context *context,
+bool ValidateVertexAttribL2d(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              GLdouble x,
@@ -596,7 +599,8 @@ bool ValidateVertexAttribL2d(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribL2dv(const Context *context,
+bool ValidateVertexAttribL2dv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLdouble *v)
@@ -604,7 +608,8 @@ bool ValidateVertexAttribL2dv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribL3d(const Context *context,
+bool ValidateVertexAttribL3d(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              GLdouble x,
@@ -614,7 +619,8 @@ bool ValidateVertexAttribL3d(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribL3dv(const Context *context,
+bool ValidateVertexAttribL3dv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLdouble *v)
@@ -622,7 +628,8 @@ bool ValidateVertexAttribL3dv(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribL4d(const Context *context,
+bool ValidateVertexAttribL4d(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              GLdouble x,
@@ -633,7 +640,8 @@ bool ValidateVertexAttribL4d(const Context *context,
     return true;
 }
 
-bool ValidateVertexAttribL4dv(const Context *context,
+bool ValidateVertexAttribL4dv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLdouble *v)
@@ -1088,7 +1096,8 @@ bool ValidateClearNamedFramebufferuiv(const Context *context,
     return true;
 }
 
-bool ValidateClipControl(const Context *context,
+bool ValidateClipControl(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          ClipOrigin originPacked,
                          ClipDepthMode depthPacked)
@@ -2200,7 +2209,8 @@ bool ValidateMultiDrawElementsIndirectCount(const Context *context,
     return true;
 }
 
-bool ValidatePolygonOffsetClamp(const Context *context,
+bool ValidatePolygonOffsetClamp(const PrivateState &state,
+                                ErrorSet *errors,
                                 angle::EntryPoint entryPoint,
                                 GLfloat factor,
                                 GLfloat units,
diff --git a/src/libANGLE/validationGL4_autogen.h b/src/libANGLE/validationGL4_autogen.h
index a1db9124f..4b5dd2da5 100644
--- a/src/libANGLE/validationGL4_autogen.h
+++ b/src/libANGLE/validationGL4_autogen.h
@@ -17,6 +17,8 @@
 namespace gl
 {
 class Context;
+class PrivateState;
+class ErrorSet;
 
 // GL 4.0
 bool ValidateBeginQueryIndexed(const Context *context,
@@ -353,41 +355,49 @@ bool ValidateScissorIndexedv(const Context *context,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLint *v);
-bool ValidateVertexAttribL1d(const Context *context,
+bool ValidateVertexAttribL1d(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              GLdouble x);
-bool ValidateVertexAttribL1dv(const Context *context,
+bool ValidateVertexAttribL1dv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLdouble *v);
-bool ValidateVertexAttribL2d(const Context *context,
+bool ValidateVertexAttribL2d(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              GLdouble x,
                              GLdouble y);
-bool ValidateVertexAttribL2dv(const Context *context,
+bool ValidateVertexAttribL2dv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLdouble *v);
-bool ValidateVertexAttribL3d(const Context *context,
+bool ValidateVertexAttribL3d(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              GLdouble x,
                              GLdouble y,
                              GLdouble z);
-bool ValidateVertexAttribL3dv(const Context *context,
+bool ValidateVertexAttribL3dv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLdouble *v);
-bool ValidateVertexAttribL4d(const Context *context,
+bool ValidateVertexAttribL4d(const PrivateState &state,
+                             ErrorSet *errors,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              GLdouble x,
                              GLdouble y,
                              GLdouble z,
                              GLdouble w);
-bool ValidateVertexAttribL4dv(const Context *context,
+bool ValidateVertexAttribL4dv(const PrivateState &state,
+                              ErrorSet *errors,
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLdouble *v);
@@ -678,7 +688,8 @@ bool ValidateClearNamedFramebufferuiv(const Context *context,
                                       GLenum buffer,
                                       GLint drawbuffer,
                                       const GLuint *value);
-bool ValidateClipControl(const Context *context,
+bool ValidateClipControl(const PrivateState &state,
+                         ErrorSet *errors,
                          angle::EntryPoint entryPoint,
                          ClipOrigin originPacked,
                          ClipDepthMode depthPacked);
@@ -1358,7 +1369,8 @@ bool ValidateMultiDrawElementsIndirectCount(const Context *context,
                                             GLintptr drawcount,
                                             GLsizei maxdrawcount,
                                             GLsizei stride);
-bool ValidatePolygonOffsetClamp(const Context *context,
+bool ValidatePolygonOffsetClamp(const PrivateState &state,
+                                ErrorSet *errors,
                                 angle::EntryPoint entryPoint,
                                 GLfloat factor,
                                 GLfloat units,
diff --git a/src/libGLESv2/entry_points_gl_1_autogen.cpp b/src/libGLESv2/entry_points_gl_1_autogen.cpp
index 5ac9c5cbb..96e7ecb3e 100644
--- a/src/libGLESv2/entry_points_gl_1_autogen.cpp
+++ b/src/libGLESv2/entry_points_gl_1_autogen.cpp
@@ -44,7 +44,9 @@ void GL_APIENTRY GL_Accum(GLenum op, GLfloat value)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLAccum) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLAccum) &&
               ValidateAccum(context, angle::EntryPoint::GLAccum, op, value)));
         if (isCallValid)
         {
@@ -70,7 +72,9 @@ void GL_APIENTRY GL_Begin(GLenum mode)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBegin) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBegin) &&
               ValidateBegin(context, angle::EntryPoint::GLBegin, mode)));
         if (isCallValid)
         {
@@ -104,7 +108,9 @@ void GL_APIENTRY GL_Bitmap(GLsizei width,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBitmap) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBitmap) &&
               ValidateBitmap(context, angle::EntryPoint::GLBitmap, width, height, xorig, yorig,
                              xmove, ymove, bitmap)));
         if (isCallValid)
@@ -131,7 +137,9 @@ void GL_APIENTRY GL_CallList(GLuint list)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCallList) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCallList) &&
               ValidateCallList(context, angle::EntryPoint::GLCallList, list)));
         if (isCallValid)
         {
@@ -157,7 +165,9 @@ void GL_APIENTRY GL_CallLists(GLsizei n, GLenum type, const void *lists)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCallLists) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCallLists) &&
               ValidateCallLists(context, angle::EntryPoint::GLCallLists, n, type, lists)));
         if (isCallValid)
         {
@@ -183,7 +193,9 @@ void GL_APIENTRY GL_ClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLClearAccum) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClearAccum) &&
               ValidateClearAccum(context, angle::EntryPoint::GLClearAccum, red, green, blue,
                                  alpha)));
         if (isCallValid)
@@ -209,7 +221,9 @@ void GL_APIENTRY GL_ClearDepth(GLdouble depth)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLClearDepth) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClearDepth) &&
               ValidateClearDepth(context, angle::EntryPoint::GLClearDepth, depth)));
         if (isCallValid)
         {
@@ -234,7 +248,9 @@ void GL_APIENTRY GL_ClearIndex(GLfloat c)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLClearIndex) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClearIndex) &&
               ValidateClearIndex(context, angle::EntryPoint::GLClearIndex, c)));
         if (isCallValid)
         {
@@ -260,7 +276,9 @@ void GL_APIENTRY GL_ClipPlane(GLenum plane, const GLdouble *equation)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLClipPlane) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClipPlane) &&
               ValidateClipPlane(context, angle::EntryPoint::GLClipPlane, plane, equation)));
         if (isCallValid)
         {
@@ -286,7 +304,9 @@ void GL_APIENTRY GL_Color3b(GLbyte red, GLbyte green, GLbyte blue)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor3b) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor3b) &&
               ValidateColor3b(context, angle::EntryPoint::GLColor3b, red, green, blue)));
         if (isCallValid)
         {
@@ -311,7 +331,9 @@ void GL_APIENTRY GL_Color3bv(const GLbyte *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor3bv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor3bv) &&
               ValidateColor3bv(context, angle::EntryPoint::GLColor3bv, v)));
         if (isCallValid)
         {
@@ -337,7 +359,9 @@ void GL_APIENTRY GL_Color3d(GLdouble red, GLdouble green, GLdouble blue)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor3d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor3d) &&
               ValidateColor3d(context, angle::EntryPoint::GLColor3d, red, green, blue)));
         if (isCallValid)
         {
@@ -362,7 +386,9 @@ void GL_APIENTRY GL_Color3dv(const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor3dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor3dv) &&
               ValidateColor3dv(context, angle::EntryPoint::GLColor3dv, v)));
         if (isCallValid)
         {
@@ -388,7 +414,9 @@ void GL_APIENTRY GL_Color3f(GLfloat red, GLfloat green, GLfloat blue)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor3f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor3f) &&
               ValidateColor3f(context, angle::EntryPoint::GLColor3f, red, green, blue)));
         if (isCallValid)
         {
@@ -413,7 +441,9 @@ void GL_APIENTRY GL_Color3fv(const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor3fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor3fv) &&
               ValidateColor3fv(context, angle::EntryPoint::GLColor3fv, v)));
         if (isCallValid)
         {
@@ -439,7 +469,9 @@ void GL_APIENTRY GL_Color3i(GLint red, GLint green, GLint blue)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor3i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor3i) &&
               ValidateColor3i(context, angle::EntryPoint::GLColor3i, red, green, blue)));
         if (isCallValid)
         {
@@ -464,7 +496,9 @@ void GL_APIENTRY GL_Color3iv(const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor3iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor3iv) &&
               ValidateColor3iv(context, angle::EntryPoint::GLColor3iv, v)));
         if (isCallValid)
         {
@@ -490,7 +524,9 @@ void GL_APIENTRY GL_Color3s(GLshort red, GLshort green, GLshort blue)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor3s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor3s) &&
               ValidateColor3s(context, angle::EntryPoint::GLColor3s, red, green, blue)));
         if (isCallValid)
         {
@@ -515,7 +551,9 @@ void GL_APIENTRY GL_Color3sv(const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor3sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor3sv) &&
               ValidateColor3sv(context, angle::EntryPoint::GLColor3sv, v)));
         if (isCallValid)
         {
@@ -541,7 +579,9 @@ void GL_APIENTRY GL_Color3ub(GLubyte red, GLubyte green, GLubyte blue)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor3ub) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor3ub) &&
               ValidateColor3ub(context, angle::EntryPoint::GLColor3ub, red, green, blue)));
         if (isCallValid)
         {
@@ -566,7 +606,9 @@ void GL_APIENTRY GL_Color3ubv(const GLubyte *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor3ubv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor3ubv) &&
               ValidateColor3ubv(context, angle::EntryPoint::GLColor3ubv, v)));
         if (isCallValid)
         {
@@ -592,7 +634,9 @@ void GL_APIENTRY GL_Color3ui(GLuint red, GLuint green, GLuint blue)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor3ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor3ui) &&
               ValidateColor3ui(context, angle::EntryPoint::GLColor3ui, red, green, blue)));
         if (isCallValid)
         {
@@ -617,7 +661,9 @@ void GL_APIENTRY GL_Color3uiv(const GLuint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor3uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor3uiv) &&
               ValidateColor3uiv(context, angle::EntryPoint::GLColor3uiv, v)));
         if (isCallValid)
         {
@@ -643,7 +689,9 @@ void GL_APIENTRY GL_Color3us(GLushort red, GLushort green, GLushort blue)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor3us) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor3us) &&
               ValidateColor3us(context, angle::EntryPoint::GLColor3us, red, green, blue)));
         if (isCallValid)
         {
@@ -668,7 +716,9 @@ void GL_APIENTRY GL_Color3usv(const GLushort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor3usv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor3usv) &&
               ValidateColor3usv(context, angle::EntryPoint::GLColor3usv, v)));
         if (isCallValid)
         {
@@ -694,7 +744,9 @@ void GL_APIENTRY GL_Color4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor4b) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor4b) &&
               ValidateColor4b(context, angle::EntryPoint::GLColor4b, red, green, blue, alpha)));
         if (isCallValid)
         {
@@ -719,7 +771,9 @@ void GL_APIENTRY GL_Color4bv(const GLbyte *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor4bv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor4bv) &&
               ValidateColor4bv(context, angle::EntryPoint::GLColor4bv, v)));
         if (isCallValid)
         {
@@ -745,7 +799,9 @@ void GL_APIENTRY GL_Color4d(GLdouble red, GLdouble green, GLdouble blue, GLdoubl
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor4d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor4d) &&
               ValidateColor4d(context, angle::EntryPoint::GLColor4d, red, green, blue, alpha)));
         if (isCallValid)
         {
@@ -770,7 +826,9 @@ void GL_APIENTRY GL_Color4dv(const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor4dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor4dv) &&
               ValidateColor4dv(context, angle::EntryPoint::GLColor4dv, v)));
         if (isCallValid)
         {
@@ -795,7 +853,9 @@ void GL_APIENTRY GL_Color4fv(const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor4fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor4fv) &&
               ValidateColor4fv(context, angle::EntryPoint::GLColor4fv, v)));
         if (isCallValid)
         {
@@ -821,7 +881,9 @@ void GL_APIENTRY GL_Color4i(GLint red, GLint green, GLint blue, GLint alpha)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor4i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor4i) &&
               ValidateColor4i(context, angle::EntryPoint::GLColor4i, red, green, blue, alpha)));
         if (isCallValid)
         {
@@ -846,7 +908,9 @@ void GL_APIENTRY GL_Color4iv(const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor4iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor4iv) &&
               ValidateColor4iv(context, angle::EntryPoint::GLColor4iv, v)));
         if (isCallValid)
         {
@@ -872,7 +936,9 @@ void GL_APIENTRY GL_Color4s(GLshort red, GLshort green, GLshort blue, GLshort al
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor4s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor4s) &&
               ValidateColor4s(context, angle::EntryPoint::GLColor4s, red, green, blue, alpha)));
         if (isCallValid)
         {
@@ -897,7 +963,9 @@ void GL_APIENTRY GL_Color4sv(const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor4sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor4sv) &&
               ValidateColor4sv(context, angle::EntryPoint::GLColor4sv, v)));
         if (isCallValid)
         {
@@ -922,7 +990,9 @@ void GL_APIENTRY GL_Color4ubv(const GLubyte *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor4ubv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor4ubv) &&
               ValidateColor4ubv(context, angle::EntryPoint::GLColor4ubv, v)));
         if (isCallValid)
         {
@@ -948,7 +1018,9 @@ void GL_APIENTRY GL_Color4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor4ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor4ui) &&
               ValidateColor4ui(context, angle::EntryPoint::GLColor4ui, red, green, blue, alpha)));
         if (isCallValid)
         {
@@ -973,7 +1045,9 @@ void GL_APIENTRY GL_Color4uiv(const GLuint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor4uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor4uiv) &&
               ValidateColor4uiv(context, angle::EntryPoint::GLColor4uiv, v)));
         if (isCallValid)
         {
@@ -999,7 +1073,9 @@ void GL_APIENTRY GL_Color4us(GLushort red, GLushort green, GLushort blue, GLusho
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor4us) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor4us) &&
               ValidateColor4us(context, angle::EntryPoint::GLColor4us, red, green, blue, alpha)));
         if (isCallValid)
         {
@@ -1024,7 +1100,9 @@ void GL_APIENTRY GL_Color4usv(const GLushort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor4usv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor4usv) &&
               ValidateColor4usv(context, angle::EntryPoint::GLColor4usv, v)));
         if (isCallValid)
         {
@@ -1051,7 +1129,9 @@ void GL_APIENTRY GL_ColorMaterial(GLenum face, GLenum mode)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColorMaterial) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColorMaterial) &&
               ValidateColorMaterial(context, angle::EntryPoint::GLColorMaterial, face, mode)));
         if (isCallValid)
         {
@@ -1077,7 +1157,9 @@ void GL_APIENTRY GL_CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCopyPixels) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCopyPixels) &&
               ValidateCopyPixels(context, angle::EntryPoint::GLCopyPixels, x, y, width, height,
                                  type)));
         if (isCallValid)
@@ -1127,7 +1209,9 @@ void GL_APIENTRY GL_DepthRange(GLdouble n, GLdouble f)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDepthRange) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDepthRange) &&
               ValidateDepthRange(context, angle::EntryPoint::GLDepthRange, n, f)));
         if (isCallValid)
         {
@@ -1153,7 +1237,9 @@ void GL_APIENTRY GL_DrawBuffer(GLenum buf)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDrawBuffer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDrawBuffer) &&
               ValidateDrawBuffer(context, angle::EntryPoint::GLDrawBuffer, buf)));
         if (isCallValid)
         {
@@ -1183,7 +1269,9 @@ GL_DrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const v
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDrawPixels) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDrawPixels) &&
               ValidateDrawPixels(context, angle::EntryPoint::GLDrawPixels, width, height, format,
                                  type, pixels)));
         if (isCallValid)
@@ -1209,7 +1297,9 @@ void GL_APIENTRY GL_EdgeFlag(GLboolean flag)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEdgeFlag) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEdgeFlag) &&
               ValidateEdgeFlag(context, angle::EntryPoint::GLEdgeFlag, flag)));
         if (isCallValid)
         {
@@ -1235,7 +1325,9 @@ void GL_APIENTRY GL_EdgeFlagv(const GLboolean *flag)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEdgeFlagv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEdgeFlagv) &&
               ValidateEdgeFlagv(context, angle::EntryPoint::GLEdgeFlagv, flag)));
         if (isCallValid)
         {
@@ -1258,9 +1350,12 @@ void GL_APIENTRY GL_End()
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEnd) &&
-                             ValidateEnd(context, angle::EntryPoint::GLEnd)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEnd) &&
+              ValidateEnd(context, angle::EntryPoint::GLEnd)));
         if (isCallValid)
         {
             context->end();
@@ -1284,7 +1379,9 @@ void GL_APIENTRY GL_EndList()
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEndList) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEndList) &&
               ValidateEndList(context, angle::EntryPoint::GLEndList)));
         if (isCallValid)
         {
@@ -1309,7 +1406,9 @@ void GL_APIENTRY GL_EvalCoord1d(GLdouble u)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEvalCoord1d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEvalCoord1d) &&
               ValidateEvalCoord1d(context, angle::EntryPoint::GLEvalCoord1d, u)));
         if (isCallValid)
         {
@@ -1335,7 +1434,9 @@ void GL_APIENTRY GL_EvalCoord1dv(const GLdouble *u)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEvalCoord1dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEvalCoord1dv) &&
               ValidateEvalCoord1dv(context, angle::EntryPoint::GLEvalCoord1dv, u)));
         if (isCallValid)
         {
@@ -1360,7 +1461,9 @@ void GL_APIENTRY GL_EvalCoord1f(GLfloat u)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEvalCoord1f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEvalCoord1f) &&
               ValidateEvalCoord1f(context, angle::EntryPoint::GLEvalCoord1f, u)));
         if (isCallValid)
         {
@@ -1386,7 +1489,9 @@ void GL_APIENTRY GL_EvalCoord1fv(const GLfloat *u)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEvalCoord1fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEvalCoord1fv) &&
               ValidateEvalCoord1fv(context, angle::EntryPoint::GLEvalCoord1fv, u)));
         if (isCallValid)
         {
@@ -1411,7 +1516,9 @@ void GL_APIENTRY GL_EvalCoord2d(GLdouble u, GLdouble v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEvalCoord2d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEvalCoord2d) &&
               ValidateEvalCoord2d(context, angle::EntryPoint::GLEvalCoord2d, u, v)));
         if (isCallValid)
         {
@@ -1437,7 +1544,9 @@ void GL_APIENTRY GL_EvalCoord2dv(const GLdouble *u)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEvalCoord2dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEvalCoord2dv) &&
               ValidateEvalCoord2dv(context, angle::EntryPoint::GLEvalCoord2dv, u)));
         if (isCallValid)
         {
@@ -1462,7 +1571,9 @@ void GL_APIENTRY GL_EvalCoord2f(GLfloat u, GLfloat v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEvalCoord2f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEvalCoord2f) &&
               ValidateEvalCoord2f(context, angle::EntryPoint::GLEvalCoord2f, u, v)));
         if (isCallValid)
         {
@@ -1488,7 +1599,9 @@ void GL_APIENTRY GL_EvalCoord2fv(const GLfloat *u)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEvalCoord2fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEvalCoord2fv) &&
               ValidateEvalCoord2fv(context, angle::EntryPoint::GLEvalCoord2fv, u)));
         if (isCallValid)
         {
@@ -1514,7 +1627,9 @@ void GL_APIENTRY GL_EvalMesh1(GLenum mode, GLint i1, GLint i2)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEvalMesh1) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEvalMesh1) &&
               ValidateEvalMesh1(context, angle::EntryPoint::GLEvalMesh1, mode, i1, i2)));
         if (isCallValid)
         {
@@ -1540,7 +1655,9 @@ void GL_APIENTRY GL_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEvalMesh2) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEvalMesh2) &&
               ValidateEvalMesh2(context, angle::EntryPoint::GLEvalMesh2, mode, i1, i2, j1, j2)));
         if (isCallValid)
         {
@@ -1565,7 +1682,9 @@ void GL_APIENTRY GL_EvalPoint1(GLint i)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEvalPoint1) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEvalPoint1) &&
               ValidateEvalPoint1(context, angle::EntryPoint::GLEvalPoint1, i)));
         if (isCallValid)
         {
@@ -1590,7 +1709,9 @@ void GL_APIENTRY GL_EvalPoint2(GLint i, GLint j)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEvalPoint2) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEvalPoint2) &&
               ValidateEvalPoint2(context, angle::EntryPoint::GLEvalPoint2, i, j)));
         if (isCallValid)
         {
@@ -1617,7 +1738,9 @@ void GL_APIENTRY GL_FeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFeedbackBuffer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFeedbackBuffer) &&
               ValidateFeedbackBuffer(context, angle::EntryPoint::GLFeedbackBuffer, size, type,
                                      buffer)));
         if (isCallValid)
@@ -1644,7 +1767,9 @@ void GL_APIENTRY GL_Fogi(GLenum pname, GLint param)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFogi) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFogi) &&
               ValidateFogi(context, angle::EntryPoint::GLFogi, pname, param)));
         if (isCallValid)
         {
@@ -1670,7 +1795,9 @@ void GL_APIENTRY GL_Fogiv(GLenum pname, const GLint *params)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFogiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFogiv) &&
               ValidateFogiv(context, angle::EntryPoint::GLFogiv, pname, params)));
         if (isCallValid)
         {
@@ -1702,7 +1829,9 @@ void GL_APIENTRY GL_Frustum(GLdouble left,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFrustum) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFrustum) &&
               ValidateFrustum(context, angle::EntryPoint::GLFrustum, left, right, bottom, top,
                               zNear, zFar)));
         if (isCallValid)
@@ -2152,7 +2281,9 @@ void GL_APIENTRY GL_IndexMask(GLuint mask)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLIndexMask) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLIndexMask) &&
               ValidateIndexMask(context, angle::EntryPoint::GLIndexMask, mask)));
         if (isCallValid)
         {
@@ -2177,7 +2308,9 @@ void GL_APIENTRY GL_Indexd(GLdouble c)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLIndexd) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLIndexd) &&
               ValidateIndexd(context, angle::EntryPoint::GLIndexd, c)));
         if (isCallValid)
         {
@@ -2202,7 +2335,9 @@ void GL_APIENTRY GL_Indexdv(const GLdouble *c)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLIndexdv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLIndexdv) &&
               ValidateIndexdv(context, angle::EntryPoint::GLIndexdv, c)));
         if (isCallValid)
         {
@@ -2227,7 +2362,9 @@ void GL_APIENTRY GL_Indexf(GLfloat c)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLIndexf) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLIndexf) &&
               ValidateIndexf(context, angle::EntryPoint::GLIndexf, c)));
         if (isCallValid)
         {
@@ -2252,7 +2389,9 @@ void GL_APIENTRY GL_Indexfv(const GLfloat *c)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLIndexfv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLIndexfv) &&
               ValidateIndexfv(context, angle::EntryPoint::GLIndexfv, c)));
         if (isCallValid)
         {
@@ -2277,7 +2416,9 @@ void GL_APIENTRY GL_Indexi(GLint c)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLIndexi) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLIndexi) &&
               ValidateIndexi(context, angle::EntryPoint::GLIndexi, c)));
         if (isCallValid)
         {
@@ -2302,7 +2443,9 @@ void GL_APIENTRY GL_Indexiv(const GLint *c)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLIndexiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLIndexiv) &&
               ValidateIndexiv(context, angle::EntryPoint::GLIndexiv, c)));
         if (isCallValid)
         {
@@ -2327,7 +2470,9 @@ void GL_APIENTRY GL_Indexs(GLshort c)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLIndexs) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLIndexs) &&
               ValidateIndexs(context, angle::EntryPoint::GLIndexs, c)));
         if (isCallValid)
         {
@@ -2352,7 +2497,9 @@ void GL_APIENTRY GL_Indexsv(const GLshort *c)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLIndexsv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLIndexsv) &&
               ValidateIndexsv(context, angle::EntryPoint::GLIndexsv, c)));
         if (isCallValid)
         {
@@ -2377,7 +2524,9 @@ void GL_APIENTRY GL_InitNames()
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLInitNames) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLInitNames) &&
               ValidateInitNames(context, angle::EntryPoint::GLInitNames)));
         if (isCallValid)
         {
@@ -2433,7 +2582,9 @@ void GL_APIENTRY GL_LightModeli(GLenum pname, GLint param)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLightModeli) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLightModeli) &&
               ValidateLightModeli(context, angle::EntryPoint::GLLightModeli, pname, param)));
         if (isCallValid)
         {
@@ -2459,7 +2610,9 @@ void GL_APIENTRY GL_LightModeliv(GLenum pname, const GLint *params)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLightModeliv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLightModeliv) &&
               ValidateLightModeliv(context, angle::EntryPoint::GLLightModeliv, pname, params)));
         if (isCallValid)
         {
@@ -2486,7 +2639,9 @@ void GL_APIENTRY GL_Lighti(GLenum light, GLenum pname, GLint param)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLighti) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLighti) &&
               ValidateLighti(context, angle::EntryPoint::GLLighti, light, pname, param)));
         if (isCallValid)
         {
@@ -2513,7 +2668,9 @@ void GL_APIENTRY GL_Lightiv(GLenum light, GLenum pname, const GLint *params)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLightiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLightiv) &&
               ValidateLightiv(context, angle::EntryPoint::GLLightiv, light, pname, params)));
         if (isCallValid)
         {
@@ -2539,7 +2696,9 @@ void GL_APIENTRY GL_LineStipple(GLint factor, GLushort pattern)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLineStipple) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLineStipple) &&
               ValidateLineStipple(context, angle::EntryPoint::GLLineStipple, factor, pattern)));
         if (isCallValid)
         {
@@ -2564,7 +2723,9 @@ void GL_APIENTRY GL_ListBase(GLuint base)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLListBase) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLListBase) &&
               ValidateListBase(context, angle::EntryPoint::GLListBase, base)));
         if (isCallValid)
         {
@@ -2590,7 +2751,9 @@ void GL_APIENTRY GL_LoadMatrixd(const GLdouble *m)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLoadMatrixd) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLoadMatrixd) &&
               ValidateLoadMatrixd(context, angle::EntryPoint::GLLoadMatrixd, m)));
         if (isCallValid)
         {
@@ -2615,7 +2778,9 @@ void GL_APIENTRY GL_LoadName(GLuint name)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLoadName) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLoadName) &&
               ValidateLoadName(context, angle::EntryPoint::GLLoadName, name)));
         if (isCallValid)
         {
@@ -2645,7 +2810,9 @@ GL_Map1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, con
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMap1d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMap1d) &&
               ValidateMap1d(context, angle::EntryPoint::GLMap1d, target, u1, u2, stride, order,
                             points)));
         if (isCallValid)
@@ -2676,7 +2843,9 @@ GL_Map1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMap1f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMap1f) &&
               ValidateMap1f(context, angle::EntryPoint::GLMap1f, target, u1, u2, stride, order,
                             points)));
         if (isCallValid)
@@ -2715,7 +2884,9 @@ void GL_APIENTRY GL_Map2d(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMap2d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMap2d) &&
               ValidateMap2d(context, angle::EntryPoint::GLMap2d, target, u1, u2, ustride, uorder,
                             v1, v2, vstride, vorder, points)));
         if (isCallValid)
@@ -2755,7 +2926,9 @@ void GL_APIENTRY GL_Map2f(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMap2f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMap2f) &&
               ValidateMap2f(context, angle::EntryPoint::GLMap2f, target, u1, u2, ustride, uorder,
                             v1, v2, vstride, vorder, points)));
         if (isCallValid)
@@ -2783,7 +2956,9 @@ void GL_APIENTRY GL_MapGrid1d(GLint un, GLdouble u1, GLdouble u2)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMapGrid1d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMapGrid1d) &&
               ValidateMapGrid1d(context, angle::EntryPoint::GLMapGrid1d, un, u1, u2)));
         if (isCallValid)
         {
@@ -2809,7 +2984,9 @@ void GL_APIENTRY GL_MapGrid1f(GLint un, GLfloat u1, GLfloat u2)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMapGrid1f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMapGrid1f) &&
               ValidateMapGrid1f(context, angle::EntryPoint::GLMapGrid1f, un, u1, u2)));
         if (isCallValid)
         {
@@ -2837,7 +3014,9 @@ GL_MapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMapGrid2d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMapGrid2d) &&
               ValidateMapGrid2d(context, angle::EntryPoint::GLMapGrid2d, un, u1, u2, vn, v1, v2)));
         if (isCallValid)
         {
@@ -2864,7 +3043,9 @@ void GL_APIENTRY GL_MapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloa
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMapGrid2f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMapGrid2f) &&
               ValidateMapGrid2f(context, angle::EntryPoint::GLMapGrid2f, un, u1, u2, vn, v1, v2)));
         if (isCallValid)
         {
@@ -2891,7 +3072,9 @@ void GL_APIENTRY GL_Materiali(GLenum face, GLenum pname, GLint param)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMateriali) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMateriali) &&
               ValidateMateriali(context, angle::EntryPoint::GLMateriali, face, pname, param)));
         if (isCallValid)
         {
@@ -2918,7 +3101,9 @@ void GL_APIENTRY GL_Materialiv(GLenum face, GLenum pname, const GLint *params)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMaterialiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMaterialiv) &&
               ValidateMaterialiv(context, angle::EntryPoint::GLMaterialiv, face, pname, params)));
         if (isCallValid)
         {
@@ -2944,7 +3129,9 @@ void GL_APIENTRY GL_MultMatrixd(const GLdouble *m)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultMatrixd) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultMatrixd) &&
               ValidateMultMatrixd(context, angle::EntryPoint::GLMultMatrixd, m)));
         if (isCallValid)
         {
@@ -2970,7 +3157,9 @@ void GL_APIENTRY GL_NewList(GLuint list, GLenum mode)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNewList) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNewList) &&
               ValidateNewList(context, angle::EntryPoint::GLNewList, list, mode)));
         if (isCallValid)
         {
@@ -2995,7 +3184,9 @@ void GL_APIENTRY GL_Normal3b(GLbyte nx, GLbyte ny, GLbyte nz)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNormal3b) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNormal3b) &&
               ValidateNormal3b(context, angle::EntryPoint::GLNormal3b, nx, ny, nz)));
         if (isCallValid)
         {
@@ -3020,7 +3211,9 @@ void GL_APIENTRY GL_Normal3bv(const GLbyte *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNormal3bv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNormal3bv) &&
               ValidateNormal3bv(context, angle::EntryPoint::GLNormal3bv, v)));
         if (isCallValid)
         {
@@ -3045,7 +3238,9 @@ void GL_APIENTRY GL_Normal3d(GLdouble nx, GLdouble ny, GLdouble nz)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNormal3d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNormal3d) &&
               ValidateNormal3d(context, angle::EntryPoint::GLNormal3d, nx, ny, nz)));
         if (isCallValid)
         {
@@ -3070,7 +3265,9 @@ void GL_APIENTRY GL_Normal3dv(const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNormal3dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNormal3dv) &&
               ValidateNormal3dv(context, angle::EntryPoint::GLNormal3dv, v)));
         if (isCallValid)
         {
@@ -3095,7 +3292,9 @@ void GL_APIENTRY GL_Normal3fv(const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNormal3fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNormal3fv) &&
               ValidateNormal3fv(context, angle::EntryPoint::GLNormal3fv, v)));
         if (isCallValid)
         {
@@ -3120,7 +3319,9 @@ void GL_APIENTRY GL_Normal3i(GLint nx, GLint ny, GLint nz)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNormal3i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNormal3i) &&
               ValidateNormal3i(context, angle::EntryPoint::GLNormal3i, nx, ny, nz)));
         if (isCallValid)
         {
@@ -3145,7 +3346,9 @@ void GL_APIENTRY GL_Normal3iv(const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNormal3iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNormal3iv) &&
               ValidateNormal3iv(context, angle::EntryPoint::GLNormal3iv, v)));
         if (isCallValid)
         {
@@ -3170,7 +3373,9 @@ void GL_APIENTRY GL_Normal3s(GLshort nx, GLshort ny, GLshort nz)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNormal3s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNormal3s) &&
               ValidateNormal3s(context, angle::EntryPoint::GLNormal3s, nx, ny, nz)));
         if (isCallValid)
         {
@@ -3195,7 +3400,9 @@ void GL_APIENTRY GL_Normal3sv(const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNormal3sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNormal3sv) &&
               ValidateNormal3sv(context, angle::EntryPoint::GLNormal3sv, v)));
         if (isCallValid)
         {
@@ -3227,7 +3434,9 @@ void GL_APIENTRY GL_Ortho(GLdouble left,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLOrtho) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLOrtho) &&
               ValidateOrtho(context, angle::EntryPoint::GLOrtho, left, right, bottom, top, zNear,
                             zFar)));
         if (isCallValid)
@@ -3253,7 +3462,9 @@ void GL_APIENTRY GL_PassThrough(GLfloat token)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPassThrough) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPassThrough) &&
               ValidatePassThrough(context, angle::EntryPoint::GLPassThrough, token)));
         if (isCallValid)
         {
@@ -3279,7 +3490,9 @@ void GL_APIENTRY GL_PixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *value
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPixelMapfv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPixelMapfv) &&
               ValidatePixelMapfv(context, angle::EntryPoint::GLPixelMapfv, map, mapsize, values)));
         if (isCallValid)
         {
@@ -3306,7 +3519,9 @@ void GL_APIENTRY GL_PixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *value
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPixelMapuiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPixelMapuiv) &&
               ValidatePixelMapuiv(context, angle::EntryPoint::GLPixelMapuiv, map, mapsize,
                                   values)));
         if (isCallValid)
@@ -3334,7 +3549,9 @@ void GL_APIENTRY GL_PixelMapusv(GLenum map, GLsizei mapsize, const GLushort *val
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPixelMapusv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPixelMapusv) &&
               ValidatePixelMapusv(context, angle::EntryPoint::GLPixelMapusv, map, mapsize,
                                   values)));
         if (isCallValid)
@@ -3361,7 +3578,9 @@ void GL_APIENTRY GL_PixelStoref(GLenum pname, GLfloat param)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPixelStoref) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPixelStoref) &&
               ValidatePixelStoref(context, angle::EntryPoint::GLPixelStoref, pname, param)));
         if (isCallValid)
         {
@@ -3387,7 +3606,9 @@ void GL_APIENTRY GL_PixelTransferf(GLenum pname, GLfloat param)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPixelTransferf) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPixelTransferf) &&
               ValidatePixelTransferf(context, angle::EntryPoint::GLPixelTransferf, pname, param)));
         if (isCallValid)
         {
@@ -3413,7 +3634,9 @@ void GL_APIENTRY GL_PixelTransferi(GLenum pname, GLint param)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPixelTransferi) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPixelTransferi) &&
               ValidatePixelTransferi(context, angle::EntryPoint::GLPixelTransferi, pname, param)));
         if (isCallValid)
         {
@@ -3439,7 +3662,9 @@ void GL_APIENTRY GL_PixelZoom(GLfloat xfactor, GLfloat yfactor)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPixelZoom) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPixelZoom) &&
               ValidatePixelZoom(context, angle::EntryPoint::GLPixelZoom, xfactor, yfactor)));
         if (isCallValid)
         {
@@ -3466,8 +3691,12 @@ void GL_APIENTRY GL_PolygonMode(GLenum face, GLenum mode)
         PolygonMode modePacked = PackParam<PolygonMode>(mode);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPolygonMode) &&
-              ValidatePolygonMode(context, angle::EntryPoint::GLPolygonMode, face, modePacked)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPolygonMode) &&
+              ValidatePolygonMode(context->getPrivateState(),
+                                  context->getMutableErrorSetForValidation(),
+                                  angle::EntryPoint::GLPolygonMode, face, modePacked)));
         if (isCallValid)
         {
             ContextPrivatePolygonMode(context->getMutablePrivateState(),
@@ -3493,7 +3722,9 @@ void GL_APIENTRY GL_PolygonStipple(const GLubyte *mask)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPolygonStipple) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPolygonStipple) &&
               ValidatePolygonStipple(context, angle::EntryPoint::GLPolygonStipple, mask)));
         if (isCallValid)
         {
@@ -3518,7 +3749,9 @@ void GL_APIENTRY GL_PopAttrib()
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPopAttrib) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPopAttrib) &&
               ValidatePopAttrib(context, angle::EntryPoint::GLPopAttrib)));
         if (isCallValid)
         {
@@ -3543,7 +3776,9 @@ void GL_APIENTRY GL_PopName()
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPopName) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPopName) &&
               ValidatePopName(context, angle::EntryPoint::GLPopName)));
         if (isCallValid)
         {
@@ -3569,7 +3804,9 @@ void GL_APIENTRY GL_PushAttrib(GLbitfield mask)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPushAttrib) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPushAttrib) &&
               ValidatePushAttrib(context, angle::EntryPoint::GLPushAttrib, mask)));
         if (isCallValid)
         {
@@ -3594,7 +3831,9 @@ void GL_APIENTRY GL_PushName(GLuint name)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPushName) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPushName) &&
               ValidatePushName(context, angle::EntryPoint::GLPushName, name)));
         if (isCallValid)
         {
@@ -3619,7 +3858,9 @@ void GL_APIENTRY GL_RasterPos2d(GLdouble x, GLdouble y)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos2d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos2d) &&
               ValidateRasterPos2d(context, angle::EntryPoint::GLRasterPos2d, x, y)));
         if (isCallValid)
         {
@@ -3645,7 +3886,9 @@ void GL_APIENTRY GL_RasterPos2dv(const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos2dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos2dv) &&
               ValidateRasterPos2dv(context, angle::EntryPoint::GLRasterPos2dv, v)));
         if (isCallValid)
         {
@@ -3670,7 +3913,9 @@ void GL_APIENTRY GL_RasterPos2f(GLfloat x, GLfloat y)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos2f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos2f) &&
               ValidateRasterPos2f(context, angle::EntryPoint::GLRasterPos2f, x, y)));
         if (isCallValid)
         {
@@ -3696,7 +3941,9 @@ void GL_APIENTRY GL_RasterPos2fv(const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos2fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos2fv) &&
               ValidateRasterPos2fv(context, angle::EntryPoint::GLRasterPos2fv, v)));
         if (isCallValid)
         {
@@ -3721,7 +3968,9 @@ void GL_APIENTRY GL_RasterPos2i(GLint x, GLint y)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos2i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos2i) &&
               ValidateRasterPos2i(context, angle::EntryPoint::GLRasterPos2i, x, y)));
         if (isCallValid)
         {
@@ -3747,7 +3996,9 @@ void GL_APIENTRY GL_RasterPos2iv(const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos2iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos2iv) &&
               ValidateRasterPos2iv(context, angle::EntryPoint::GLRasterPos2iv, v)));
         if (isCallValid)
         {
@@ -3772,7 +4023,9 @@ void GL_APIENTRY GL_RasterPos2s(GLshort x, GLshort y)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos2s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos2s) &&
               ValidateRasterPos2s(context, angle::EntryPoint::GLRasterPos2s, x, y)));
         if (isCallValid)
         {
@@ -3798,7 +4051,9 @@ void GL_APIENTRY GL_RasterPos2sv(const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos2sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos2sv) &&
               ValidateRasterPos2sv(context, angle::EntryPoint::GLRasterPos2sv, v)));
         if (isCallValid)
         {
@@ -3823,7 +4078,9 @@ void GL_APIENTRY GL_RasterPos3d(GLdouble x, GLdouble y, GLdouble z)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos3d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos3d) &&
               ValidateRasterPos3d(context, angle::EntryPoint::GLRasterPos3d, x, y, z)));
         if (isCallValid)
         {
@@ -3849,7 +4106,9 @@ void GL_APIENTRY GL_RasterPos3dv(const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos3dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos3dv) &&
               ValidateRasterPos3dv(context, angle::EntryPoint::GLRasterPos3dv, v)));
         if (isCallValid)
         {
@@ -3874,7 +4133,9 @@ void GL_APIENTRY GL_RasterPos3f(GLfloat x, GLfloat y, GLfloat z)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos3f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos3f) &&
               ValidateRasterPos3f(context, angle::EntryPoint::GLRasterPos3f, x, y, z)));
         if (isCallValid)
         {
@@ -3900,7 +4161,9 @@ void GL_APIENTRY GL_RasterPos3fv(const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos3fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos3fv) &&
               ValidateRasterPos3fv(context, angle::EntryPoint::GLRasterPos3fv, v)));
         if (isCallValid)
         {
@@ -3925,7 +4188,9 @@ void GL_APIENTRY GL_RasterPos3i(GLint x, GLint y, GLint z)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos3i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos3i) &&
               ValidateRasterPos3i(context, angle::EntryPoint::GLRasterPos3i, x, y, z)));
         if (isCallValid)
         {
@@ -3951,7 +4216,9 @@ void GL_APIENTRY GL_RasterPos3iv(const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos3iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos3iv) &&
               ValidateRasterPos3iv(context, angle::EntryPoint::GLRasterPos3iv, v)));
         if (isCallValid)
         {
@@ -3976,7 +4243,9 @@ void GL_APIENTRY GL_RasterPos3s(GLshort x, GLshort y, GLshort z)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos3s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos3s) &&
               ValidateRasterPos3s(context, angle::EntryPoint::GLRasterPos3s, x, y, z)));
         if (isCallValid)
         {
@@ -4002,7 +4271,9 @@ void GL_APIENTRY GL_RasterPos3sv(const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos3sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos3sv) &&
               ValidateRasterPos3sv(context, angle::EntryPoint::GLRasterPos3sv, v)));
         if (isCallValid)
         {
@@ -4028,7 +4299,9 @@ void GL_APIENTRY GL_RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos4d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos4d) &&
               ValidateRasterPos4d(context, angle::EntryPoint::GLRasterPos4d, x, y, z, w)));
         if (isCallValid)
         {
@@ -4054,7 +4327,9 @@ void GL_APIENTRY GL_RasterPos4dv(const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos4dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos4dv) &&
               ValidateRasterPos4dv(context, angle::EntryPoint::GLRasterPos4dv, v)));
         if (isCallValid)
         {
@@ -4080,7 +4355,9 @@ void GL_APIENTRY GL_RasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos4f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos4f) &&
               ValidateRasterPos4f(context, angle::EntryPoint::GLRasterPos4f, x, y, z, w)));
         if (isCallValid)
         {
@@ -4106,7 +4383,9 @@ void GL_APIENTRY GL_RasterPos4fv(const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos4fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos4fv) &&
               ValidateRasterPos4fv(context, angle::EntryPoint::GLRasterPos4fv, v)));
         if (isCallValid)
         {
@@ -4132,7 +4411,9 @@ void GL_APIENTRY GL_RasterPos4i(GLint x, GLint y, GLint z, GLint w)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos4i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos4i) &&
               ValidateRasterPos4i(context, angle::EntryPoint::GLRasterPos4i, x, y, z, w)));
         if (isCallValid)
         {
@@ -4158,7 +4439,9 @@ void GL_APIENTRY GL_RasterPos4iv(const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos4iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos4iv) &&
               ValidateRasterPos4iv(context, angle::EntryPoint::GLRasterPos4iv, v)));
         if (isCallValid)
         {
@@ -4184,7 +4467,9 @@ void GL_APIENTRY GL_RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos4s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos4s) &&
               ValidateRasterPos4s(context, angle::EntryPoint::GLRasterPos4s, x, y, z, w)));
         if (isCallValid)
         {
@@ -4210,7 +4495,9 @@ void GL_APIENTRY GL_RasterPos4sv(const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRasterPos4sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRasterPos4sv) &&
               ValidateRasterPos4sv(context, angle::EntryPoint::GLRasterPos4sv, v)));
         if (isCallValid)
         {
@@ -4236,7 +4523,9 @@ void GL_APIENTRY GL_Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRectd) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRectd) &&
               ValidateRectd(context, angle::EntryPoint::GLRectd, x1, y1, x2, y2)));
         if (isCallValid)
         {
@@ -4262,7 +4551,9 @@ void GL_APIENTRY GL_Rectdv(const GLdouble *v1, const GLdouble *v2)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRectdv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRectdv) &&
               ValidateRectdv(context, angle::EntryPoint::GLRectdv, v1, v2)));
         if (isCallValid)
         {
@@ -4288,7 +4579,9 @@ void GL_APIENTRY GL_Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRectf) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRectf) &&
               ValidateRectf(context, angle::EntryPoint::GLRectf, x1, y1, x2, y2)));
         if (isCallValid)
         {
@@ -4314,7 +4607,9 @@ void GL_APIENTRY GL_Rectfv(const GLfloat *v1, const GLfloat *v2)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRectfv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRectfv) &&
               ValidateRectfv(context, angle::EntryPoint::GLRectfv, v1, v2)));
         if (isCallValid)
         {
@@ -4340,7 +4635,9 @@ void GL_APIENTRY GL_Recti(GLint x1, GLint y1, GLint x2, GLint y2)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRecti) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRecti) &&
               ValidateRecti(context, angle::EntryPoint::GLRecti, x1, y1, x2, y2)));
         if (isCallValid)
         {
@@ -4366,7 +4663,9 @@ void GL_APIENTRY GL_Rectiv(const GLint *v1, const GLint *v2)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRectiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRectiv) &&
               ValidateRectiv(context, angle::EntryPoint::GLRectiv, v1, v2)));
         if (isCallValid)
         {
@@ -4392,7 +4691,9 @@ void GL_APIENTRY GL_Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRects) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRects) &&
               ValidateRects(context, angle::EntryPoint::GLRects, x1, y1, x2, y2)));
         if (isCallValid)
         {
@@ -4418,7 +4719,9 @@ void GL_APIENTRY GL_Rectsv(const GLshort *v1, const GLshort *v2)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRectsv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRectsv) &&
               ValidateRectsv(context, angle::EntryPoint::GLRectsv, v1, v2)));
         if (isCallValid)
         {
@@ -4445,7 +4748,9 @@ GLint GL_APIENTRY GL_RenderMode(GLenum mode)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRenderMode) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRenderMode) &&
               ValidateRenderMode(context, angle::EntryPoint::GLRenderMode, mode)));
         if (isCallValid)
         {
@@ -4477,7 +4782,9 @@ void GL_APIENTRY GL_Rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRotated) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRotated) &&
               ValidateRotated(context, angle::EntryPoint::GLRotated, angle, x, y, z)));
         if (isCallValid)
         {
@@ -4502,7 +4809,9 @@ void GL_APIENTRY GL_Scaled(GLdouble x, GLdouble y, GLdouble z)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLScaled) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLScaled) &&
               ValidateScaled(context, angle::EntryPoint::GLScaled, x, y, z)));
         if (isCallValid)
         {
@@ -4528,7 +4837,9 @@ void GL_APIENTRY GL_SelectBuffer(GLsizei size, GLuint *buffer)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSelectBuffer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSelectBuffer) &&
               ValidateSelectBuffer(context, angle::EntryPoint::GLSelectBuffer, size, buffer)));
         if (isCallValid)
         {
@@ -4553,7 +4864,9 @@ void GL_APIENTRY GL_TexCoord1d(GLdouble s)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord1d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord1d) &&
               ValidateTexCoord1d(context, angle::EntryPoint::GLTexCoord1d, s)));
         if (isCallValid)
         {
@@ -4579,7 +4892,9 @@ void GL_APIENTRY GL_TexCoord1dv(const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord1dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord1dv) &&
               ValidateTexCoord1dv(context, angle::EntryPoint::GLTexCoord1dv, v)));
         if (isCallValid)
         {
@@ -4604,7 +4919,9 @@ void GL_APIENTRY GL_TexCoord1f(GLfloat s)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord1f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord1f) &&
               ValidateTexCoord1f(context, angle::EntryPoint::GLTexCoord1f, s)));
         if (isCallValid)
         {
@@ -4630,7 +4947,9 @@ void GL_APIENTRY GL_TexCoord1fv(const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord1fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord1fv) &&
               ValidateTexCoord1fv(context, angle::EntryPoint::GLTexCoord1fv, v)));
         if (isCallValid)
         {
@@ -4655,7 +4974,9 @@ void GL_APIENTRY GL_TexCoord1i(GLint s)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord1i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord1i) &&
               ValidateTexCoord1i(context, angle::EntryPoint::GLTexCoord1i, s)));
         if (isCallValid)
         {
@@ -4681,7 +5002,9 @@ void GL_APIENTRY GL_TexCoord1iv(const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord1iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord1iv) &&
               ValidateTexCoord1iv(context, angle::EntryPoint::GLTexCoord1iv, v)));
         if (isCallValid)
         {
@@ -4706,7 +5029,9 @@ void GL_APIENTRY GL_TexCoord1s(GLshort s)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord1s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord1s) &&
               ValidateTexCoord1s(context, angle::EntryPoint::GLTexCoord1s, s)));
         if (isCallValid)
         {
@@ -4732,7 +5057,9 @@ void GL_APIENTRY GL_TexCoord1sv(const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord1sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord1sv) &&
               ValidateTexCoord1sv(context, angle::EntryPoint::GLTexCoord1sv, v)));
         if (isCallValid)
         {
@@ -4757,7 +5084,9 @@ void GL_APIENTRY GL_TexCoord2d(GLdouble s, GLdouble t)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord2d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord2d) &&
               ValidateTexCoord2d(context, angle::EntryPoint::GLTexCoord2d, s, t)));
         if (isCallValid)
         {
@@ -4783,7 +5112,9 @@ void GL_APIENTRY GL_TexCoord2dv(const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord2dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord2dv) &&
               ValidateTexCoord2dv(context, angle::EntryPoint::GLTexCoord2dv, v)));
         if (isCallValid)
         {
@@ -4808,7 +5139,9 @@ void GL_APIENTRY GL_TexCoord2f(GLfloat s, GLfloat t)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord2f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord2f) &&
               ValidateTexCoord2f(context, angle::EntryPoint::GLTexCoord2f, s, t)));
         if (isCallValid)
         {
@@ -4834,7 +5167,9 @@ void GL_APIENTRY GL_TexCoord2fv(const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord2fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord2fv) &&
               ValidateTexCoord2fv(context, angle::EntryPoint::GLTexCoord2fv, v)));
         if (isCallValid)
         {
@@ -4859,7 +5194,9 @@ void GL_APIENTRY GL_TexCoord2i(GLint s, GLint t)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord2i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord2i) &&
               ValidateTexCoord2i(context, angle::EntryPoint::GLTexCoord2i, s, t)));
         if (isCallValid)
         {
@@ -4885,7 +5222,9 @@ void GL_APIENTRY GL_TexCoord2iv(const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord2iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord2iv) &&
               ValidateTexCoord2iv(context, angle::EntryPoint::GLTexCoord2iv, v)));
         if (isCallValid)
         {
@@ -4910,7 +5249,9 @@ void GL_APIENTRY GL_TexCoord2s(GLshort s, GLshort t)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord2s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord2s) &&
               ValidateTexCoord2s(context, angle::EntryPoint::GLTexCoord2s, s, t)));
         if (isCallValid)
         {
@@ -4936,7 +5277,9 @@ void GL_APIENTRY GL_TexCoord2sv(const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord2sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord2sv) &&
               ValidateTexCoord2sv(context, angle::EntryPoint::GLTexCoord2sv, v)));
         if (isCallValid)
         {
@@ -4961,7 +5304,9 @@ void GL_APIENTRY GL_TexCoord3d(GLdouble s, GLdouble t, GLdouble r)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord3d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord3d) &&
               ValidateTexCoord3d(context, angle::EntryPoint::GLTexCoord3d, s, t, r)));
         if (isCallValid)
         {
@@ -4987,7 +5332,9 @@ void GL_APIENTRY GL_TexCoord3dv(const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord3dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord3dv) &&
               ValidateTexCoord3dv(context, angle::EntryPoint::GLTexCoord3dv, v)));
         if (isCallValid)
         {
@@ -5012,7 +5359,9 @@ void GL_APIENTRY GL_TexCoord3f(GLfloat s, GLfloat t, GLfloat r)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord3f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord3f) &&
               ValidateTexCoord3f(context, angle::EntryPoint::GLTexCoord3f, s, t, r)));
         if (isCallValid)
         {
@@ -5038,7 +5387,9 @@ void GL_APIENTRY GL_TexCoord3fv(const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord3fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord3fv) &&
               ValidateTexCoord3fv(context, angle::EntryPoint::GLTexCoord3fv, v)));
         if (isCallValid)
         {
@@ -5063,7 +5414,9 @@ void GL_APIENTRY GL_TexCoord3i(GLint s, GLint t, GLint r)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord3i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord3i) &&
               ValidateTexCoord3i(context, angle::EntryPoint::GLTexCoord3i, s, t, r)));
         if (isCallValid)
         {
@@ -5089,7 +5442,9 @@ void GL_APIENTRY GL_TexCoord3iv(const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord3iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord3iv) &&
               ValidateTexCoord3iv(context, angle::EntryPoint::GLTexCoord3iv, v)));
         if (isCallValid)
         {
@@ -5114,7 +5469,9 @@ void GL_APIENTRY GL_TexCoord3s(GLshort s, GLshort t, GLshort r)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord3s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord3s) &&
               ValidateTexCoord3s(context, angle::EntryPoint::GLTexCoord3s, s, t, r)));
         if (isCallValid)
         {
@@ -5140,7 +5497,9 @@ void GL_APIENTRY GL_TexCoord3sv(const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord3sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord3sv) &&
               ValidateTexCoord3sv(context, angle::EntryPoint::GLTexCoord3sv, v)));
         if (isCallValid)
         {
@@ -5166,7 +5525,9 @@ void GL_APIENTRY GL_TexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord4d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord4d) &&
               ValidateTexCoord4d(context, angle::EntryPoint::GLTexCoord4d, s, t, r, q)));
         if (isCallValid)
         {
@@ -5192,7 +5553,9 @@ void GL_APIENTRY GL_TexCoord4dv(const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord4dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord4dv) &&
               ValidateTexCoord4dv(context, angle::EntryPoint::GLTexCoord4dv, v)));
         if (isCallValid)
         {
@@ -5218,7 +5581,9 @@ void GL_APIENTRY GL_TexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord4f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord4f) &&
               ValidateTexCoord4f(context, angle::EntryPoint::GLTexCoord4f, s, t, r, q)));
         if (isCallValid)
         {
@@ -5244,7 +5609,9 @@ void GL_APIENTRY GL_TexCoord4fv(const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord4fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord4fv) &&
               ValidateTexCoord4fv(context, angle::EntryPoint::GLTexCoord4fv, v)));
         if (isCallValid)
         {
@@ -5270,7 +5637,9 @@ void GL_APIENTRY GL_TexCoord4i(GLint s, GLint t, GLint r, GLint q)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord4i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord4i) &&
               ValidateTexCoord4i(context, angle::EntryPoint::GLTexCoord4i, s, t, r, q)));
         if (isCallValid)
         {
@@ -5296,7 +5665,9 @@ void GL_APIENTRY GL_TexCoord4iv(const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord4iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord4iv) &&
               ValidateTexCoord4iv(context, angle::EntryPoint::GLTexCoord4iv, v)));
         if (isCallValid)
         {
@@ -5322,7 +5693,9 @@ void GL_APIENTRY GL_TexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord4s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord4s) &&
               ValidateTexCoord4s(context, angle::EntryPoint::GLTexCoord4s, s, t, r, q)));
         if (isCallValid)
         {
@@ -5348,7 +5721,9 @@ void GL_APIENTRY GL_TexCoord4sv(const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoord4sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoord4sv) &&
               ValidateTexCoord4sv(context, angle::EntryPoint::GLTexCoord4sv, v)));
         if (isCallValid)
         {
@@ -5375,7 +5750,9 @@ void GL_APIENTRY GL_TexGend(GLenum coord, GLenum pname, GLdouble param)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexGend) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexGend) &&
               ValidateTexGend(context, angle::EntryPoint::GLTexGend, coord, pname, param)));
         if (isCallValid)
         {
@@ -5402,7 +5779,9 @@ void GL_APIENTRY GL_TexGendv(GLenum coord, GLenum pname, const GLdouble *params)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexGendv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexGendv) &&
               ValidateTexGendv(context, angle::EntryPoint::GLTexGendv, coord, pname, params)));
         if (isCallValid)
         {
@@ -5429,7 +5808,9 @@ void GL_APIENTRY GL_TexGenf(GLenum coord, GLenum pname, GLfloat param)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexGenf) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexGenf) &&
               ValidateTexGenf(context, angle::EntryPoint::GLTexGenf, coord, pname, param)));
         if (isCallValid)
         {
@@ -5456,7 +5837,9 @@ void GL_APIENTRY GL_TexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexGenfv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexGenfv) &&
               ValidateTexGenfv(context, angle::EntryPoint::GLTexGenfv, coord, pname, params)));
         if (isCallValid)
         {
@@ -5483,7 +5866,9 @@ void GL_APIENTRY GL_TexGeni(GLenum coord, GLenum pname, GLint param)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexGeni) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexGeni) &&
               ValidateTexGeni(context, angle::EntryPoint::GLTexGeni, coord, pname, param)));
         if (isCallValid)
         {
@@ -5510,7 +5895,9 @@ void GL_APIENTRY GL_TexGeniv(GLenum coord, GLenum pname, const GLint *params)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexGeniv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexGeniv) &&
               ValidateTexGeniv(context, angle::EntryPoint::GLTexGeniv, coord, pname, params)));
         if (isCallValid)
         {
@@ -5547,7 +5934,9 @@ void GL_APIENTRY GL_TexImage1D(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexImage1D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexImage1D) &&
               ValidateTexImage1D(context, angle::EntryPoint::GLTexImage1D, target, level,
                                  internalformat, width, border, format, type, pixels)));
         if (isCallValid)
@@ -5574,7 +5963,9 @@ void GL_APIENTRY GL_Translated(GLdouble x, GLdouble y, GLdouble z)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTranslated) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTranslated) &&
               ValidateTranslated(context, angle::EntryPoint::GLTranslated, x, y, z)));
         if (isCallValid)
         {
@@ -5599,7 +5990,9 @@ void GL_APIENTRY GL_Vertex2d(GLdouble x, GLdouble y)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex2d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex2d) &&
               ValidateVertex2d(context, angle::EntryPoint::GLVertex2d, x, y)));
         if (isCallValid)
         {
@@ -5624,7 +6017,9 @@ void GL_APIENTRY GL_Vertex2dv(const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex2dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex2dv) &&
               ValidateVertex2dv(context, angle::EntryPoint::GLVertex2dv, v)));
         if (isCallValid)
         {
@@ -5649,7 +6044,9 @@ void GL_APIENTRY GL_Vertex2f(GLfloat x, GLfloat y)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex2f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex2f) &&
               ValidateVertex2f(context, angle::EntryPoint::GLVertex2f, x, y)));
         if (isCallValid)
         {
@@ -5674,7 +6071,9 @@ void GL_APIENTRY GL_Vertex2fv(const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex2fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex2fv) &&
               ValidateVertex2fv(context, angle::EntryPoint::GLVertex2fv, v)));
         if (isCallValid)
         {
@@ -5699,7 +6098,9 @@ void GL_APIENTRY GL_Vertex2i(GLint x, GLint y)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex2i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex2i) &&
               ValidateVertex2i(context, angle::EntryPoint::GLVertex2i, x, y)));
         if (isCallValid)
         {
@@ -5724,7 +6125,9 @@ void GL_APIENTRY GL_Vertex2iv(const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex2iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex2iv) &&
               ValidateVertex2iv(context, angle::EntryPoint::GLVertex2iv, v)));
         if (isCallValid)
         {
@@ -5749,7 +6152,9 @@ void GL_APIENTRY GL_Vertex2s(GLshort x, GLshort y)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex2s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex2s) &&
               ValidateVertex2s(context, angle::EntryPoint::GLVertex2s, x, y)));
         if (isCallValid)
         {
@@ -5774,7 +6179,9 @@ void GL_APIENTRY GL_Vertex2sv(const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex2sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex2sv) &&
               ValidateVertex2sv(context, angle::EntryPoint::GLVertex2sv, v)));
         if (isCallValid)
         {
@@ -5799,7 +6206,9 @@ void GL_APIENTRY GL_Vertex3d(GLdouble x, GLdouble y, GLdouble z)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex3d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex3d) &&
               ValidateVertex3d(context, angle::EntryPoint::GLVertex3d, x, y, z)));
         if (isCallValid)
         {
@@ -5824,7 +6233,9 @@ void GL_APIENTRY GL_Vertex3dv(const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex3dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex3dv) &&
               ValidateVertex3dv(context, angle::EntryPoint::GLVertex3dv, v)));
         if (isCallValid)
         {
@@ -5849,7 +6260,9 @@ void GL_APIENTRY GL_Vertex3f(GLfloat x, GLfloat y, GLfloat z)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex3f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex3f) &&
               ValidateVertex3f(context, angle::EntryPoint::GLVertex3f, x, y, z)));
         if (isCallValid)
         {
@@ -5874,7 +6287,9 @@ void GL_APIENTRY GL_Vertex3fv(const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex3fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex3fv) &&
               ValidateVertex3fv(context, angle::EntryPoint::GLVertex3fv, v)));
         if (isCallValid)
         {
@@ -5899,7 +6314,9 @@ void GL_APIENTRY GL_Vertex3i(GLint x, GLint y, GLint z)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex3i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex3i) &&
               ValidateVertex3i(context, angle::EntryPoint::GLVertex3i, x, y, z)));
         if (isCallValid)
         {
@@ -5924,7 +6341,9 @@ void GL_APIENTRY GL_Vertex3iv(const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex3iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex3iv) &&
               ValidateVertex3iv(context, angle::EntryPoint::GLVertex3iv, v)));
         if (isCallValid)
         {
@@ -5949,7 +6368,9 @@ void GL_APIENTRY GL_Vertex3s(GLshort x, GLshort y, GLshort z)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex3s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex3s) &&
               ValidateVertex3s(context, angle::EntryPoint::GLVertex3s, x, y, z)));
         if (isCallValid)
         {
@@ -5974,7 +6395,9 @@ void GL_APIENTRY GL_Vertex3sv(const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex3sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex3sv) &&
               ValidateVertex3sv(context, angle::EntryPoint::GLVertex3sv, v)));
         if (isCallValid)
         {
@@ -6000,7 +6423,9 @@ void GL_APIENTRY GL_Vertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex4d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex4d) &&
               ValidateVertex4d(context, angle::EntryPoint::GLVertex4d, x, y, z, w)));
         if (isCallValid)
         {
@@ -6025,7 +6450,9 @@ void GL_APIENTRY GL_Vertex4dv(const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex4dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex4dv) &&
               ValidateVertex4dv(context, angle::EntryPoint::GLVertex4dv, v)));
         if (isCallValid)
         {
@@ -6051,7 +6478,9 @@ void GL_APIENTRY GL_Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex4f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex4f) &&
               ValidateVertex4f(context, angle::EntryPoint::GLVertex4f, x, y, z, w)));
         if (isCallValid)
         {
@@ -6076,7 +6505,9 @@ void GL_APIENTRY GL_Vertex4fv(const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex4fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex4fv) &&
               ValidateVertex4fv(context, angle::EntryPoint::GLVertex4fv, v)));
         if (isCallValid)
         {
@@ -6102,7 +6533,9 @@ void GL_APIENTRY GL_Vertex4i(GLint x, GLint y, GLint z, GLint w)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex4i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex4i) &&
               ValidateVertex4i(context, angle::EntryPoint::GLVertex4i, x, y, z, w)));
         if (isCallValid)
         {
@@ -6127,7 +6560,9 @@ void GL_APIENTRY GL_Vertex4iv(const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex4iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex4iv) &&
               ValidateVertex4iv(context, angle::EntryPoint::GLVertex4iv, v)));
         if (isCallValid)
         {
@@ -6153,7 +6588,9 @@ void GL_APIENTRY GL_Vertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex4s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex4s) &&
               ValidateVertex4s(context, angle::EntryPoint::GLVertex4s, x, y, z, w)));
         if (isCallValid)
         {
@@ -6178,7 +6615,9 @@ void GL_APIENTRY GL_Vertex4sv(const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertex4sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertex4sv) &&
               ValidateVertex4sv(context, angle::EntryPoint::GLVertex4sv, v)));
         if (isCallValid)
         {
@@ -6209,7 +6648,8 @@ GLboolean GL_APIENTRY GL_AreTexturesResident(GLsizei n,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLAreTexturesResident) &&
               ValidateAreTexturesResident(context, angle::EntryPoint::GLAreTexturesResident, n,
                                           textures, residences)));
@@ -6244,7 +6684,9 @@ void GL_APIENTRY GL_ArrayElement(GLint i)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLArrayElement) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLArrayElement) &&
               ValidateArrayElement(context, angle::EntryPoint::GLArrayElement, i)));
         if (isCallValid)
         {
@@ -6279,7 +6721,9 @@ void GL_APIENTRY GL_CopyTexImage1D(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCopyTexImage1D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCopyTexImage1D) &&
               ValidateCopyTexImage1D(context, angle::EntryPoint::GLCopyTexImage1D, target, level,
                                      internalformat, x, y, width, border)));
         if (isCallValid)
@@ -6310,7 +6754,9 @@ GL_CopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCopyTexSubImage1D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCopyTexSubImage1D) &&
               ValidateCopyTexSubImage1D(context, angle::EntryPoint::GLCopyTexSubImage1D, target,
                                         level, xoffset, x, y, width)));
         if (isCallValid)
@@ -6338,7 +6784,9 @@ void GL_APIENTRY GL_EdgeFlagPointer(GLsizei stride, const void *pointer)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEdgeFlagPointer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEdgeFlagPointer) &&
               ValidateEdgeFlagPointer(context, angle::EntryPoint::GLEdgeFlagPointer, stride,
                                       pointer)));
         if (isCallValid)
@@ -6366,7 +6814,9 @@ void GL_APIENTRY GL_IndexPointer(GLenum type, GLsizei stride, const void *pointe
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLIndexPointer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLIndexPointer) &&
               ValidateIndexPointer(context, angle::EntryPoint::GLIndexPointer, type, stride,
                                    pointer)));
         if (isCallValid)
@@ -6392,7 +6842,9 @@ void GL_APIENTRY GL_Indexub(GLubyte c)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLIndexub) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLIndexub) &&
               ValidateIndexub(context, angle::EntryPoint::GLIndexub, c)));
         if (isCallValid)
         {
@@ -6417,7 +6869,9 @@ void GL_APIENTRY GL_Indexubv(const GLubyte *c)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLIndexubv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLIndexubv) &&
               ValidateIndexubv(context, angle::EntryPoint::GLIndexubv, c)));
         if (isCallValid)
         {
@@ -6444,7 +6898,9 @@ void GL_APIENTRY GL_InterleavedArrays(GLenum format, GLsizei stride, const void
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLInterleavedArrays) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLInterleavedArrays) &&
               ValidateInterleavedArrays(context, angle::EntryPoint::GLInterleavedArrays, format,
                                         stride, pointer)));
         if (isCallValid)
@@ -6470,7 +6926,9 @@ void GL_APIENTRY GL_PopClientAttrib()
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPopClientAttrib) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPopClientAttrib) &&
               ValidatePopClientAttrib(context, angle::EntryPoint::GLPopClientAttrib)));
         if (isCallValid)
         {
@@ -6497,7 +6955,9 @@ void GL_APIENTRY GL_PrioritizeTextures(GLsizei n, const GLuint *textures, const
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPrioritizeTextures) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPrioritizeTextures) &&
               ValidatePrioritizeTextures(context, angle::EntryPoint::GLPrioritizeTextures, n,
                                          textures, priorities)));
         if (isCallValid)
@@ -6524,7 +6984,9 @@ void GL_APIENTRY GL_PushClientAttrib(GLbitfield mask)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPushClientAttrib) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPushClientAttrib) &&
               ValidatePushClientAttrib(context, angle::EntryPoint::GLPushClientAttrib, mask)));
         if (isCallValid)
         {
@@ -6560,7 +7022,9 @@ void GL_APIENTRY GL_TexSubImage1D(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexSubImage1D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexSubImage1D) &&
               ValidateTexSubImage1D(context, angle::EntryPoint::GLTexSubImage1D, target, level,
                                     xoffset, width, format, type, pixels)));
         if (isCallValid)
@@ -6599,12 +7063,14 @@ void GL_APIENTRY GL_CompressedTexImage1D(GLenum target,
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLCompressedTexImage1D) &&
-                             ValidateCompressedTexImage1D(
-                                 context, angle::EntryPoint::GLCompressedTexImage1D, target, level,
-                                 internalformat, width, border, imageSize, data)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCompressedTexImage1D) &&
+              ValidateCompressedTexImage1D(context, angle::EntryPoint::GLCompressedTexImage1D,
+                                           target, level, internalformat, width, border, imageSize,
+                                           data)));
         if (isCallValid)
         {
             context->compressedTexImage1D(target, level, internalformat, width, border, imageSize,
@@ -6638,12 +7104,14 @@ void GL_APIENTRY GL_CompressedTexSubImage1D(GLenum target,
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLCompressedTexSubImage1D) &&
-                             ValidateCompressedTexSubImage1D(
-                                 context, angle::EntryPoint::GLCompressedTexSubImage1D, target,
-                                 level, xoffset, width, format, imageSize, data)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCompressedTexSubImage1D) &&
+              ValidateCompressedTexSubImage1D(context, angle::EntryPoint::GLCompressedTexSubImage1D,
+                                              target, level, xoffset, width, format, imageSize,
+                                              data)));
         if (isCallValid)
         {
             context->compressedTexSubImage1D(target, level, xoffset, width, format, imageSize,
@@ -6698,7 +7166,8 @@ void GL_APIENTRY GL_LoadTransposeMatrixd(const GLdouble *m)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLLoadTransposeMatrixd) &&
               ValidateLoadTransposeMatrixd(context, angle::EntryPoint::GLLoadTransposeMatrixd, m)));
         if (isCallValid)
@@ -6725,7 +7194,8 @@ void GL_APIENTRY GL_LoadTransposeMatrixf(const GLfloat *m)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLLoadTransposeMatrixf) &&
               ValidateLoadTransposeMatrixf(context, angle::EntryPoint::GLLoadTransposeMatrixf, m)));
         if (isCallValid)
@@ -6752,7 +7222,8 @@ void GL_APIENTRY GL_MultTransposeMatrixd(const GLdouble *m)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLMultTransposeMatrixd) &&
               ValidateMultTransposeMatrixd(context, angle::EntryPoint::GLMultTransposeMatrixd, m)));
         if (isCallValid)
@@ -6779,7 +7250,8 @@ void GL_APIENTRY GL_MultTransposeMatrixf(const GLfloat *m)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLMultTransposeMatrixf) &&
               ValidateMultTransposeMatrixf(context, angle::EntryPoint::GLMultTransposeMatrixf, m)));
         if (isCallValid)
@@ -6806,7 +7278,9 @@ void GL_APIENTRY GL_MultiTexCoord1d(GLenum target, GLdouble s)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord1d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord1d) &&
               ValidateMultiTexCoord1d(context, angle::EntryPoint::GLMultiTexCoord1d, target, s)));
         if (isCallValid)
         {
@@ -6832,7 +7306,9 @@ void GL_APIENTRY GL_MultiTexCoord1dv(GLenum target, const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord1dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord1dv) &&
               ValidateMultiTexCoord1dv(context, angle::EntryPoint::GLMultiTexCoord1dv, target, v)));
         if (isCallValid)
         {
@@ -6858,7 +7334,9 @@ void GL_APIENTRY GL_MultiTexCoord1f(GLenum target, GLfloat s)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord1f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord1f) &&
               ValidateMultiTexCoord1f(context, angle::EntryPoint::GLMultiTexCoord1f, target, s)));
         if (isCallValid)
         {
@@ -6884,7 +7362,9 @@ void GL_APIENTRY GL_MultiTexCoord1fv(GLenum target, const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord1fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord1fv) &&
               ValidateMultiTexCoord1fv(context, angle::EntryPoint::GLMultiTexCoord1fv, target, v)));
         if (isCallValid)
         {
@@ -6910,7 +7390,9 @@ void GL_APIENTRY GL_MultiTexCoord1i(GLenum target, GLint s)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord1i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord1i) &&
               ValidateMultiTexCoord1i(context, angle::EntryPoint::GLMultiTexCoord1i, target, s)));
         if (isCallValid)
         {
@@ -6936,7 +7418,9 @@ void GL_APIENTRY GL_MultiTexCoord1iv(GLenum target, const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord1iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord1iv) &&
               ValidateMultiTexCoord1iv(context, angle::EntryPoint::GLMultiTexCoord1iv, target, v)));
         if (isCallValid)
         {
@@ -6962,7 +7446,9 @@ void GL_APIENTRY GL_MultiTexCoord1s(GLenum target, GLshort s)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord1s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord1s) &&
               ValidateMultiTexCoord1s(context, angle::EntryPoint::GLMultiTexCoord1s, target, s)));
         if (isCallValid)
         {
@@ -6988,7 +7474,9 @@ void GL_APIENTRY GL_MultiTexCoord1sv(GLenum target, const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord1sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord1sv) &&
               ValidateMultiTexCoord1sv(context, angle::EntryPoint::GLMultiTexCoord1sv, target, v)));
         if (isCallValid)
         {
@@ -7014,7 +7502,9 @@ void GL_APIENTRY GL_MultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord2d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord2d) &&
               ValidateMultiTexCoord2d(context, angle::EntryPoint::GLMultiTexCoord2d, target, s,
                                       t)));
         if (isCallValid)
@@ -7041,7 +7531,9 @@ void GL_APIENTRY GL_MultiTexCoord2dv(GLenum target, const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord2dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord2dv) &&
               ValidateMultiTexCoord2dv(context, angle::EntryPoint::GLMultiTexCoord2dv, target, v)));
         if (isCallValid)
         {
@@ -7067,7 +7559,9 @@ void GL_APIENTRY GL_MultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord2f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord2f) &&
               ValidateMultiTexCoord2f(context, angle::EntryPoint::GLMultiTexCoord2f, target, s,
                                       t)));
         if (isCallValid)
@@ -7094,7 +7588,9 @@ void GL_APIENTRY GL_MultiTexCoord2fv(GLenum target, const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord2fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord2fv) &&
               ValidateMultiTexCoord2fv(context, angle::EntryPoint::GLMultiTexCoord2fv, target, v)));
         if (isCallValid)
         {
@@ -7120,7 +7616,9 @@ void GL_APIENTRY GL_MultiTexCoord2i(GLenum target, GLint s, GLint t)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord2i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord2i) &&
               ValidateMultiTexCoord2i(context, angle::EntryPoint::GLMultiTexCoord2i, target, s,
                                       t)));
         if (isCallValid)
@@ -7147,7 +7645,9 @@ void GL_APIENTRY GL_MultiTexCoord2iv(GLenum target, const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord2iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord2iv) &&
               ValidateMultiTexCoord2iv(context, angle::EntryPoint::GLMultiTexCoord2iv, target, v)));
         if (isCallValid)
         {
@@ -7173,7 +7673,9 @@ void GL_APIENTRY GL_MultiTexCoord2s(GLenum target, GLshort s, GLshort t)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord2s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord2s) &&
               ValidateMultiTexCoord2s(context, angle::EntryPoint::GLMultiTexCoord2s, target, s,
                                       t)));
         if (isCallValid)
@@ -7200,7 +7702,9 @@ void GL_APIENTRY GL_MultiTexCoord2sv(GLenum target, const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord2sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord2sv) &&
               ValidateMultiTexCoord2sv(context, angle::EntryPoint::GLMultiTexCoord2sv, target, v)));
         if (isCallValid)
         {
@@ -7226,7 +7730,9 @@ void GL_APIENTRY GL_MultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdou
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord3d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord3d) &&
               ValidateMultiTexCoord3d(context, angle::EntryPoint::GLMultiTexCoord3d, target, s, t,
                                       r)));
         if (isCallValid)
@@ -7253,7 +7759,9 @@ void GL_APIENTRY GL_MultiTexCoord3dv(GLenum target, const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord3dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord3dv) &&
               ValidateMultiTexCoord3dv(context, angle::EntryPoint::GLMultiTexCoord3dv, target, v)));
         if (isCallValid)
         {
@@ -7279,7 +7787,9 @@ void GL_APIENTRY GL_MultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord3f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord3f) &&
               ValidateMultiTexCoord3f(context, angle::EntryPoint::GLMultiTexCoord3f, target, s, t,
                                       r)));
         if (isCallValid)
@@ -7306,7 +7816,9 @@ void GL_APIENTRY GL_MultiTexCoord3fv(GLenum target, const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord3fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord3fv) &&
               ValidateMultiTexCoord3fv(context, angle::EntryPoint::GLMultiTexCoord3fv, target, v)));
         if (isCallValid)
         {
@@ -7332,7 +7844,9 @@ void GL_APIENTRY GL_MultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord3i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord3i) &&
               ValidateMultiTexCoord3i(context, angle::EntryPoint::GLMultiTexCoord3i, target, s, t,
                                       r)));
         if (isCallValid)
@@ -7359,7 +7873,9 @@ void GL_APIENTRY GL_MultiTexCoord3iv(GLenum target, const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord3iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord3iv) &&
               ValidateMultiTexCoord3iv(context, angle::EntryPoint::GLMultiTexCoord3iv, target, v)));
         if (isCallValid)
         {
@@ -7385,7 +7901,9 @@ void GL_APIENTRY GL_MultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord3s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord3s) &&
               ValidateMultiTexCoord3s(context, angle::EntryPoint::GLMultiTexCoord3s, target, s, t,
                                       r)));
         if (isCallValid)
@@ -7412,7 +7930,9 @@ void GL_APIENTRY GL_MultiTexCoord3sv(GLenum target, const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord3sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord3sv) &&
               ValidateMultiTexCoord3sv(context, angle::EntryPoint::GLMultiTexCoord3sv, target, v)));
         if (isCallValid)
         {
@@ -7438,7 +7958,9 @@ void GL_APIENTRY GL_MultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdou
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord4d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord4d) &&
               ValidateMultiTexCoord4d(context, angle::EntryPoint::GLMultiTexCoord4d, target, s, t,
                                       r, q)));
         if (isCallValid)
@@ -7465,7 +7987,9 @@ void GL_APIENTRY GL_MultiTexCoord4dv(GLenum target, const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord4dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord4dv) &&
               ValidateMultiTexCoord4dv(context, angle::EntryPoint::GLMultiTexCoord4dv, target, v)));
         if (isCallValid)
         {
@@ -7491,7 +8015,9 @@ void GL_APIENTRY GL_MultiTexCoord4fv(GLenum target, const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord4fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord4fv) &&
               ValidateMultiTexCoord4fv(context, angle::EntryPoint::GLMultiTexCoord4fv, target, v)));
         if (isCallValid)
         {
@@ -7517,7 +8043,9 @@ void GL_APIENTRY GL_MultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GL
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord4i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord4i) &&
               ValidateMultiTexCoord4i(context, angle::EntryPoint::GLMultiTexCoord4i, target, s, t,
                                       r, q)));
         if (isCallValid)
@@ -7544,7 +8072,9 @@ void GL_APIENTRY GL_MultiTexCoord4iv(GLenum target, const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord4iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord4iv) &&
               ValidateMultiTexCoord4iv(context, angle::EntryPoint::GLMultiTexCoord4iv, target, v)));
         if (isCallValid)
         {
@@ -7570,7 +8100,9 @@ void GL_APIENTRY GL_MultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord4s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord4s) &&
               ValidateMultiTexCoord4s(context, angle::EntryPoint::GLMultiTexCoord4s, target, s, t,
                                       r, q)));
         if (isCallValid)
@@ -7597,7 +8129,9 @@ void GL_APIENTRY GL_MultiTexCoord4sv(GLenum target, const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord4sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord4sv) &&
               ValidateMultiTexCoord4sv(context, angle::EntryPoint::GLMultiTexCoord4sv, target, v)));
         if (isCallValid)
         {
@@ -7625,7 +8159,9 @@ void GL_APIENTRY GL_FogCoordPointer(GLenum type, GLsizei stride, const void *poi
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFogCoordPointer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFogCoordPointer) &&
               ValidateFogCoordPointer(context, angle::EntryPoint::GLFogCoordPointer, type, stride,
                                       pointer)));
         if (isCallValid)
@@ -7651,7 +8187,9 @@ void GL_APIENTRY GL_FogCoordd(GLdouble coord)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFogCoordd) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFogCoordd) &&
               ValidateFogCoordd(context, angle::EntryPoint::GLFogCoordd, coord)));
         if (isCallValid)
         {
@@ -7677,7 +8215,9 @@ void GL_APIENTRY GL_FogCoorddv(const GLdouble *coord)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFogCoorddv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFogCoorddv) &&
               ValidateFogCoorddv(context, angle::EntryPoint::GLFogCoorddv, coord)));
         if (isCallValid)
         {
@@ -7702,7 +8242,9 @@ void GL_APIENTRY GL_FogCoordf(GLfloat coord)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFogCoordf) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFogCoordf) &&
               ValidateFogCoordf(context, angle::EntryPoint::GLFogCoordf, coord)));
         if (isCallValid)
         {
@@ -7728,7 +8270,9 @@ void GL_APIENTRY GL_FogCoordfv(const GLfloat *coord)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFogCoordfv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFogCoordfv) &&
               ValidateFogCoordfv(context, angle::EntryPoint::GLFogCoordfv, coord)));
         if (isCallValid)
         {
@@ -7761,7 +8305,9 @@ void GL_APIENTRY GL_MultiDrawArrays(GLenum mode,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiDrawArrays) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiDrawArrays) &&
               ValidateMultiDrawArrays(context, angle::EntryPoint::GLMultiDrawArrays, modePacked,
                                       first, count, drawcount)));
         if (isCallValid)
@@ -7798,7 +8344,9 @@ void GL_APIENTRY GL_MultiDrawElements(GLenum mode,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiDrawElements) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiDrawElements) &&
               ValidateMultiDrawElements(context, angle::EntryPoint::GLMultiDrawElements, modePacked,
                                         count, typePacked, indices, drawcount)));
         if (isCallValid)
@@ -7826,7 +8374,9 @@ void GL_APIENTRY GL_PointParameteri(GLenum pname, GLint param)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPointParameteri) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPointParameteri) &&
               ValidatePointParameteri(context, angle::EntryPoint::GLPointParameteri, pname,
                                       param)));
         if (isCallValid)
@@ -7853,7 +8403,9 @@ void GL_APIENTRY GL_PointParameteriv(GLenum pname, const GLint *params)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPointParameteriv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPointParameteriv) &&
               ValidatePointParameteriv(context, angle::EntryPoint::GLPointParameteriv, pname,
                                        params)));
         if (isCallValid)
@@ -7880,7 +8432,9 @@ void GL_APIENTRY GL_SecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSecondaryColor3b) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColor3b) &&
               ValidateSecondaryColor3b(context, angle::EntryPoint::GLSecondaryColor3b, red, green,
                                        blue)));
         if (isCallValid)
@@ -7907,7 +8461,9 @@ void GL_APIENTRY GL_SecondaryColor3bv(const GLbyte *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSecondaryColor3bv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColor3bv) &&
               ValidateSecondaryColor3bv(context, angle::EntryPoint::GLSecondaryColor3bv, v)));
         if (isCallValid)
         {
@@ -7933,7 +8489,9 @@ void GL_APIENTRY GL_SecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSecondaryColor3d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColor3d) &&
               ValidateSecondaryColor3d(context, angle::EntryPoint::GLSecondaryColor3d, red, green,
                                        blue)));
         if (isCallValid)
@@ -7960,7 +8518,9 @@ void GL_APIENTRY GL_SecondaryColor3dv(const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSecondaryColor3dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColor3dv) &&
               ValidateSecondaryColor3dv(context, angle::EntryPoint::GLSecondaryColor3dv, v)));
         if (isCallValid)
         {
@@ -7986,7 +8546,9 @@ void GL_APIENTRY GL_SecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSecondaryColor3f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColor3f) &&
               ValidateSecondaryColor3f(context, angle::EntryPoint::GLSecondaryColor3f, red, green,
                                        blue)));
         if (isCallValid)
@@ -8013,7 +8575,9 @@ void GL_APIENTRY GL_SecondaryColor3fv(const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSecondaryColor3fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColor3fv) &&
               ValidateSecondaryColor3fv(context, angle::EntryPoint::GLSecondaryColor3fv, v)));
         if (isCallValid)
         {
@@ -8039,7 +8603,9 @@ void GL_APIENTRY GL_SecondaryColor3i(GLint red, GLint green, GLint blue)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSecondaryColor3i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColor3i) &&
               ValidateSecondaryColor3i(context, angle::EntryPoint::GLSecondaryColor3i, red, green,
                                        blue)));
         if (isCallValid)
@@ -8066,7 +8632,9 @@ void GL_APIENTRY GL_SecondaryColor3iv(const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSecondaryColor3iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColor3iv) &&
               ValidateSecondaryColor3iv(context, angle::EntryPoint::GLSecondaryColor3iv, v)));
         if (isCallValid)
         {
@@ -8092,7 +8660,9 @@ void GL_APIENTRY GL_SecondaryColor3s(GLshort red, GLshort green, GLshort blue)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSecondaryColor3s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColor3s) &&
               ValidateSecondaryColor3s(context, angle::EntryPoint::GLSecondaryColor3s, red, green,
                                        blue)));
         if (isCallValid)
@@ -8119,7 +8689,9 @@ void GL_APIENTRY GL_SecondaryColor3sv(const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSecondaryColor3sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColor3sv) &&
               ValidateSecondaryColor3sv(context, angle::EntryPoint::GLSecondaryColor3sv, v)));
         if (isCallValid)
         {
@@ -8145,7 +8717,9 @@ void GL_APIENTRY GL_SecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSecondaryColor3ub) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColor3ub) &&
               ValidateSecondaryColor3ub(context, angle::EntryPoint::GLSecondaryColor3ub, red, green,
                                         blue)));
         if (isCallValid)
@@ -8172,7 +8746,9 @@ void GL_APIENTRY GL_SecondaryColor3ubv(const GLubyte *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSecondaryColor3ubv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColor3ubv) &&
               ValidateSecondaryColor3ubv(context, angle::EntryPoint::GLSecondaryColor3ubv, v)));
         if (isCallValid)
         {
@@ -8198,7 +8774,9 @@ void GL_APIENTRY GL_SecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSecondaryColor3ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColor3ui) &&
               ValidateSecondaryColor3ui(context, angle::EntryPoint::GLSecondaryColor3ui, red, green,
                                         blue)));
         if (isCallValid)
@@ -8225,7 +8803,9 @@ void GL_APIENTRY GL_SecondaryColor3uiv(const GLuint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSecondaryColor3uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColor3uiv) &&
               ValidateSecondaryColor3uiv(context, angle::EntryPoint::GLSecondaryColor3uiv, v)));
         if (isCallValid)
         {
@@ -8251,7 +8831,9 @@ void GL_APIENTRY GL_SecondaryColor3us(GLushort red, GLushort green, GLushort blu
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSecondaryColor3us) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColor3us) &&
               ValidateSecondaryColor3us(context, angle::EntryPoint::GLSecondaryColor3us, red, green,
                                         blue)));
         if (isCallValid)
@@ -8278,7 +8860,9 @@ void GL_APIENTRY GL_SecondaryColor3usv(const GLushort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSecondaryColor3usv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColor3usv) &&
               ValidateSecondaryColor3usv(context, angle::EntryPoint::GLSecondaryColor3usv, v)));
         if (isCallValid)
         {
@@ -8309,7 +8893,8 @@ void GL_APIENTRY GL_SecondaryColorPointer(GLint size,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLSecondaryColorPointer) &&
               ValidateSecondaryColorPointer(context, angle::EntryPoint::GLSecondaryColorPointer,
                                             size, type, stride, pointer)));
@@ -8336,7 +8921,9 @@ void GL_APIENTRY GL_WindowPos2d(GLdouble x, GLdouble y)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWindowPos2d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWindowPos2d) &&
               ValidateWindowPos2d(context, angle::EntryPoint::GLWindowPos2d, x, y)));
         if (isCallValid)
         {
@@ -8362,7 +8949,9 @@ void GL_APIENTRY GL_WindowPos2dv(const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWindowPos2dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWindowPos2dv) &&
               ValidateWindowPos2dv(context, angle::EntryPoint::GLWindowPos2dv, v)));
         if (isCallValid)
         {
@@ -8387,7 +8976,9 @@ void GL_APIENTRY GL_WindowPos2f(GLfloat x, GLfloat y)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWindowPos2f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWindowPos2f) &&
               ValidateWindowPos2f(context, angle::EntryPoint::GLWindowPos2f, x, y)));
         if (isCallValid)
         {
@@ -8413,7 +9004,9 @@ void GL_APIENTRY GL_WindowPos2fv(const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWindowPos2fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWindowPos2fv) &&
               ValidateWindowPos2fv(context, angle::EntryPoint::GLWindowPos2fv, v)));
         if (isCallValid)
         {
@@ -8438,7 +9031,9 @@ void GL_APIENTRY GL_WindowPos2i(GLint x, GLint y)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWindowPos2i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWindowPos2i) &&
               ValidateWindowPos2i(context, angle::EntryPoint::GLWindowPos2i, x, y)));
         if (isCallValid)
         {
@@ -8464,7 +9059,9 @@ void GL_APIENTRY GL_WindowPos2iv(const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWindowPos2iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWindowPos2iv) &&
               ValidateWindowPos2iv(context, angle::EntryPoint::GLWindowPos2iv, v)));
         if (isCallValid)
         {
@@ -8489,7 +9086,9 @@ void GL_APIENTRY GL_WindowPos2s(GLshort x, GLshort y)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWindowPos2s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWindowPos2s) &&
               ValidateWindowPos2s(context, angle::EntryPoint::GLWindowPos2s, x, y)));
         if (isCallValid)
         {
@@ -8515,7 +9114,9 @@ void GL_APIENTRY GL_WindowPos2sv(const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWindowPos2sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWindowPos2sv) &&
               ValidateWindowPos2sv(context, angle::EntryPoint::GLWindowPos2sv, v)));
         if (isCallValid)
         {
@@ -8540,7 +9141,9 @@ void GL_APIENTRY GL_WindowPos3d(GLdouble x, GLdouble y, GLdouble z)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWindowPos3d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWindowPos3d) &&
               ValidateWindowPos3d(context, angle::EntryPoint::GLWindowPos3d, x, y, z)));
         if (isCallValid)
         {
@@ -8566,7 +9169,9 @@ void GL_APIENTRY GL_WindowPos3dv(const GLdouble *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWindowPos3dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWindowPos3dv) &&
               ValidateWindowPos3dv(context, angle::EntryPoint::GLWindowPos3dv, v)));
         if (isCallValid)
         {
@@ -8591,7 +9196,9 @@ void GL_APIENTRY GL_WindowPos3f(GLfloat x, GLfloat y, GLfloat z)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWindowPos3f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWindowPos3f) &&
               ValidateWindowPos3f(context, angle::EntryPoint::GLWindowPos3f, x, y, z)));
         if (isCallValid)
         {
@@ -8617,7 +9224,9 @@ void GL_APIENTRY GL_WindowPos3fv(const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWindowPos3fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWindowPos3fv) &&
               ValidateWindowPos3fv(context, angle::EntryPoint::GLWindowPos3fv, v)));
         if (isCallValid)
         {
@@ -8642,7 +9251,9 @@ void GL_APIENTRY GL_WindowPos3i(GLint x, GLint y, GLint z)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWindowPos3i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWindowPos3i) &&
               ValidateWindowPos3i(context, angle::EntryPoint::GLWindowPos3i, x, y, z)));
         if (isCallValid)
         {
@@ -8668,7 +9279,9 @@ void GL_APIENTRY GL_WindowPos3iv(const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWindowPos3iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWindowPos3iv) &&
               ValidateWindowPos3iv(context, angle::EntryPoint::GLWindowPos3iv, v)));
         if (isCallValid)
         {
@@ -8693,7 +9306,9 @@ void GL_APIENTRY GL_WindowPos3s(GLshort x, GLshort y, GLshort z)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWindowPos3s) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWindowPos3s) &&
               ValidateWindowPos3s(context, angle::EntryPoint::GLWindowPos3s, x, y, z)));
         if (isCallValid)
         {
@@ -8719,7 +9334,9 @@ void GL_APIENTRY GL_WindowPos3sv(const GLshort *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWindowPos3sv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWindowPos3sv) &&
               ValidateWindowPos3sv(context, angle::EntryPoint::GLWindowPos3sv, v)));
         if (isCallValid)
         {
@@ -8803,7 +9420,9 @@ void *GL_APIENTRY GL_MapBuffer(GLenum target, GLenum access)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMapBuffer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMapBuffer) &&
               ValidateMapBuffer(context, angle::EntryPoint::GLMapBuffer, targetPacked, access)));
         if (isCallValid)
         {
diff --git a/src/libGLESv2/entry_points_gl_2_autogen.cpp b/src/libGLESv2/entry_points_gl_2_autogen.cpp
index 1e846e5a6..c6c5b4eb1 100644
--- a/src/libGLESv2/entry_points_gl_2_autogen.cpp
+++ b/src/libGLESv2/entry_points_gl_2_autogen.cpp
@@ -67,9 +67,10 @@ void GL_APIENTRY GL_VertexAttrib1d(GLuint index, GLdouble x)
 
     if (context)
     {
-        bool isCallValid =
-            (context->skipValidation() ||
-             ValidateVertexAttrib1d(context, angle::EntryPoint::GLVertexAttrib1d, index, x));
+        bool isCallValid = (context->skipValidation() ||
+                            ValidateVertexAttrib1d(context->getPrivateState(),
+                                                   context->getMutableErrorSetForValidation(),
+                                                   angle::EntryPoint::GLVertexAttrib1d, index, x));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib1d(context->getMutablePrivateState(),
@@ -94,7 +95,9 @@ void GL_APIENTRY GL_VertexAttrib1dv(GLuint index, const GLdouble *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib1dv(context, angle::EntryPoint::GLVertexAttrib1dv, index, v));
+             ValidateVertexAttrib1dv(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttrib1dv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib1dv(context->getMutablePrivateState(),
@@ -116,9 +119,10 @@ void GL_APIENTRY GL_VertexAttrib1s(GLuint index, GLshort x)
 
     if (context)
     {
-        bool isCallValid =
-            (context->skipValidation() ||
-             ValidateVertexAttrib1s(context, angle::EntryPoint::GLVertexAttrib1s, index, x));
+        bool isCallValid = (context->skipValidation() ||
+                            ValidateVertexAttrib1s(context->getPrivateState(),
+                                                   context->getMutableErrorSetForValidation(),
+                                                   angle::EntryPoint::GLVertexAttrib1s, index, x));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib1s(context->getMutablePrivateState(),
@@ -143,7 +147,9 @@ void GL_APIENTRY GL_VertexAttrib1sv(GLuint index, const GLshort *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib1sv(context, angle::EntryPoint::GLVertexAttrib1sv, index, v));
+             ValidateVertexAttrib1sv(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttrib1sv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib1sv(context->getMutablePrivateState(),
@@ -168,7 +174,9 @@ void GL_APIENTRY GL_VertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib2d(context, angle::EntryPoint::GLVertexAttrib2d, index, x, y));
+             ValidateVertexAttrib2d(context->getPrivateState(),
+                                    context->getMutableErrorSetForValidation(),
+                                    angle::EntryPoint::GLVertexAttrib2d, index, x, y));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib2d(context->getMutablePrivateState(),
@@ -193,7 +201,9 @@ void GL_APIENTRY GL_VertexAttrib2dv(GLuint index, const GLdouble *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib2dv(context, angle::EntryPoint::GLVertexAttrib2dv, index, v));
+             ValidateVertexAttrib2dv(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttrib2dv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib2dv(context->getMutablePrivateState(),
@@ -218,7 +228,9 @@ void GL_APIENTRY GL_VertexAttrib2s(GLuint index, GLshort x, GLshort y)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib2s(context, angle::EntryPoint::GLVertexAttrib2s, index, x, y));
+             ValidateVertexAttrib2s(context->getPrivateState(),
+                                    context->getMutableErrorSetForValidation(),
+                                    angle::EntryPoint::GLVertexAttrib2s, index, x, y));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib2s(context->getMutablePrivateState(),
@@ -243,7 +255,9 @@ void GL_APIENTRY GL_VertexAttrib2sv(GLuint index, const GLshort *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib2sv(context, angle::EntryPoint::GLVertexAttrib2sv, index, v));
+             ValidateVertexAttrib2sv(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttrib2sv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib2sv(context->getMutablePrivateState(),
@@ -268,7 +282,9 @@ void GL_APIENTRY GL_VertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdoubl
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib3d(context, angle::EntryPoint::GLVertexAttrib3d, index, x, y, z));
+             ValidateVertexAttrib3d(context->getPrivateState(),
+                                    context->getMutableErrorSetForValidation(),
+                                    angle::EntryPoint::GLVertexAttrib3d, index, x, y, z));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib3d(context->getMutablePrivateState(),
@@ -293,7 +309,9 @@ void GL_APIENTRY GL_VertexAttrib3dv(GLuint index, const GLdouble *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib3dv(context, angle::EntryPoint::GLVertexAttrib3dv, index, v));
+             ValidateVertexAttrib3dv(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttrib3dv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib3dv(context->getMutablePrivateState(),
@@ -318,7 +336,9 @@ void GL_APIENTRY GL_VertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib3s(context, angle::EntryPoint::GLVertexAttrib3s, index, x, y, z));
+             ValidateVertexAttrib3s(context->getPrivateState(),
+                                    context->getMutableErrorSetForValidation(),
+                                    angle::EntryPoint::GLVertexAttrib3s, index, x, y, z));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib3s(context->getMutablePrivateState(),
@@ -343,7 +363,9 @@ void GL_APIENTRY GL_VertexAttrib3sv(GLuint index, const GLshort *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib3sv(context, angle::EntryPoint::GLVertexAttrib3sv, index, v));
+             ValidateVertexAttrib3sv(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttrib3sv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib3sv(context->getMutablePrivateState(),
@@ -368,7 +390,9 @@ void GL_APIENTRY GL_VertexAttrib4Nbv(GLuint index, const GLbyte *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib4Nbv(context, angle::EntryPoint::GLVertexAttrib4Nbv, index, v));
+             ValidateVertexAttrib4Nbv(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttrib4Nbv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4Nbv(context->getMutablePrivateState(),
@@ -393,7 +417,9 @@ void GL_APIENTRY GL_VertexAttrib4Niv(GLuint index, const GLint *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib4Niv(context, angle::EntryPoint::GLVertexAttrib4Niv, index, v));
+             ValidateVertexAttrib4Niv(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttrib4Niv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4Niv(context->getMutablePrivateState(),
@@ -418,7 +444,9 @@ void GL_APIENTRY GL_VertexAttrib4Nsv(GLuint index, const GLshort *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib4Nsv(context, angle::EntryPoint::GLVertexAttrib4Nsv, index, v));
+             ValidateVertexAttrib4Nsv(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttrib4Nsv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4Nsv(context->getMutablePrivateState(),
@@ -441,9 +469,11 @@ void GL_APIENTRY GL_VertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateVertexAttrib4Nub(context, angle::EntryPoint::GLVertexAttrib4Nub,
-                                                     index, x, y, z, w));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateVertexAttrib4Nub(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttrib4Nub, index, x, y, z, w));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4Nub(context->getMutablePrivateState(),
@@ -469,7 +499,9 @@ void GL_APIENTRY GL_VertexAttrib4Nubv(GLuint index, const GLubyte *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib4Nubv(context, angle::EntryPoint::GLVertexAttrib4Nubv, index, v));
+             ValidateVertexAttrib4Nubv(context->getPrivateState(),
+                                       context->getMutableErrorSetForValidation(),
+                                       angle::EntryPoint::GLVertexAttrib4Nubv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4Nubv(context->getMutablePrivateState(),
@@ -494,7 +526,9 @@ void GL_APIENTRY GL_VertexAttrib4Nuiv(GLuint index, const GLuint *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib4Nuiv(context, angle::EntryPoint::GLVertexAttrib4Nuiv, index, v));
+             ValidateVertexAttrib4Nuiv(context->getPrivateState(),
+                                       context->getMutableErrorSetForValidation(),
+                                       angle::EntryPoint::GLVertexAttrib4Nuiv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4Nuiv(context->getMutablePrivateState(),
@@ -519,7 +553,9 @@ void GL_APIENTRY GL_VertexAttrib4Nusv(GLuint index, const GLushort *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib4Nusv(context, angle::EntryPoint::GLVertexAttrib4Nusv, index, v));
+             ValidateVertexAttrib4Nusv(context->getPrivateState(),
+                                       context->getMutableErrorSetForValidation(),
+                                       angle::EntryPoint::GLVertexAttrib4Nusv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4Nusv(context->getMutablePrivateState(),
@@ -544,7 +580,9 @@ void GL_APIENTRY GL_VertexAttrib4bv(GLuint index, const GLbyte *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib4bv(context, angle::EntryPoint::GLVertexAttrib4bv, index, v));
+             ValidateVertexAttrib4bv(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttrib4bv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4bv(context->getMutablePrivateState(),
@@ -567,9 +605,11 @@ void GL_APIENTRY GL_VertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdoubl
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateVertexAttrib4d(context, angle::EntryPoint::GLVertexAttrib4d,
-                                                   index, x, y, z, w));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateVertexAttrib4d(context->getPrivateState(),
+                                    context->getMutableErrorSetForValidation(),
+                                    angle::EntryPoint::GLVertexAttrib4d, index, x, y, z, w));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4d(context->getMutablePrivateState(),
@@ -594,7 +634,9 @@ void GL_APIENTRY GL_VertexAttrib4dv(GLuint index, const GLdouble *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib4dv(context, angle::EntryPoint::GLVertexAttrib4dv, index, v));
+             ValidateVertexAttrib4dv(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttrib4dv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4dv(context->getMutablePrivateState(),
@@ -619,7 +661,9 @@ void GL_APIENTRY GL_VertexAttrib4iv(GLuint index, const GLint *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib4iv(context, angle::EntryPoint::GLVertexAttrib4iv, index, v));
+             ValidateVertexAttrib4iv(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttrib4iv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4iv(context->getMutablePrivateState(),
@@ -642,9 +686,11 @@ void GL_APIENTRY GL_VertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateVertexAttrib4s(context, angle::EntryPoint::GLVertexAttrib4s,
-                                                   index, x, y, z, w));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateVertexAttrib4s(context->getPrivateState(),
+                                    context->getMutableErrorSetForValidation(),
+                                    angle::EntryPoint::GLVertexAttrib4s, index, x, y, z, w));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4s(context->getMutablePrivateState(),
@@ -669,7 +715,9 @@ void GL_APIENTRY GL_VertexAttrib4sv(GLuint index, const GLshort *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib4sv(context, angle::EntryPoint::GLVertexAttrib4sv, index, v));
+             ValidateVertexAttrib4sv(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttrib4sv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4sv(context->getMutablePrivateState(),
@@ -694,7 +742,9 @@ void GL_APIENTRY GL_VertexAttrib4ubv(GLuint index, const GLubyte *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib4ubv(context, angle::EntryPoint::GLVertexAttrib4ubv, index, v));
+             ValidateVertexAttrib4ubv(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttrib4ubv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4ubv(context->getMutablePrivateState(),
@@ -719,7 +769,9 @@ void GL_APIENTRY GL_VertexAttrib4uiv(GLuint index, const GLuint *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib4uiv(context, angle::EntryPoint::GLVertexAttrib4uiv, index, v));
+             ValidateVertexAttrib4uiv(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttrib4uiv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4uiv(context->getMutablePrivateState(),
@@ -744,7 +796,9 @@ void GL_APIENTRY GL_VertexAttrib4usv(GLuint index, const GLushort *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib4usv(context, angle::EntryPoint::GLVertexAttrib4usv, index, v));
+             ValidateVertexAttrib4usv(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttrib4usv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4usv(context->getMutablePrivateState(),
diff --git a/src/libGLESv2/entry_points_gl_3_autogen.cpp b/src/libGLESv2/entry_points_gl_3_autogen.cpp
index dc1850459..b7cead60a 100644
--- a/src/libGLESv2/entry_points_gl_3_autogen.cpp
+++ b/src/libGLESv2/entry_points_gl_3_autogen.cpp
@@ -42,11 +42,13 @@ void GL_APIENTRY GL_BeginConditionalRender(GLuint id, GLenum mode)
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLBeginConditionalRender) &&
-                             ValidateBeginConditionalRender(
-                                 context, angle::EntryPoint::GLBeginConditionalRender, id, mode)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBeginConditionalRender) &&
+              ValidateBeginConditionalRender(context, angle::EntryPoint::GLBeginConditionalRender,
+                                             id, mode)));
         if (isCallValid)
         {
             context->beginConditionalRender(id, mode);
@@ -73,7 +75,8 @@ void GL_APIENTRY GL_BindFragDataLocation(GLuint program, GLuint color, const GLc
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLBindFragDataLocation) &&
               ValidateBindFragDataLocation(context, angle::EntryPoint::GLBindFragDataLocation,
                                            programPacked, color, name)));
@@ -101,7 +104,9 @@ void GL_APIENTRY GL_ClampColor(GLenum target, GLenum clamp)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLClampColor) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClampColor) &&
               ValidateClampColor(context, angle::EntryPoint::GLClampColor, target, clamp)));
         if (isCallValid)
         {
@@ -126,7 +131,8 @@ void GL_APIENTRY GL_EndConditionalRender()
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLEndConditionalRender) &&
               ValidateEndConditionalRender(context, angle::EntryPoint::GLEndConditionalRender)));
         if (isCallValid)
@@ -160,12 +166,14 @@ void GL_APIENTRY GL_FramebufferTexture1D(GLenum target,
         TextureTarget textargetPacked = PackParam<TextureTarget>(textarget);
         TextureID texturePacked       = PackParam<TextureID>(texture);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLFramebufferTexture1D) &&
-                             ValidateFramebufferTexture1D(
-                                 context, angle::EntryPoint::GLFramebufferTexture1D, target,
-                                 attachment, textargetPacked, texturePacked, level)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFramebufferTexture1D) &&
+              ValidateFramebufferTexture1D(context, angle::EntryPoint::GLFramebufferTexture1D,
+                                           target, attachment, textargetPacked, texturePacked,
+                                           level)));
         if (isCallValid)
         {
             context->framebufferTexture1D(target, attachment, textargetPacked, texturePacked,
@@ -201,12 +209,14 @@ void GL_APIENTRY GL_FramebufferTexture3D(GLenum target,
         TextureTarget textargetPacked = PackParam<TextureTarget>(textarget);
         TextureID texturePacked       = PackParam<TextureID>(texture);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLFramebufferTexture3D) &&
-                             ValidateFramebufferTexture3D(
-                                 context, angle::EntryPoint::GLFramebufferTexture3D, target,
-                                 attachment, textargetPacked, texturePacked, level, zoffset)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFramebufferTexture3D) &&
+              ValidateFramebufferTexture3D(context, angle::EntryPoint::GLFramebufferTexture3D,
+                                           target, attachment, textargetPacked, texturePacked,
+                                           level, zoffset)));
         if (isCallValid)
         {
             context->framebufferTexture3D(target, attachment, textargetPacked, texturePacked, level,
@@ -231,7 +241,9 @@ void GL_APIENTRY GL_VertexAttribI1i(GLuint index, GLint x)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribI1i(context, angle::EntryPoint::GLVertexAttribI1i, index, x));
+             ValidateVertexAttribI1i(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttribI1i, index, x));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI1i(context->getMutablePrivateState(),
@@ -256,7 +268,9 @@ void GL_APIENTRY GL_VertexAttribI1iv(GLuint index, const GLint *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribI1iv(context, angle::EntryPoint::GLVertexAttribI1iv, index, v));
+             ValidateVertexAttribI1iv(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttribI1iv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI1iv(context->getMutablePrivateState(),
@@ -280,7 +294,9 @@ void GL_APIENTRY GL_VertexAttribI1ui(GLuint index, GLuint x)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribI1ui(context, angle::EntryPoint::GLVertexAttribI1ui, index, x));
+             ValidateVertexAttribI1ui(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttribI1ui, index, x));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI1ui(context->getMutablePrivateState(),
@@ -305,7 +321,9 @@ void GL_APIENTRY GL_VertexAttribI1uiv(GLuint index, const GLuint *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribI1uiv(context, angle::EntryPoint::GLVertexAttribI1uiv, index, v));
+             ValidateVertexAttribI1uiv(context->getPrivateState(),
+                                       context->getMutableErrorSetForValidation(),
+                                       angle::EntryPoint::GLVertexAttribI1uiv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI1uiv(context->getMutablePrivateState(),
@@ -330,7 +348,9 @@ void GL_APIENTRY GL_VertexAttribI2i(GLuint index, GLint x, GLint y)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribI2i(context, angle::EntryPoint::GLVertexAttribI2i, index, x, y));
+             ValidateVertexAttribI2i(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttribI2i, index, x, y));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI2i(context->getMutablePrivateState(),
@@ -355,7 +375,9 @@ void GL_APIENTRY GL_VertexAttribI2iv(GLuint index, const GLint *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribI2iv(context, angle::EntryPoint::GLVertexAttribI2iv, index, v));
+             ValidateVertexAttribI2iv(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttribI2iv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI2iv(context->getMutablePrivateState(),
@@ -380,7 +402,9 @@ void GL_APIENTRY GL_VertexAttribI2ui(GLuint index, GLuint x, GLuint y)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribI2ui(context, angle::EntryPoint::GLVertexAttribI2ui, index, x, y));
+             ValidateVertexAttribI2ui(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttribI2ui, index, x, y));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI2ui(context->getMutablePrivateState(),
@@ -405,7 +429,9 @@ void GL_APIENTRY GL_VertexAttribI2uiv(GLuint index, const GLuint *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribI2uiv(context, angle::EntryPoint::GLVertexAttribI2uiv, index, v));
+             ValidateVertexAttribI2uiv(context->getPrivateState(),
+                                       context->getMutableErrorSetForValidation(),
+                                       angle::EntryPoint::GLVertexAttribI2uiv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI2uiv(context->getMutablePrivateState(),
@@ -428,9 +454,11 @@ void GL_APIENTRY GL_VertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateVertexAttribI3i(context, angle::EntryPoint::GLVertexAttribI3i,
-                                                    index, x, y, z));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateVertexAttribI3i(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttribI3i, index, x, y, z));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI3i(context->getMutablePrivateState(),
@@ -455,7 +483,9 @@ void GL_APIENTRY GL_VertexAttribI3iv(GLuint index, const GLint *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribI3iv(context, angle::EntryPoint::GLVertexAttribI3iv, index, v));
+             ValidateVertexAttribI3iv(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttribI3iv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI3iv(context->getMutablePrivateState(),
@@ -478,9 +508,11 @@ void GL_APIENTRY GL_VertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateVertexAttribI3ui(context, angle::EntryPoint::GLVertexAttribI3ui,
-                                                     index, x, y, z));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateVertexAttribI3ui(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttribI3ui, index, x, y, z));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI3ui(context->getMutablePrivateState(),
@@ -505,7 +537,9 @@ void GL_APIENTRY GL_VertexAttribI3uiv(GLuint index, const GLuint *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribI3uiv(context, angle::EntryPoint::GLVertexAttribI3uiv, index, v));
+             ValidateVertexAttribI3uiv(context->getPrivateState(),
+                                       context->getMutableErrorSetForValidation(),
+                                       angle::EntryPoint::GLVertexAttribI3uiv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI3uiv(context->getMutablePrivateState(),
@@ -530,7 +564,9 @@ void GL_APIENTRY GL_VertexAttribI4bv(GLuint index, const GLbyte *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribI4bv(context, angle::EntryPoint::GLVertexAttribI4bv, index, v));
+             ValidateVertexAttribI4bv(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttribI4bv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI4bv(context->getMutablePrivateState(),
@@ -555,7 +591,9 @@ void GL_APIENTRY GL_VertexAttribI4sv(GLuint index, const GLshort *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribI4sv(context, angle::EntryPoint::GLVertexAttribI4sv, index, v));
+             ValidateVertexAttribI4sv(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttribI4sv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI4sv(context->getMutablePrivateState(),
@@ -580,7 +618,9 @@ void GL_APIENTRY GL_VertexAttribI4ubv(GLuint index, const GLubyte *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribI4ubv(context, angle::EntryPoint::GLVertexAttribI4ubv, index, v));
+             ValidateVertexAttribI4ubv(context->getPrivateState(),
+                                       context->getMutableErrorSetForValidation(),
+                                       angle::EntryPoint::GLVertexAttribI4ubv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI4ubv(context->getMutablePrivateState(),
@@ -605,7 +645,9 @@ void GL_APIENTRY GL_VertexAttribI4usv(GLuint index, const GLushort *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribI4usv(context, angle::EntryPoint::GLVertexAttribI4usv, index, v));
+             ValidateVertexAttribI4usv(context->getPrivateState(),
+                                       context->getMutableErrorSetForValidation(),
+                                       angle::EntryPoint::GLVertexAttribI4usv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI4usv(context->getMutablePrivateState(),
@@ -664,11 +706,13 @@ void GL_APIENTRY GL_PrimitiveRestartIndex(GLuint index)
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLPrimitiveRestartIndex) &&
-                             ValidatePrimitiveRestartIndex(
-                                 context, angle::EntryPoint::GLPrimitiveRestartIndex, index)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPrimitiveRestartIndex) &&
+              ValidatePrimitiveRestartIndex(context, angle::EntryPoint::GLPrimitiveRestartIndex,
+                                            index)));
         if (isCallValid)
         {
             context->primitiveRestartIndex(index);
@@ -703,12 +747,14 @@ void GL_APIENTRY GL_MultiDrawElementsBaseVertex(GLenum mode,
         PrimitiveMode modePacked    = PackParam<PrimitiveMode>(mode);
         DrawElementsType typePacked = PackParam<DrawElementsType>(type);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLMultiDrawElementsBaseVertex) &&
-                             ValidateMultiDrawElementsBaseVertex(
-                                 context, angle::EntryPoint::GLMultiDrawElementsBaseVertex,
-                                 modePacked, count, typePacked, indices, drawcount, basevertex)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiDrawElementsBaseVertex) &&
+              ValidateMultiDrawElementsBaseVertex(
+                  context, angle::EntryPoint::GLMultiDrawElementsBaseVertex, modePacked, count,
+                  typePacked, indices, drawcount, basevertex)));
         if (isCallValid)
         {
             context->multiDrawElementsBaseVertex(modePacked, count, typePacked, indices, drawcount,
@@ -735,8 +781,12 @@ void GL_APIENTRY GL_ProvokingVertex(GLenum mode)
         ProvokingVertexConvention modePacked = PackParam<ProvokingVertexConvention>(mode);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProvokingVertex) &&
-              ValidateProvokingVertex(context, angle::EntryPoint::GLProvokingVertex, modePacked)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProvokingVertex) &&
+              ValidateProvokingVertex(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLProvokingVertex, modePacked)));
         if (isCallValid)
         {
             ContextPrivateProvokingVertex(context->getMutablePrivateState(),
@@ -769,12 +819,14 @@ void GL_APIENTRY GL_TexImage2DMultisample(GLenum target,
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLTexImage2DMultisample) &&
-                             ValidateTexImage2DMultisample(
-                                 context, angle::EntryPoint::GLTexImage2DMultisample, target,
-                                 samples, internalformat, width, height, fixedsamplelocations)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexImage2DMultisample) &&
+              ValidateTexImage2DMultisample(context, angle::EntryPoint::GLTexImage2DMultisample,
+                                            target, samples, internalformat, width, height,
+                                            fixedsamplelocations)));
         if (isCallValid)
         {
             context->texImage2DMultisample(target, samples, internalformat, width, height,
@@ -811,7 +863,8 @@ void GL_APIENTRY GL_TexImage3DMultisample(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLTexImage3DMultisample) &&
               ValidateTexImage3DMultisample(context, angle::EntryPoint::GLTexImage3DMultisample,
                                             target, samples, internalformat, width, height, depth,
@@ -846,12 +899,14 @@ void GL_APIENTRY GL_BindFragDataLocationIndexed(GLuint program,
     {
         ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLBindFragDataLocationIndexed) &&
-                             ValidateBindFragDataLocationIndexed(
-                                 context, angle::EntryPoint::GLBindFragDataLocationIndexed,
-                                 programPacked, colorNumber, index, name)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBindFragDataLocationIndexed) &&
+              ValidateBindFragDataLocationIndexed(context,
+                                                  angle::EntryPoint::GLBindFragDataLocationIndexed,
+                                                  programPacked, colorNumber, index, name)));
         if (isCallValid)
         {
             context->bindFragDataLocationIndexed(programPacked, colorNumber, index, name);
@@ -877,7 +932,9 @@ void GL_APIENTRY GL_ColorP3ui(GLenum type, GLuint color)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColorP3ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColorP3ui) &&
               ValidateColorP3ui(context, angle::EntryPoint::GLColorP3ui, type, color)));
         if (isCallValid)
         {
@@ -903,7 +960,9 @@ void GL_APIENTRY GL_ColorP3uiv(GLenum type, const GLuint *color)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColorP3uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColorP3uiv) &&
               ValidateColorP3uiv(context, angle::EntryPoint::GLColorP3uiv, type, color)));
         if (isCallValid)
         {
@@ -929,7 +988,9 @@ void GL_APIENTRY GL_ColorP4ui(GLenum type, GLuint color)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColorP4ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColorP4ui) &&
               ValidateColorP4ui(context, angle::EntryPoint::GLColorP4ui, type, color)));
         if (isCallValid)
         {
@@ -955,7 +1016,9 @@ void GL_APIENTRY GL_ColorP4uiv(GLenum type, const GLuint *color)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColorP4uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColorP4uiv) &&
               ValidateColorP4uiv(context, angle::EntryPoint::GLColorP4uiv, type, color)));
         if (isCallValid)
         {
@@ -1070,7 +1133,9 @@ void GL_APIENTRY GL_MultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoordP1ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoordP1ui) &&
               ValidateMultiTexCoordP1ui(context, angle::EntryPoint::GLMultiTexCoordP1ui, texture,
                                         type, coords)));
         if (isCallValid)
@@ -1099,7 +1164,9 @@ void GL_APIENTRY GL_MultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoordP1uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoordP1uiv) &&
               ValidateMultiTexCoordP1uiv(context, angle::EntryPoint::GLMultiTexCoordP1uiv, texture,
                                          type, coords)));
         if (isCallValid)
@@ -1127,7 +1194,9 @@ void GL_APIENTRY GL_MultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoordP2ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoordP2ui) &&
               ValidateMultiTexCoordP2ui(context, angle::EntryPoint::GLMultiTexCoordP2ui, texture,
                                         type, coords)));
         if (isCallValid)
@@ -1156,7 +1225,9 @@ void GL_APIENTRY GL_MultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoordP2uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoordP2uiv) &&
               ValidateMultiTexCoordP2uiv(context, angle::EntryPoint::GLMultiTexCoordP2uiv, texture,
                                          type, coords)));
         if (isCallValid)
@@ -1184,7 +1255,9 @@ void GL_APIENTRY GL_MultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoordP3ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoordP3ui) &&
               ValidateMultiTexCoordP3ui(context, angle::EntryPoint::GLMultiTexCoordP3ui, texture,
                                         type, coords)));
         if (isCallValid)
@@ -1213,7 +1286,9 @@ void GL_APIENTRY GL_MultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoordP3uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoordP3uiv) &&
               ValidateMultiTexCoordP3uiv(context, angle::EntryPoint::GLMultiTexCoordP3uiv, texture,
                                          type, coords)));
         if (isCallValid)
@@ -1241,7 +1316,9 @@ void GL_APIENTRY GL_MultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoordP4ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoordP4ui) &&
               ValidateMultiTexCoordP4ui(context, angle::EntryPoint::GLMultiTexCoordP4ui, texture,
                                         type, coords)));
         if (isCallValid)
@@ -1270,7 +1347,9 @@ void GL_APIENTRY GL_MultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoordP4uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoordP4uiv) &&
               ValidateMultiTexCoordP4uiv(context, angle::EntryPoint::GLMultiTexCoordP4uiv, texture,
                                          type, coords)));
         if (isCallValid)
@@ -1297,7 +1376,9 @@ void GL_APIENTRY GL_NormalP3ui(GLenum type, GLuint coords)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNormalP3ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNormalP3ui) &&
               ValidateNormalP3ui(context, angle::EntryPoint::GLNormalP3ui, type, coords)));
         if (isCallValid)
         {
@@ -1323,7 +1404,9 @@ void GL_APIENTRY GL_NormalP3uiv(GLenum type, const GLuint *coords)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNormalP3uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNormalP3uiv) &&
               ValidateNormalP3uiv(context, angle::EntryPoint::GLNormalP3uiv, type, coords)));
         if (isCallValid)
         {
@@ -1351,7 +1434,9 @@ void GL_APIENTRY GL_QueryCounter(GLuint id, GLenum target)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLQueryCounter) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLQueryCounter) &&
               ValidateQueryCounter(context, angle::EntryPoint::GLQueryCounter, idPacked,
                                    targetPacked)));
         if (isCallValid)
@@ -1378,7 +1463,9 @@ void GL_APIENTRY GL_SecondaryColorP3ui(GLenum type, GLuint color)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSecondaryColorP3ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColorP3ui) &&
               ValidateSecondaryColorP3ui(context, angle::EntryPoint::GLSecondaryColorP3ui, type,
                                          color)));
         if (isCallValid)
@@ -1403,11 +1490,13 @@ void GL_APIENTRY GL_SecondaryColorP3uiv(GLenum type, const GLuint *color)
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLSecondaryColorP3uiv) &&
-                             ValidateSecondaryColorP3uiv(
-                                 context, angle::EntryPoint::GLSecondaryColorP3uiv, type, color)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSecondaryColorP3uiv) &&
+              ValidateSecondaryColorP3uiv(context, angle::EntryPoint::GLSecondaryColorP3uiv, type,
+                                          color)));
         if (isCallValid)
         {
             context->secondaryColorP3uiv(type, color);
@@ -1432,7 +1521,9 @@ void GL_APIENTRY GL_TexCoordP1ui(GLenum type, GLuint coords)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoordP1ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoordP1ui) &&
               ValidateTexCoordP1ui(context, angle::EntryPoint::GLTexCoordP1ui, type, coords)));
         if (isCallValid)
         {
@@ -1458,7 +1549,9 @@ void GL_APIENTRY GL_TexCoordP1uiv(GLenum type, const GLuint *coords)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoordP1uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoordP1uiv) &&
               ValidateTexCoordP1uiv(context, angle::EntryPoint::GLTexCoordP1uiv, type, coords)));
         if (isCallValid)
         {
@@ -1484,7 +1577,9 @@ void GL_APIENTRY GL_TexCoordP2ui(GLenum type, GLuint coords)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoordP2ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoordP2ui) &&
               ValidateTexCoordP2ui(context, angle::EntryPoint::GLTexCoordP2ui, type, coords)));
         if (isCallValid)
         {
@@ -1510,7 +1605,9 @@ void GL_APIENTRY GL_TexCoordP2uiv(GLenum type, const GLuint *coords)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoordP2uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoordP2uiv) &&
               ValidateTexCoordP2uiv(context, angle::EntryPoint::GLTexCoordP2uiv, type, coords)));
         if (isCallValid)
         {
@@ -1536,7 +1633,9 @@ void GL_APIENTRY GL_TexCoordP3ui(GLenum type, GLuint coords)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoordP3ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoordP3ui) &&
               ValidateTexCoordP3ui(context, angle::EntryPoint::GLTexCoordP3ui, type, coords)));
         if (isCallValid)
         {
@@ -1562,7 +1661,9 @@ void GL_APIENTRY GL_TexCoordP3uiv(GLenum type, const GLuint *coords)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoordP3uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoordP3uiv) &&
               ValidateTexCoordP3uiv(context, angle::EntryPoint::GLTexCoordP3uiv, type, coords)));
         if (isCallValid)
         {
@@ -1588,7 +1689,9 @@ void GL_APIENTRY GL_TexCoordP4ui(GLenum type, GLuint coords)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoordP4ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoordP4ui) &&
               ValidateTexCoordP4ui(context, angle::EntryPoint::GLTexCoordP4ui, type, coords)));
         if (isCallValid)
         {
@@ -1614,7 +1717,9 @@ void GL_APIENTRY GL_TexCoordP4uiv(GLenum type, const GLuint *coords)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoordP4uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoordP4uiv) &&
               ValidateTexCoordP4uiv(context, angle::EntryPoint::GLTexCoordP4uiv, type, coords)));
         if (isCallValid)
         {
@@ -1639,9 +1744,11 @@ void GL_APIENTRY GL_VertexAttribP1ui(GLuint index, GLenum type, GLboolean normal
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateVertexAttribP1ui(context, angle::EntryPoint::GLVertexAttribP1ui,
-                                                     index, type, normalized, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateVertexAttribP1ui(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLVertexAttribP1ui, index, type, normalized, value));
         if (isCallValid)
         {
             ContextPrivateVertexAttribP1ui(context->getMutablePrivateState(),
@@ -1672,8 +1779,9 @@ void GL_APIENTRY GL_VertexAttribP1uiv(GLuint index,
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribP1uiv(context, angle::EntryPoint::GLVertexAttribP1uiv, index, type,
-                                       normalized, value));
+             ValidateVertexAttribP1uiv(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLVertexAttribP1uiv, index, type, normalized, value));
         if (isCallValid)
         {
             ContextPrivateVertexAttribP1uiv(context->getMutablePrivateState(),
@@ -1699,9 +1807,11 @@ void GL_APIENTRY GL_VertexAttribP2ui(GLuint index, GLenum type, GLboolean normal
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateVertexAttribP2ui(context, angle::EntryPoint::GLVertexAttribP2ui,
-                                                     index, type, normalized, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateVertexAttribP2ui(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLVertexAttribP2ui, index, type, normalized, value));
         if (isCallValid)
         {
             ContextPrivateVertexAttribP2ui(context->getMutablePrivateState(),
@@ -1732,8 +1842,9 @@ void GL_APIENTRY GL_VertexAttribP2uiv(GLuint index,
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribP2uiv(context, angle::EntryPoint::GLVertexAttribP2uiv, index, type,
-                                       normalized, value));
+             ValidateVertexAttribP2uiv(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLVertexAttribP2uiv, index, type, normalized, value));
         if (isCallValid)
         {
             ContextPrivateVertexAttribP2uiv(context->getMutablePrivateState(),
@@ -1759,9 +1870,11 @@ void GL_APIENTRY GL_VertexAttribP3ui(GLuint index, GLenum type, GLboolean normal
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateVertexAttribP3ui(context, angle::EntryPoint::GLVertexAttribP3ui,
-                                                     index, type, normalized, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateVertexAttribP3ui(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLVertexAttribP3ui, index, type, normalized, value));
         if (isCallValid)
         {
             ContextPrivateVertexAttribP3ui(context->getMutablePrivateState(),
@@ -1792,8 +1905,9 @@ void GL_APIENTRY GL_VertexAttribP3uiv(GLuint index,
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribP3uiv(context, angle::EntryPoint::GLVertexAttribP3uiv, index, type,
-                                       normalized, value));
+             ValidateVertexAttribP3uiv(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLVertexAttribP3uiv, index, type, normalized, value));
         if (isCallValid)
         {
             ContextPrivateVertexAttribP3uiv(context->getMutablePrivateState(),
@@ -1819,9 +1933,11 @@ void GL_APIENTRY GL_VertexAttribP4ui(GLuint index, GLenum type, GLboolean normal
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateVertexAttribP4ui(context, angle::EntryPoint::GLVertexAttribP4ui,
-                                                     index, type, normalized, value));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateVertexAttribP4ui(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLVertexAttribP4ui, index, type, normalized, value));
         if (isCallValid)
         {
             ContextPrivateVertexAttribP4ui(context->getMutablePrivateState(),
@@ -1852,8 +1968,9 @@ void GL_APIENTRY GL_VertexAttribP4uiv(GLuint index,
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribP4uiv(context, angle::EntryPoint::GLVertexAttribP4uiv, index, type,
-                                       normalized, value));
+             ValidateVertexAttribP4uiv(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLVertexAttribP4uiv, index, type, normalized, value));
         if (isCallValid)
         {
             ContextPrivateVertexAttribP4uiv(context->getMutablePrivateState(),
@@ -1880,7 +1997,9 @@ void GL_APIENTRY GL_VertexP2ui(GLenum type, GLuint value)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertexP2ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertexP2ui) &&
               ValidateVertexP2ui(context, angle::EntryPoint::GLVertexP2ui, type, value)));
         if (isCallValid)
         {
@@ -1906,7 +2025,9 @@ void GL_APIENTRY GL_VertexP2uiv(GLenum type, const GLuint *value)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertexP2uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertexP2uiv) &&
               ValidateVertexP2uiv(context, angle::EntryPoint::GLVertexP2uiv, type, value)));
         if (isCallValid)
         {
@@ -1932,7 +2053,9 @@ void GL_APIENTRY GL_VertexP3ui(GLenum type, GLuint value)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertexP3ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertexP3ui) &&
               ValidateVertexP3ui(context, angle::EntryPoint::GLVertexP3ui, type, value)));
         if (isCallValid)
         {
@@ -1958,7 +2081,9 @@ void GL_APIENTRY GL_VertexP3uiv(GLenum type, const GLuint *value)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertexP3uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertexP3uiv) &&
               ValidateVertexP3uiv(context, angle::EntryPoint::GLVertexP3uiv, type, value)));
         if (isCallValid)
         {
@@ -1984,7 +2109,9 @@ void GL_APIENTRY GL_VertexP4ui(GLenum type, GLuint value)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertexP4ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertexP4ui) &&
               ValidateVertexP4ui(context, angle::EntryPoint::GLVertexP4ui, type, value)));
         if (isCallValid)
         {
@@ -2010,7 +2137,9 @@ void GL_APIENTRY GL_VertexP4uiv(GLenum type, const GLuint *value)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertexP4uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertexP4uiv) &&
               ValidateVertexP4uiv(context, angle::EntryPoint::GLVertexP4uiv, type, value)));
         if (isCallValid)
         {
diff --git a/src/libGLESv2/entry_points_gl_4_autogen.cpp b/src/libGLESv2/entry_points_gl_4_autogen.cpp
index 0b0084e35..f4e911fa0 100644
--- a/src/libGLESv2/entry_points_gl_4_autogen.cpp
+++ b/src/libGLESv2/entry_points_gl_4_autogen.cpp
@@ -45,7 +45,9 @@ void GL_APIENTRY GL_BeginQueryIndexed(GLenum target, GLuint index, GLuint id)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBeginQueryIndexed) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBeginQueryIndexed) &&
               ValidateBeginQueryIndexed(context, angle::EntryPoint::GLBeginQueryIndexed, target,
                                         index, idPacked)));
         if (isCallValid)
@@ -73,7 +75,8 @@ void GL_APIENTRY GL_DrawTransformFeedback(GLenum mode, GLuint id)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLDrawTransformFeedback) &&
               ValidateDrawTransformFeedback(context, angle::EntryPoint::GLDrawTransformFeedback,
                                             mode, idPacked)));
@@ -100,12 +103,14 @@ void GL_APIENTRY GL_DrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint s
     {
         TransformFeedbackID idPacked = PackParam<TransformFeedbackID>(id);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLDrawTransformFeedbackStream) &&
-                             ValidateDrawTransformFeedbackStream(
-                                 context, angle::EntryPoint::GLDrawTransformFeedbackStream, mode,
-                                 idPacked, stream)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDrawTransformFeedbackStream) &&
+              ValidateDrawTransformFeedbackStream(context,
+                                                  angle::EntryPoint::GLDrawTransformFeedbackStream,
+                                                  mode, idPacked, stream)));
         if (isCallValid)
         {
             context->drawTransformFeedbackStream(mode, idPacked, stream);
@@ -130,7 +135,9 @@ void GL_APIENTRY GL_EndQueryIndexed(GLenum target, GLuint index)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEndQueryIndexed) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEndQueryIndexed) &&
               ValidateEndQueryIndexed(context, angle::EntryPoint::GLEndQueryIndexed, target,
                                       index)));
         if (isCallValid)
@@ -459,7 +466,9 @@ void GL_APIENTRY GL_PatchParameterfv(GLenum pname, const GLfloat *values)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPatchParameterfv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPatchParameterfv) &&
               ValidatePatchParameterfv(context, angle::EntryPoint::GLPatchParameterfv, pname,
                                        values)));
         if (isCallValid)
@@ -1011,7 +1020,9 @@ void GL_APIENTRY GL_DepthRangeArrayv(GLuint first, GLsizei count, const GLdouble
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDepthRangeArrayv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDepthRangeArrayv) &&
               ValidateDepthRangeArrayv(context, angle::EntryPoint::GLDepthRangeArrayv, first, count,
                                        v)));
         if (isCallValid)
@@ -1038,7 +1049,9 @@ void GL_APIENTRY GL_DepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDepthRangeIndexed) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDepthRangeIndexed) &&
               ValidateDepthRangeIndexed(context, angle::EntryPoint::GLDepthRangeIndexed, index, n,
                                         f)));
         if (isCallValid)
@@ -1145,7 +1158,9 @@ void GL_APIENTRY GL_ProgramUniform1d(GLuint program, GLint location, GLdouble v0
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform1d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform1d) &&
               ValidateProgramUniform1d(context, angle::EntryPoint::GLProgramUniform1d,
                                        programPacked, locationPacked, v0)));
         if (isCallValid)
@@ -1178,7 +1193,9 @@ void GL_APIENTRY GL_ProgramUniform1dv(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform1dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform1dv) &&
               ValidateProgramUniform1dv(context, angle::EntryPoint::GLProgramUniform1dv,
                                         programPacked, locationPacked, count, value)));
         if (isCallValid)
@@ -1209,7 +1226,9 @@ void GL_APIENTRY GL_ProgramUniform2d(GLuint program, GLint location, GLdouble v0
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform2d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform2d) &&
               ValidateProgramUniform2d(context, angle::EntryPoint::GLProgramUniform2d,
                                        programPacked, locationPacked, v0, v1)));
         if (isCallValid)
@@ -1243,7 +1262,9 @@ void GL_APIENTRY GL_ProgramUniform2dv(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform2dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform2dv) &&
               ValidateProgramUniform2dv(context, angle::EntryPoint::GLProgramUniform2dv,
                                         programPacked, locationPacked, count, value)));
         if (isCallValid)
@@ -1275,7 +1296,9 @@ GL_ProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GL
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform3d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform3d) &&
               ValidateProgramUniform3d(context, angle::EntryPoint::GLProgramUniform3d,
                                        programPacked, locationPacked, v0, v1, v2)));
         if (isCallValid)
@@ -1309,7 +1332,9 @@ void GL_APIENTRY GL_ProgramUniform3dv(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform3dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform3dv) &&
               ValidateProgramUniform3dv(context, angle::EntryPoint::GLProgramUniform3dv,
                                         programPacked, locationPacked, count, value)));
         if (isCallValid)
@@ -1345,7 +1370,9 @@ void GL_APIENTRY GL_ProgramUniform4d(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform4d) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform4d) &&
               ValidateProgramUniform4d(context, angle::EntryPoint::GLProgramUniform4d,
                                        programPacked, locationPacked, v0, v1, v2, v3)));
         if (isCallValid)
@@ -1379,7 +1406,9 @@ void GL_APIENTRY GL_ProgramUniform4dv(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform4dv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform4dv) &&
               ValidateProgramUniform4dv(context, angle::EntryPoint::GLProgramUniform4dv,
                                         programPacked, locationPacked, count, value)));
         if (isCallValid)
@@ -1413,12 +1442,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix2dv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2dv) &&
-                             ValidateProgramUniformMatrix2dv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2dv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix2dv) &&
+              ValidateProgramUniformMatrix2dv(context, angle::EntryPoint::GLProgramUniformMatrix2dv,
+                                              programPacked, locationPacked, count, transpose,
+                                              value)));
         if (isCallValid)
         {
             context->programUniformMatrix2dv(programPacked, locationPacked, count, transpose,
@@ -1451,12 +1482,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix2x3dv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2x3dv) &&
-                             ValidateProgramUniformMatrix2x3dv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2x3dv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix2x3dv) &&
+              ValidateProgramUniformMatrix2x3dv(
+                  context, angle::EntryPoint::GLProgramUniformMatrix2x3dv, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix2x3dv(programPacked, locationPacked, count, transpose,
@@ -1489,12 +1522,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix2x4dv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2x4dv) &&
-                             ValidateProgramUniformMatrix2x4dv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2x4dv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix2x4dv) &&
+              ValidateProgramUniformMatrix2x4dv(
+                  context, angle::EntryPoint::GLProgramUniformMatrix2x4dv, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix2x4dv(programPacked, locationPacked, count, transpose,
@@ -1527,12 +1562,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix3dv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3dv) &&
-                             ValidateProgramUniformMatrix3dv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3dv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix3dv) &&
+              ValidateProgramUniformMatrix3dv(context, angle::EntryPoint::GLProgramUniformMatrix3dv,
+                                              programPacked, locationPacked, count, transpose,
+                                              value)));
         if (isCallValid)
         {
             context->programUniformMatrix3dv(programPacked, locationPacked, count, transpose,
@@ -1565,12 +1602,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix3x2dv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3x2dv) &&
-                             ValidateProgramUniformMatrix3x2dv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3x2dv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix3x2dv) &&
+              ValidateProgramUniformMatrix3x2dv(
+                  context, angle::EntryPoint::GLProgramUniformMatrix3x2dv, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix3x2dv(programPacked, locationPacked, count, transpose,
@@ -1603,12 +1642,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix3x4dv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3x4dv) &&
-                             ValidateProgramUniformMatrix3x4dv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3x4dv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix3x4dv) &&
+              ValidateProgramUniformMatrix3x4dv(
+                  context, angle::EntryPoint::GLProgramUniformMatrix3x4dv, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix3x4dv(programPacked, locationPacked, count, transpose,
@@ -1641,12 +1682,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix4dv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4dv) &&
-                             ValidateProgramUniformMatrix4dv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4dv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix4dv) &&
+              ValidateProgramUniformMatrix4dv(context, angle::EntryPoint::GLProgramUniformMatrix4dv,
+                                              programPacked, locationPacked, count, transpose,
+                                              value)));
         if (isCallValid)
         {
             context->programUniformMatrix4dv(programPacked, locationPacked, count, transpose,
@@ -1679,12 +1722,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix4x2dv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4x2dv) &&
-                             ValidateProgramUniformMatrix4x2dv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4x2dv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix4x2dv) &&
+              ValidateProgramUniformMatrix4x2dv(
+                  context, angle::EntryPoint::GLProgramUniformMatrix4x2dv, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix4x2dv(programPacked, locationPacked, count, transpose,
@@ -1717,12 +1762,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix4x3dv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4x3dv) &&
-                             ValidateProgramUniformMatrix4x3dv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4x3dv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix4x3dv) &&
+              ValidateProgramUniformMatrix4x3dv(
+                  context, angle::EntryPoint::GLProgramUniformMatrix4x3dv, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix4x3dv(programPacked, locationPacked, count, transpose,
@@ -1749,7 +1796,9 @@ void GL_APIENTRY GL_ScissorArrayv(GLuint first, GLsizei count, const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLScissorArrayv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLScissorArrayv) &&
               ValidateScissorArrayv(context, angle::EntryPoint::GLScissorArrayv, first, count, v)));
         if (isCallValid)
         {
@@ -1777,7 +1826,9 @@ GL_ScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLScissorIndexed) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLScissorIndexed) &&
               ValidateScissorIndexed(context, angle::EntryPoint::GLScissorIndexed, index, left,
                                      bottom, width, height)));
         if (isCallValid)
@@ -1804,7 +1855,9 @@ void GL_APIENTRY GL_ScissorIndexedv(GLuint index, const GLint *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLScissorIndexedv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLScissorIndexedv) &&
               ValidateScissorIndexedv(context, angle::EntryPoint::GLScissorIndexedv, index, v)));
         if (isCallValid)
         {
@@ -1828,7 +1881,9 @@ void GL_APIENTRY GL_VertexAttribL1d(GLuint index, GLdouble x)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribL1d(context, angle::EntryPoint::GLVertexAttribL1d, index, x));
+             ValidateVertexAttribL1d(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttribL1d, index, x));
         if (isCallValid)
         {
             ContextPrivateVertexAttribL1d(context->getMutablePrivateState(),
@@ -1853,7 +1908,9 @@ void GL_APIENTRY GL_VertexAttribL1dv(GLuint index, const GLdouble *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribL1dv(context, angle::EntryPoint::GLVertexAttribL1dv, index, v));
+             ValidateVertexAttribL1dv(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttribL1dv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttribL1dv(context->getMutablePrivateState(),
@@ -1878,7 +1935,9 @@ void GL_APIENTRY GL_VertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribL2d(context, angle::EntryPoint::GLVertexAttribL2d, index, x, y));
+             ValidateVertexAttribL2d(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttribL2d, index, x, y));
         if (isCallValid)
         {
             ContextPrivateVertexAttribL2d(context->getMutablePrivateState(),
@@ -1903,7 +1962,9 @@ void GL_APIENTRY GL_VertexAttribL2dv(GLuint index, const GLdouble *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribL2dv(context, angle::EntryPoint::GLVertexAttribL2dv, index, v));
+             ValidateVertexAttribL2dv(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttribL2dv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttribL2dv(context->getMutablePrivateState(),
@@ -1926,9 +1987,11 @@ void GL_APIENTRY GL_VertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdoub
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateVertexAttribL3d(context, angle::EntryPoint::GLVertexAttribL3d,
-                                                    index, x, y, z));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateVertexAttribL3d(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttribL3d, index, x, y, z));
         if (isCallValid)
         {
             ContextPrivateVertexAttribL3d(context->getMutablePrivateState(),
@@ -1953,7 +2016,9 @@ void GL_APIENTRY GL_VertexAttribL3dv(GLuint index, const GLdouble *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribL3dv(context, angle::EntryPoint::GLVertexAttribL3dv, index, v));
+             ValidateVertexAttribL3dv(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttribL3dv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttribL3dv(context->getMutablePrivateState(),
@@ -1976,9 +2041,11 @@ void GL_APIENTRY GL_VertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdoub
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateVertexAttribL4d(context, angle::EntryPoint::GLVertexAttribL4d,
-                                                    index, x, y, z, w));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateVertexAttribL4d(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttribL4d, index, x, y, z, w));
         if (isCallValid)
         {
             ContextPrivateVertexAttribL4d(context->getMutablePrivateState(),
@@ -2004,7 +2071,9 @@ void GL_APIENTRY GL_VertexAttribL4dv(GLuint index, const GLdouble *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribL4dv(context, angle::EntryPoint::GLVertexAttribL4dv, index, v));
+             ValidateVertexAttribL4dv(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttribL4dv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttribL4dv(context->getMutablePrivateState(),
@@ -2061,7 +2130,9 @@ void GL_APIENTRY GL_ViewportArrayv(GLuint first, GLsizei count, const GLfloat *v
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLViewportArrayv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLViewportArrayv) &&
               ValidateViewportArrayv(context, angle::EntryPoint::GLViewportArrayv, first, count,
                                      v)));
         if (isCallValid)
@@ -2088,7 +2159,9 @@ void GL_APIENTRY GL_ViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLViewportIndexedf) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLViewportIndexedf) &&
               ValidateViewportIndexedf(context, angle::EntryPoint::GLViewportIndexedf, index, x, y,
                                        w, h)));
         if (isCallValid)
@@ -2115,7 +2188,9 @@ void GL_APIENTRY GL_ViewportIndexedfv(GLuint index, const GLfloat *v)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLViewportIndexedfv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLViewportIndexedfv) &&
               ValidateViewportIndexedfv(context, angle::EntryPoint::GLViewportIndexedfv, index,
                                         v)));
         if (isCallValid)
@@ -2260,12 +2335,14 @@ void GL_APIENTRY GL_DrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsiz
     {
         TransformFeedbackID idPacked = PackParam<TransformFeedbackID>(id);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLDrawTransformFeedbackInstanced) &&
-                             ValidateDrawTransformFeedbackInstanced(
-                                 context, angle::EntryPoint::GLDrawTransformFeedbackInstanced, mode,
-                                 idPacked, instancecount)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLDrawTransformFeedbackInstanced) &&
+              ValidateDrawTransformFeedbackInstanced(
+                  context, angle::EntryPoint::GLDrawTransformFeedbackInstanced, mode, idPacked,
+                  instancecount)));
         if (isCallValid)
         {
             context->drawTransformFeedbackInstanced(mode, idPacked, instancecount);
@@ -2297,7 +2374,8 @@ void GL_APIENTRY GL_DrawTransformFeedbackStreamInstanced(GLenum mode,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLDrawTransformFeedbackStreamInstanced) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLDrawTransformFeedbackStreamInstanced) &&
               ValidateDrawTransformFeedbackStreamInstanced(
                   context, angle::EntryPoint::GLDrawTransformFeedbackStreamInstanced, mode,
                   idPacked, stream, instancecount)));
@@ -2364,7 +2442,9 @@ void GL_APIENTRY GL_TexStorage1D(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexStorage1D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexStorage1D) &&
               ValidateTexStorage1D(context, angle::EntryPoint::GLTexStorage1D, target, levels,
                                    internalformat, width)));
         if (isCallValid)
@@ -2544,7 +2624,8 @@ void GL_APIENTRY GL_InvalidateBufferData(GLuint buffer)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLInvalidateBufferData) &&
               ValidateInvalidateBufferData(context, angle::EntryPoint::GLInvalidateBufferData,
                                            bufferPacked)));
@@ -2574,7 +2655,8 @@ void GL_APIENTRY GL_InvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsi
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLInvalidateBufferSubData) &&
               ValidateInvalidateBufferSubData(context, angle::EntryPoint::GLInvalidateBufferSubData,
                                               bufferPacked, offset, length)));
@@ -2604,7 +2686,9 @@ void GL_APIENTRY GL_InvalidateTexImage(GLuint texture, GLint level)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLInvalidateTexImage) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLInvalidateTexImage) &&
               ValidateInvalidateTexImage(context, angle::EntryPoint::GLInvalidateTexImage,
                                          texturePacked, level)));
         if (isCallValid)
@@ -2639,12 +2723,14 @@ void GL_APIENTRY GL_InvalidateTexSubImage(GLuint texture,
     {
         TextureID texturePacked = PackParam<TextureID>(texture);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLInvalidateTexSubImage) &&
-                             ValidateInvalidateTexSubImage(
-                                 context, angle::EntryPoint::GLInvalidateTexSubImage, texturePacked,
-                                 level, xoffset, yoffset, zoffset, width, height, depth)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLInvalidateTexSubImage) &&
+              ValidateInvalidateTexSubImage(context, angle::EntryPoint::GLInvalidateTexSubImage,
+                                            texturePacked, level, xoffset, yoffset, zoffset, width,
+                                            height, depth)));
         if (isCallValid)
         {
             context->invalidateTexSubImage(texturePacked, level, xoffset, yoffset, zoffset, width,
@@ -2677,7 +2763,8 @@ void GL_APIENTRY GL_MultiDrawArraysIndirect(GLenum mode,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLMultiDrawArraysIndirect) &&
               ValidateMultiDrawArraysIndirect(context, angle::EntryPoint::GLMultiDrawArraysIndirect,
                                               modePacked, indirect, drawcount, stride)));
@@ -2714,12 +2801,14 @@ void GL_APIENTRY GL_MultiDrawElementsIndirect(GLenum mode,
         PrimitiveMode modePacked    = PackParam<PrimitiveMode>(mode);
         DrawElementsType typePacked = PackParam<DrawElementsType>(type);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLMultiDrawElementsIndirect) &&
-                             ValidateMultiDrawElementsIndirect(
-                                 context, angle::EntryPoint::GLMultiDrawElementsIndirect,
-                                 modePacked, typePacked, indirect, drawcount, stride)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiDrawElementsIndirect) &&
+              ValidateMultiDrawElementsIndirect(
+                  context, angle::EntryPoint::GLMultiDrawElementsIndirect, modePacked, typePacked,
+                  indirect, drawcount, stride)));
         if (isCallValid)
         {
             context->multiDrawElementsIndirect(modePacked, typePacked, indirect, drawcount, stride);
@@ -2747,12 +2836,14 @@ void GL_APIENTRY GL_ShaderStorageBlockBinding(GLuint program,
     {
         ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLShaderStorageBlockBinding) &&
-                             ValidateShaderStorageBlockBinding(
-                                 context, angle::EntryPoint::GLShaderStorageBlockBinding,
-                                 programPacked, storageBlockIndex, storageBlockBinding)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLShaderStorageBlockBinding) &&
+              ValidateShaderStorageBlockBinding(
+                  context, angle::EntryPoint::GLShaderStorageBlockBinding, programPacked,
+                  storageBlockIndex, storageBlockBinding)));
         if (isCallValid)
         {
             context->shaderStorageBlockBinding(programPacked, storageBlockIndex,
@@ -2791,7 +2882,9 @@ void GL_APIENTRY GL_TextureView(GLuint texture,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTextureView) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTextureView) &&
               ValidateTextureView(context, angle::EntryPoint::GLTextureView, texturePacked, target,
                                   origtexture, internalformat, minlevel, numlevels, minlayer,
                                   numlayers)));
@@ -2859,7 +2952,9 @@ void GL_APIENTRY GL_BindBuffersBase(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBindBuffersBase) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBindBuffersBase) &&
               ValidateBindBuffersBase(context, angle::EntryPoint::GLBindBuffersBase, target, first,
                                       count, buffersPacked)));
         if (isCallValid)
@@ -2896,7 +2991,9 @@ void GL_APIENTRY GL_BindBuffersRange(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBindBuffersRange) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBindBuffersRange) &&
               ValidateBindBuffersRange(context, angle::EntryPoint::GLBindBuffersRange, target,
                                        first, count, buffersPacked, offsets, sizes)));
         if (isCallValid)
@@ -2925,7 +3022,9 @@ void GL_APIENTRY GL_BindImageTextures(GLuint first, GLsizei count, const GLuint
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBindImageTextures) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBindImageTextures) &&
               ValidateBindImageTextures(context, angle::EntryPoint::GLBindImageTextures, first,
                                         count, textures)));
         if (isCallValid)
@@ -2953,7 +3052,9 @@ void GL_APIENTRY GL_BindSamplers(GLuint first, GLsizei count, const GLuint *samp
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBindSamplers) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBindSamplers) &&
               ValidateBindSamplers(context, angle::EntryPoint::GLBindSamplers, first, count,
                                    samplers)));
         if (isCallValid)
@@ -2981,7 +3082,9 @@ void GL_APIENTRY GL_BindTextures(GLuint first, GLsizei count, const GLuint *text
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBindTextures) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBindTextures) &&
               ValidateBindTextures(context, angle::EntryPoint::GLBindTextures, first, count,
                                    textures)));
         if (isCallValid)
@@ -3015,7 +3118,9 @@ void GL_APIENTRY GL_BindVertexBuffers(GLuint first,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBindVertexBuffers) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBindVertexBuffers) &&
               ValidateBindVertexBuffers(context, angle::EntryPoint::GLBindVertexBuffers, first,
                                         count, buffersPacked, offsets, strides)));
         if (isCallValid)
@@ -3050,7 +3155,9 @@ void GL_APIENTRY GL_BufferStorage(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBufferStorage) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBufferStorage) &&
               ValidateBufferStorage(context, angle::EntryPoint::GLBufferStorage, targetPacked, size,
                                     data, flags)));
         if (isCallValid)
@@ -3082,7 +3189,9 @@ GL_ClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLClearTexImage) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClearTexImage) &&
               ValidateClearTexImage(context, angle::EntryPoint::GLClearTexImage, texturePacked,
                                     level, format, type, data)));
         if (isCallValid)
@@ -3125,7 +3234,9 @@ void GL_APIENTRY GL_ClearTexSubImage(GLuint texture,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLClearTexSubImage) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClearTexSubImage) &&
               ValidateClearTexSubImage(context, angle::EntryPoint::GLClearTexSubImage,
                                        texturePacked, level, xoffset, yoffset, zoffset, width,
                                        height, depth, format, type, data)));
@@ -3157,7 +3268,9 @@ void GL_APIENTRY GL_BindTextureUnit(GLuint unit, GLuint texture)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBindTextureUnit) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBindTextureUnit) &&
               ValidateBindTextureUnit(context, angle::EntryPoint::GLBindTextureUnit, unit,
                                       texturePacked)));
         if (isCallValid)
@@ -3200,7 +3313,8 @@ void GL_APIENTRY GL_BlitNamedFramebuffer(GLuint readFramebuffer,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLBlitNamedFramebuffer) &&
               ValidateBlitNamedFramebuffer(context, angle::EntryPoint::GLBlitNamedFramebuffer,
                                            readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1,
@@ -3232,12 +3346,14 @@ GLenum GL_APIENTRY GL_CheckNamedFramebufferStatus(GLuint framebuffer, GLenum tar
     {
         FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLCheckNamedFramebufferStatus) &&
-                             ValidateCheckNamedFramebufferStatus(
-                                 context, angle::EntryPoint::GLCheckNamedFramebufferStatus,
-                                 framebufferPacked, target)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCheckNamedFramebufferStatus) &&
+              ValidateCheckNamedFramebufferStatus(context,
+                                                  angle::EntryPoint::GLCheckNamedFramebufferStatus,
+                                                  framebufferPacked, target)));
         if (isCallValid)
         {
             returnValue = context->checkNamedFramebufferStatus(framebufferPacked, target);
@@ -3280,7 +3396,8 @@ void GL_APIENTRY GL_ClearNamedBufferData(GLuint buffer,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLClearNamedBufferData) &&
               ValidateClearNamedBufferData(context, angle::EntryPoint::GLClearNamedBufferData,
                                            bufferPacked, internalformat, format, type, data)));
@@ -3319,12 +3436,14 @@ void GL_APIENTRY GL_ClearNamedBufferSubData(GLuint buffer,
     {
         BufferID bufferPacked = PackParam<BufferID>(buffer);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLClearNamedBufferSubData) &&
-                             ValidateClearNamedBufferSubData(
-                                 context, angle::EntryPoint::GLClearNamedBufferSubData,
-                                 bufferPacked, internalformat, offset, size, format, type, data)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClearNamedBufferSubData) &&
+              ValidateClearNamedBufferSubData(context, angle::EntryPoint::GLClearNamedBufferSubData,
+                                              bufferPacked, internalformat, offset, size, format,
+                                              type, data)));
         if (isCallValid)
         {
             context->clearNamedBufferSubData(bufferPacked, internalformat, offset, size, format,
@@ -3356,12 +3475,14 @@ void GL_APIENTRY GL_ClearNamedFramebufferfi(GLuint framebuffer,
     {
         FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLClearNamedFramebufferfi) &&
-                             ValidateClearNamedFramebufferfi(
-                                 context, angle::EntryPoint::GLClearNamedFramebufferfi,
-                                 framebufferPacked, buffer, drawbuffer, depth, stencil)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClearNamedFramebufferfi) &&
+              ValidateClearNamedFramebufferfi(context, angle::EntryPoint::GLClearNamedFramebufferfi,
+                                              framebufferPacked, buffer, drawbuffer, depth,
+                                              stencil)));
         if (isCallValid)
         {
             context->clearNamedFramebufferfi(framebufferPacked, buffer, drawbuffer, depth, stencil);
@@ -3393,7 +3514,8 @@ void GL_APIENTRY GL_ClearNamedFramebufferfv(GLuint framebuffer,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLClearNamedFramebufferfv) &&
               ValidateClearNamedFramebufferfv(context, angle::EntryPoint::GLClearNamedFramebufferfv,
                                               framebufferPacked, buffer, drawbuffer, value)));
@@ -3428,7 +3550,8 @@ void GL_APIENTRY GL_ClearNamedFramebufferiv(GLuint framebuffer,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLClearNamedFramebufferiv) &&
               ValidateClearNamedFramebufferiv(context, angle::EntryPoint::GLClearNamedFramebufferiv,
                                               framebufferPacked, buffer, drawbuffer, value)));
@@ -3461,12 +3584,14 @@ void GL_APIENTRY GL_ClearNamedFramebufferuiv(GLuint framebuffer,
     {
         FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLClearNamedFramebufferuiv) &&
-                             ValidateClearNamedFramebufferuiv(
-                                 context, angle::EntryPoint::GLClearNamedFramebufferuiv,
-                                 framebufferPacked, buffer, drawbuffer, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClearNamedFramebufferuiv) &&
+              ValidateClearNamedFramebufferuiv(context,
+                                               angle::EntryPoint::GLClearNamedFramebufferuiv,
+                                               framebufferPacked, buffer, drawbuffer, value)));
         if (isCallValid)
         {
             context->clearNamedFramebufferuiv(framebufferPacked, buffer, drawbuffer, value);
@@ -3494,9 +3619,12 @@ void GL_APIENTRY GL_ClipControl(GLenum origin, GLenum depth)
         ClipDepthMode depthPacked = PackParam<ClipDepthMode>(depth);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLClipControl) &&
-              ValidateClipControl(context, angle::EntryPoint::GLClipControl, originPacked,
-                                  depthPacked)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClipControl) &&
+              ValidateClipControl(context->getPrivateState(),
+                                  context->getMutableErrorSetForValidation(),
+                                  angle::EntryPoint::GLClipControl, originPacked, depthPacked)));
         if (isCallValid)
         {
             ContextPrivateClipControl(context->getMutablePrivateState(),
@@ -3531,12 +3659,14 @@ void GL_APIENTRY GL_CompressedTextureSubImage1D(GLuint texture,
     {
         TextureID texturePacked = PackParam<TextureID>(texture);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLCompressedTextureSubImage1D) &&
-                             ValidateCompressedTextureSubImage1D(
-                                 context, angle::EntryPoint::GLCompressedTextureSubImage1D,
-                                 texturePacked, level, xoffset, width, format, imageSize, data)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCompressedTextureSubImage1D) &&
+              ValidateCompressedTextureSubImage1D(
+                  context, angle::EntryPoint::GLCompressedTextureSubImage1D, texturePacked, level,
+                  xoffset, width, format, imageSize, data)));
         if (isCallValid)
         {
             context->compressedTextureSubImage1D(texturePacked, level, xoffset, width, format,
@@ -3575,7 +3705,8 @@ void GL_APIENTRY GL_CompressedTextureSubImage2D(GLuint texture,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCompressedTextureSubImage2D) &&
               ValidateCompressedTextureSubImage2D(
                   context, angle::EntryPoint::GLCompressedTextureSubImage2D, texturePacked, level,
@@ -3620,7 +3751,8 @@ void GL_APIENTRY GL_CompressedTextureSubImage3D(GLuint texture,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCompressedTextureSubImage3D) &&
               ValidateCompressedTextureSubImage3D(
                   context, angle::EntryPoint::GLCompressedTextureSubImage3D, texturePacked, level,
@@ -3656,12 +3788,14 @@ void GL_APIENTRY GL_CopyNamedBufferSubData(GLuint readBuffer,
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLCopyNamedBufferSubData) &&
-                             ValidateCopyNamedBufferSubData(
-                                 context, angle::EntryPoint::GLCopyNamedBufferSubData, readBuffer,
-                                 writeBuffer, readOffset, writeOffset, size)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCopyNamedBufferSubData) &&
+              ValidateCopyNamedBufferSubData(context, angle::EntryPoint::GLCopyNamedBufferSubData,
+                                             readBuffer, writeBuffer, readOffset, writeOffset,
+                                             size)));
         if (isCallValid)
         {
             context->copyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);
@@ -3694,7 +3828,8 @@ void GL_APIENTRY GL_CopyTextureSubImage1D(GLuint texture,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCopyTextureSubImage1D) &&
               ValidateCopyTextureSubImage1D(context, angle::EntryPoint::GLCopyTextureSubImage1D,
                                             texturePacked, level, xoffset, x, y, width)));
@@ -3731,12 +3866,14 @@ void GL_APIENTRY GL_CopyTextureSubImage2D(GLuint texture,
     {
         TextureID texturePacked = PackParam<TextureID>(texture);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLCopyTextureSubImage2D) &&
-                             ValidateCopyTextureSubImage2D(
-                                 context, angle::EntryPoint::GLCopyTextureSubImage2D, texturePacked,
-                                 level, xoffset, yoffset, x, y, width, height)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCopyTextureSubImage2D) &&
+              ValidateCopyTextureSubImage2D(context, angle::EntryPoint::GLCopyTextureSubImage2D,
+                                            texturePacked, level, xoffset, yoffset, x, y, width,
+                                            height)));
         if (isCallValid)
         {
             context->copyTextureSubImage2D(texturePacked, level, xoffset, yoffset, x, y, width,
@@ -3772,12 +3909,14 @@ void GL_APIENTRY GL_CopyTextureSubImage3D(GLuint texture,
     {
         TextureID texturePacked = PackParam<TextureID>(texture);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLCopyTextureSubImage3D) &&
-                             ValidateCopyTextureSubImage3D(
-                                 context, angle::EntryPoint::GLCopyTextureSubImage3D, texturePacked,
-                                 level, xoffset, yoffset, zoffset, x, y, width, height)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCopyTextureSubImage3D) &&
+              ValidateCopyTextureSubImage3D(context, angle::EntryPoint::GLCopyTextureSubImage3D,
+                                            texturePacked, level, xoffset, yoffset, zoffset, x, y,
+                                            width, height)));
         if (isCallValid)
         {
             context->copyTextureSubImage3D(texturePacked, level, xoffset, yoffset, zoffset, x, y,
@@ -3805,7 +3944,9 @@ void GL_APIENTRY GL_CreateBuffers(GLsizei n, GLuint *buffers)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCreateBuffers) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCreateBuffers) &&
               ValidateCreateBuffers(context, angle::EntryPoint::GLCreateBuffers, n,
                                     buffersPacked)));
         if (isCallValid)
@@ -3832,7 +3973,9 @@ void GL_APIENTRY GL_CreateFramebuffers(GLsizei n, GLuint *framebuffers)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCreateFramebuffers) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCreateFramebuffers) &&
               ValidateCreateFramebuffers(context, angle::EntryPoint::GLCreateFramebuffers, n,
                                          framebuffers)));
         if (isCallValid)
@@ -3859,7 +4002,8 @@ void GL_APIENTRY GL_CreateProgramPipelines(GLsizei n, GLuint *pipelines)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCreateProgramPipelines) &&
               ValidateCreateProgramPipelines(context, angle::EntryPoint::GLCreateProgramPipelines,
                                              n, pipelines)));
@@ -3887,7 +4031,9 @@ void GL_APIENTRY GL_CreateQueries(GLenum target, GLsizei n, GLuint *ids)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCreateQueries) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCreateQueries) &&
               ValidateCreateQueries(context, angle::EntryPoint::GLCreateQueries, target, n, ids)));
         if (isCallValid)
         {
@@ -3914,7 +4060,8 @@ void GL_APIENTRY GL_CreateRenderbuffers(GLsizei n, GLuint *renderbuffers)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCreateRenderbuffers) &&
               ValidateCreateRenderbuffers(context, angle::EntryPoint::GLCreateRenderbuffers, n,
                                           renderbuffersPacked)));
@@ -3942,7 +4089,9 @@ void GL_APIENTRY GL_CreateSamplers(GLsizei n, GLuint *samplers)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCreateSamplers) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCreateSamplers) &&
               ValidateCreateSamplers(context, angle::EntryPoint::GLCreateSamplers, n, samplers)));
         if (isCallValid)
         {
@@ -3969,7 +4118,9 @@ void GL_APIENTRY GL_CreateTextures(GLenum target, GLsizei n, GLuint *textures)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCreateTextures) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCreateTextures) &&
               ValidateCreateTextures(context, angle::EntryPoint::GLCreateTextures, target, n,
                                      textures)));
         if (isCallValid)
@@ -3994,11 +4145,13 @@ void GL_APIENTRY GL_CreateTransformFeedbacks(GLsizei n, GLuint *ids)
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLCreateTransformFeedbacks) &&
-                             ValidateCreateTransformFeedbacks(
-                                 context, angle::EntryPoint::GLCreateTransformFeedbacks, n, ids)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCreateTransformFeedbacks) &&
+              ValidateCreateTransformFeedbacks(
+                  context, angle::EntryPoint::GLCreateTransformFeedbacks, n, ids)));
         if (isCallValid)
         {
             context->createTransformFeedbacks(n, ids);
@@ -4024,7 +4177,9 @@ void GL_APIENTRY GL_CreateVertexArrays(GLsizei n, GLuint *arrays)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCreateVertexArrays) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCreateVertexArrays) &&
               ValidateCreateVertexArrays(context, angle::EntryPoint::GLCreateVertexArrays, n,
                                          arraysPacked)));
         if (isCallValid)
@@ -4052,7 +4207,8 @@ void GL_APIENTRY GL_DisableVertexArrayAttrib(GLuint vaobj, GLuint index)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLDisableVertexArrayAttrib) &&
               ValidateDisableVertexArrayAttrib(
                   context, angle::EntryPoint::GLDisableVertexArrayAttrib, vaobjPacked, index)));
@@ -4081,7 +4237,8 @@ void GL_APIENTRY GL_EnableVertexArrayAttrib(GLuint vaobj, GLuint index)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLEnableVertexArrayAttrib) &&
               ValidateEnableVertexArrayAttrib(context, angle::EntryPoint::GLEnableVertexArrayAttrib,
                                               vaobjPacked, index)));
@@ -4109,12 +4266,14 @@ void GL_APIENTRY GL_FlushMappedNamedBufferRange(GLuint buffer, GLintptr offset,
     {
         BufferID bufferPacked = PackParam<BufferID>(buffer);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLFlushMappedNamedBufferRange) &&
-                             ValidateFlushMappedNamedBufferRange(
-                                 context, angle::EntryPoint::GLFlushMappedNamedBufferRange,
-                                 bufferPacked, offset, length)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFlushMappedNamedBufferRange) &&
+              ValidateFlushMappedNamedBufferRange(context,
+                                                  angle::EntryPoint::GLFlushMappedNamedBufferRange,
+                                                  bufferPacked, offset, length)));
         if (isCallValid)
         {
             context->flushMappedNamedBufferRange(bufferPacked, offset, length);
@@ -5471,12 +5630,14 @@ void GL_APIENTRY GL_InvalidateNamedFramebufferData(GLuint framebuffer,
     {
         FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLInvalidateNamedFramebufferData) &&
-                             ValidateInvalidateNamedFramebufferData(
-                                 context, angle::EntryPoint::GLInvalidateNamedFramebufferData,
-                                 framebufferPacked, numAttachments, attachments)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLInvalidateNamedFramebufferData) &&
+              ValidateInvalidateNamedFramebufferData(
+                  context, angle::EntryPoint::GLInvalidateNamedFramebufferData, framebufferPacked,
+                  numAttachments, attachments)));
         if (isCallValid)
         {
             context->invalidateNamedFramebufferData(framebufferPacked, numAttachments, attachments);
@@ -5512,7 +5673,8 @@ void GL_APIENTRY GL_InvalidateNamedFramebufferSubData(GLuint framebuffer,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLInvalidateNamedFramebufferSubData) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLInvalidateNamedFramebufferSubData) &&
               ValidateInvalidateNamedFramebufferSubData(
                   context, angle::EntryPoint::GLInvalidateNamedFramebufferSubData,
                   framebufferPacked, numAttachments, attachments, x, y, width, height)));
@@ -5544,7 +5706,9 @@ void *GL_APIENTRY GL_MapNamedBuffer(GLuint buffer, GLenum access)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMapNamedBuffer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMapNamedBuffer) &&
               ValidateMapNamedBuffer(context, angle::EntryPoint::GLMapNamedBuffer, bufferPacked,
                                      access)));
         if (isCallValid)
@@ -5584,7 +5748,8 @@ void *GL_APIENTRY GL_MapNamedBufferRange(GLuint buffer,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLMapNamedBufferRange) &&
               ValidateMapNamedBufferRange(context, angle::EntryPoint::GLMapNamedBufferRange,
                                           bufferPacked, offset, length, access)));
@@ -5622,7 +5787,9 @@ void GL_APIENTRY GL_NamedBufferData(GLuint buffer, GLsizeiptr size, const void *
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNamedBufferData) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNamedBufferData) &&
               ValidateNamedBufferData(context, angle::EntryPoint::GLNamedBufferData, bufferPacked,
                                       size, data, usage)));
         if (isCallValid)
@@ -5655,7 +5822,9 @@ void GL_APIENTRY GL_NamedBufferStorage(GLuint buffer,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNamedBufferStorage) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNamedBufferStorage) &&
               ValidateNamedBufferStorage(context, angle::EntryPoint::GLNamedBufferStorage,
                                          bufferPacked, size, data, flags)));
         if (isCallValid)
@@ -5688,7 +5857,9 @@ void GL_APIENTRY GL_NamedBufferSubData(GLuint buffer,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNamedBufferSubData) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNamedBufferSubData) &&
               ValidateNamedBufferSubData(context, angle::EntryPoint::GLNamedBufferSubData,
                                          bufferPacked, offset, size, data)));
         if (isCallValid)
@@ -5715,12 +5886,14 @@ void GL_APIENTRY GL_NamedFramebufferDrawBuffer(GLuint framebuffer, GLenum buf)
     {
         FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLNamedFramebufferDrawBuffer) &&
-                             ValidateNamedFramebufferDrawBuffer(
-                                 context, angle::EntryPoint::GLNamedFramebufferDrawBuffer,
-                                 framebufferPacked, buf)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNamedFramebufferDrawBuffer) &&
+              ValidateNamedFramebufferDrawBuffer(context,
+                                                 angle::EntryPoint::GLNamedFramebufferDrawBuffer,
+                                                 framebufferPacked, buf)));
         if (isCallValid)
         {
             context->namedFramebufferDrawBuffer(framebufferPacked, buf);
@@ -5745,12 +5918,14 @@ void GL_APIENTRY GL_NamedFramebufferDrawBuffers(GLuint framebuffer, GLsizei n, c
     {
         FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLNamedFramebufferDrawBuffers) &&
-                             ValidateNamedFramebufferDrawBuffers(
-                                 context, angle::EntryPoint::GLNamedFramebufferDrawBuffers,
-                                 framebufferPacked, n, bufs)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNamedFramebufferDrawBuffers) &&
+              ValidateNamedFramebufferDrawBuffers(context,
+                                                  angle::EntryPoint::GLNamedFramebufferDrawBuffers,
+                                                  framebufferPacked, n, bufs)));
         if (isCallValid)
         {
             context->namedFramebufferDrawBuffers(framebufferPacked, n, bufs);
@@ -5776,12 +5951,14 @@ void GL_APIENTRY GL_NamedFramebufferParameteri(GLuint framebuffer, GLenum pname,
     {
         FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLNamedFramebufferParameteri) &&
-                             ValidateNamedFramebufferParameteri(
-                                 context, angle::EntryPoint::GLNamedFramebufferParameteri,
-                                 framebufferPacked, pname, param)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNamedFramebufferParameteri) &&
+              ValidateNamedFramebufferParameteri(context,
+                                                 angle::EntryPoint::GLNamedFramebufferParameteri,
+                                                 framebufferPacked, pname, param)));
         if (isCallValid)
         {
             context->namedFramebufferParameteri(framebufferPacked, pname, param);
@@ -5806,12 +5983,14 @@ void GL_APIENTRY GL_NamedFramebufferReadBuffer(GLuint framebuffer, GLenum src)
     {
         FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLNamedFramebufferReadBuffer) &&
-                             ValidateNamedFramebufferReadBuffer(
-                                 context, angle::EntryPoint::GLNamedFramebufferReadBuffer,
-                                 framebufferPacked, src)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNamedFramebufferReadBuffer) &&
+              ValidateNamedFramebufferReadBuffer(context,
+                                                 angle::EntryPoint::GLNamedFramebufferReadBuffer,
+                                                 framebufferPacked, src)));
         if (isCallValid)
         {
             context->namedFramebufferReadBuffer(framebufferPacked, src);
@@ -5845,7 +6024,8 @@ void GL_APIENTRY GL_NamedFramebufferRenderbuffer(GLuint framebuffer,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLNamedFramebufferRenderbuffer) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLNamedFramebufferRenderbuffer) &&
               ValidateNamedFramebufferRenderbuffer(
                   context, angle::EntryPoint::GLNamedFramebufferRenderbuffer, framebufferPacked,
                   attachment, renderbuffertarget, renderbufferPacked)));
@@ -5880,12 +6060,14 @@ void GL_APIENTRY GL_NamedFramebufferTexture(GLuint framebuffer,
         FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
         TextureID texturePacked         = PackParam<TextureID>(texture);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLNamedFramebufferTexture) &&
-                             ValidateNamedFramebufferTexture(
-                                 context, angle::EntryPoint::GLNamedFramebufferTexture,
-                                 framebufferPacked, attachment, texturePacked, level)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNamedFramebufferTexture) &&
+              ValidateNamedFramebufferTexture(context, angle::EntryPoint::GLNamedFramebufferTexture,
+                                              framebufferPacked, attachment, texturePacked,
+                                              level)));
         if (isCallValid)
         {
             context->namedFramebufferTexture(framebufferPacked, attachment, texturePacked, level);
@@ -5917,12 +6099,14 @@ void GL_APIENTRY GL_NamedFramebufferTextureLayer(GLuint framebuffer,
         FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
         TextureID texturePacked         = PackParam<TextureID>(texture);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLNamedFramebufferTextureLayer) &&
-                             ValidateNamedFramebufferTextureLayer(
-                                 context, angle::EntryPoint::GLNamedFramebufferTextureLayer,
-                                 framebufferPacked, attachment, texturePacked, level, layer)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLNamedFramebufferTextureLayer) &&
+              ValidateNamedFramebufferTextureLayer(
+                  context, angle::EntryPoint::GLNamedFramebufferTextureLayer, framebufferPacked,
+                  attachment, texturePacked, level, layer)));
         if (isCallValid)
         {
             context->namedFramebufferTextureLayer(framebufferPacked, attachment, texturePacked,
@@ -5953,12 +6137,14 @@ void GL_APIENTRY GL_NamedRenderbufferStorage(GLuint renderbuffer,
     {
         RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLNamedRenderbufferStorage) &&
-                             ValidateNamedRenderbufferStorage(
-                                 context, angle::EntryPoint::GLNamedRenderbufferStorage,
-                                 renderbufferPacked, internalformat, width, height)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNamedRenderbufferStorage) &&
+              ValidateNamedRenderbufferStorage(context,
+                                               angle::EntryPoint::GLNamedRenderbufferStorage,
+                                               renderbufferPacked, internalformat, width, height)));
         if (isCallValid)
         {
             context->namedRenderbufferStorage(renderbufferPacked, internalformat, width, height);
@@ -5993,7 +6179,8 @@ void GL_APIENTRY GL_NamedRenderbufferStorageMultisample(GLuint renderbuffer,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLNamedRenderbufferStorageMultisample) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLNamedRenderbufferStorageMultisample) &&
               ValidateNamedRenderbufferStorageMultisample(
                   context, angle::EntryPoint::GLNamedRenderbufferStorageMultisample,
                   renderbufferPacked, samples, internalformat, width, height)));
@@ -6022,7 +6209,9 @@ void GL_APIENTRY GL_TextureBarrier()
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTextureBarrier) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTextureBarrier) &&
               ValidateTextureBarrier(context, angle::EntryPoint::GLTextureBarrier)));
         if (isCallValid)
         {
@@ -6051,7 +6240,9 @@ void GL_APIENTRY GL_TextureBuffer(GLuint texture, GLenum internalformat, GLuint
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTextureBuffer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTextureBuffer) &&
               ValidateTextureBuffer(context, angle::EntryPoint::GLTextureBuffer, texturePacked,
                                     internalformat, bufferPacked)));
         if (isCallValid)
@@ -6088,7 +6279,9 @@ void GL_APIENTRY GL_TextureBufferRange(GLuint texture,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTextureBufferRange) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTextureBufferRange) &&
               ValidateTextureBufferRange(context, angle::EntryPoint::GLTextureBufferRange,
                                          texturePacked, internalformat, bufferPacked, offset,
                                          size)));
@@ -6119,7 +6312,8 @@ void GL_APIENTRY GL_TextureParameterIiv(GLuint texture, GLenum pname, const GLin
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLTextureParameterIiv) &&
               ValidateTextureParameterIiv(context, angle::EntryPoint::GLTextureParameterIiv,
                                           texturePacked, pname, params)));
@@ -6149,7 +6343,8 @@ void GL_APIENTRY GL_TextureParameterIuiv(GLuint texture, GLenum pname, const GLu
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLTextureParameterIuiv) &&
               ValidateTextureParameterIuiv(context, angle::EntryPoint::GLTextureParameterIuiv,
                                            texturePacked, pname, params)));
@@ -6178,7 +6373,9 @@ void GL_APIENTRY GL_TextureParameterf(GLuint texture, GLenum pname, GLfloat para
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTextureParameterf) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTextureParameterf) &&
               ValidateTextureParameterf(context, angle::EntryPoint::GLTextureParameterf,
                                         texturePacked, pname, param)));
         if (isCallValid)
@@ -6207,7 +6404,9 @@ void GL_APIENTRY GL_TextureParameterfv(GLuint texture, GLenum pname, const GLflo
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTextureParameterfv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTextureParameterfv) &&
               ValidateTextureParameterfv(context, angle::EntryPoint::GLTextureParameterfv,
                                          texturePacked, pname, param)));
         if (isCallValid)
@@ -6235,7 +6434,9 @@ void GL_APIENTRY GL_TextureParameteri(GLuint texture, GLenum pname, GLint param)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTextureParameteri) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTextureParameteri) &&
               ValidateTextureParameteri(context, angle::EntryPoint::GLTextureParameteri,
                                         texturePacked, pname, param)));
         if (isCallValid)
@@ -6264,7 +6465,9 @@ void GL_APIENTRY GL_TextureParameteriv(GLuint texture, GLenum pname, const GLint
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTextureParameteriv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTextureParameteriv) &&
               ValidateTextureParameteriv(context, angle::EntryPoint::GLTextureParameteriv,
                                          texturePacked, pname, param)));
         if (isCallValid)
@@ -6296,7 +6499,9 @@ void GL_APIENTRY GL_TextureStorage1D(GLuint texture,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTextureStorage1D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTextureStorage1D) &&
               ValidateTextureStorage1D(context, angle::EntryPoint::GLTextureStorage1D,
                                        texturePacked, levels, internalformat, width)));
         if (isCallValid)
@@ -6331,7 +6536,9 @@ void GL_APIENTRY GL_TextureStorage2D(GLuint texture,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTextureStorage2D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTextureStorage2D) &&
               ValidateTextureStorage2D(context, angle::EntryPoint::GLTextureStorage2D,
                                        texturePacked, levels, internalformat, width, height)));
         if (isCallValid)
@@ -6369,7 +6576,8 @@ void GL_APIENTRY GL_TextureStorage2DMultisample(GLuint texture,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLTextureStorage2DMultisample) &&
               ValidateTextureStorage2DMultisample(
                   context, angle::EntryPoint::GLTextureStorage2DMultisample, texturePacked, samples,
@@ -6409,7 +6617,9 @@ void GL_APIENTRY GL_TextureStorage3D(GLuint texture,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTextureStorage3D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTextureStorage3D) &&
               ValidateTextureStorage3D(context, angle::EntryPoint::GLTextureStorage3D,
                                        texturePacked, levels, internalformat, width, height,
                                        depth)));
@@ -6449,7 +6659,8 @@ void GL_APIENTRY GL_TextureStorage3DMultisample(GLuint texture,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLTextureStorage3DMultisample) &&
               ValidateTextureStorage3DMultisample(
                   context, angle::EntryPoint::GLTextureStorage3DMultisample, texturePacked, samples,
@@ -6491,7 +6702,9 @@ void GL_APIENTRY GL_TextureSubImage1D(GLuint texture,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTextureSubImage1D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTextureSubImage1D) &&
               ValidateTextureSubImage1D(context, angle::EntryPoint::GLTextureSubImage1D,
                                         texturePacked, level, xoffset, width, format, type,
                                         pixels)));
@@ -6533,7 +6746,9 @@ void GL_APIENTRY GL_TextureSubImage2D(GLuint texture,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTextureSubImage2D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTextureSubImage2D) &&
               ValidateTextureSubImage2D(context, angle::EntryPoint::GLTextureSubImage2D,
                                         texturePacked, level, xoffset, yoffset, width, height,
                                         format, type, pixels)));
@@ -6578,7 +6793,9 @@ void GL_APIENTRY GL_TextureSubImage3D(GLuint texture,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTextureSubImage3D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTextureSubImage3D) &&
               ValidateTextureSubImage3D(context, angle::EntryPoint::GLTextureSubImage3D,
                                         texturePacked, level, xoffset, yoffset, zoffset, width,
                                         height, depth, format, type, pixels)));
@@ -6607,12 +6824,14 @@ void GL_APIENTRY GL_TransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint
     {
         BufferID bufferPacked = PackParam<BufferID>(buffer);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLTransformFeedbackBufferBase) &&
-                             ValidateTransformFeedbackBufferBase(
-                                 context, angle::EntryPoint::GLTransformFeedbackBufferBase, xfb,
-                                 index, bufferPacked)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTransformFeedbackBufferBase) &&
+              ValidateTransformFeedbackBufferBase(context,
+                                                  angle::EntryPoint::GLTransformFeedbackBufferBase,
+                                                  xfb, index, bufferPacked)));
         if (isCallValid)
         {
             context->transformFeedbackBufferBase(xfb, index, bufferPacked);
@@ -6643,12 +6862,14 @@ void GL_APIENTRY GL_TransformFeedbackBufferRange(GLuint xfb,
     {
         BufferID bufferPacked = PackParam<BufferID>(buffer);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLTransformFeedbackBufferRange) &&
-                             ValidateTransformFeedbackBufferRange(
-                                 context, angle::EntryPoint::GLTransformFeedbackBufferRange, xfb,
-                                 index, bufferPacked, offset, size)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLTransformFeedbackBufferRange) &&
+              ValidateTransformFeedbackBufferRange(
+                  context, angle::EntryPoint::GLTransformFeedbackBufferRange, xfb, index,
+                  bufferPacked, offset, size)));
         if (isCallValid)
         {
             context->transformFeedbackBufferRange(xfb, index, bufferPacked, offset, size);
@@ -6675,7 +6896,9 @@ GLboolean GL_APIENTRY GL_UnmapNamedBuffer(GLuint buffer)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLUnmapNamedBuffer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLUnmapNamedBuffer) &&
               ValidateUnmapNamedBuffer(context, angle::EntryPoint::GLUnmapNamedBuffer,
                                        bufferPacked)));
         if (isCallValid)
@@ -6708,12 +6931,14 @@ void GL_APIENTRY GL_VertexArrayAttribBinding(GLuint vaobj, GLuint attribindex, G
     {
         VertexArrayID vaobjPacked = PackParam<VertexArrayID>(vaobj);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLVertexArrayAttribBinding) &&
-                             ValidateVertexArrayAttribBinding(
-                                 context, angle::EntryPoint::GLVertexArrayAttribBinding,
-                                 vaobjPacked, attribindex, bindingindex)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertexArrayAttribBinding) &&
+              ValidateVertexArrayAttribBinding(context,
+                                               angle::EntryPoint::GLVertexArrayAttribBinding,
+                                               vaobjPacked, attribindex, bindingindex)));
         if (isCallValid)
         {
             context->vertexArrayAttribBinding(vaobjPacked, attribindex, bindingindex);
@@ -6746,12 +6971,14 @@ void GL_APIENTRY GL_VertexArrayAttribFormat(GLuint vaobj,
     {
         VertexArrayID vaobjPacked = PackParam<VertexArrayID>(vaobj);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLVertexArrayAttribFormat) &&
-                             ValidateVertexArrayAttribFormat(
-                                 context, angle::EntryPoint::GLVertexArrayAttribFormat, vaobjPacked,
-                                 attribindex, size, type, normalized, relativeoffset)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertexArrayAttribFormat) &&
+              ValidateVertexArrayAttribFormat(context, angle::EntryPoint::GLVertexArrayAttribFormat,
+                                              vaobjPacked, attribindex, size, type, normalized,
+                                              relativeoffset)));
         if (isCallValid)
         {
             context->vertexArrayAttribFormat(vaobjPacked, attribindex, size, type, normalized,
@@ -6783,12 +7010,14 @@ void GL_APIENTRY GL_VertexArrayAttribIFormat(GLuint vaobj,
     {
         VertexArrayID vaobjPacked = PackParam<VertexArrayID>(vaobj);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLVertexArrayAttribIFormat) &&
-                             ValidateVertexArrayAttribIFormat(
-                                 context, angle::EntryPoint::GLVertexArrayAttribIFormat,
-                                 vaobjPacked, attribindex, size, type, relativeoffset)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertexArrayAttribIFormat) &&
+              ValidateVertexArrayAttribIFormat(
+                  context, angle::EntryPoint::GLVertexArrayAttribIFormat, vaobjPacked, attribindex,
+                  size, type, relativeoffset)));
         if (isCallValid)
         {
             context->vertexArrayAttribIFormat(vaobjPacked, attribindex, size, type, relativeoffset);
@@ -6819,12 +7048,14 @@ void GL_APIENTRY GL_VertexArrayAttribLFormat(GLuint vaobj,
     {
         VertexArrayID vaobjPacked = PackParam<VertexArrayID>(vaobj);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLVertexArrayAttribLFormat) &&
-                             ValidateVertexArrayAttribLFormat(
-                                 context, angle::EntryPoint::GLVertexArrayAttribLFormat,
-                                 vaobjPacked, attribindex, size, type, relativeoffset)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertexArrayAttribLFormat) &&
+              ValidateVertexArrayAttribLFormat(
+                  context, angle::EntryPoint::GLVertexArrayAttribLFormat, vaobjPacked, attribindex,
+                  size, type, relativeoffset)));
         if (isCallValid)
         {
             context->vertexArrayAttribLFormat(vaobjPacked, attribindex, size, type, relativeoffset);
@@ -6850,12 +7081,14 @@ void GL_APIENTRY GL_VertexArrayBindingDivisor(GLuint vaobj, GLuint bindingindex,
     {
         VertexArrayID vaobjPacked = PackParam<VertexArrayID>(vaobj);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLVertexArrayBindingDivisor) &&
-                             ValidateVertexArrayBindingDivisor(
-                                 context, angle::EntryPoint::GLVertexArrayBindingDivisor,
-                                 vaobjPacked, bindingindex, divisor)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertexArrayBindingDivisor) &&
+              ValidateVertexArrayBindingDivisor(context,
+                                                angle::EntryPoint::GLVertexArrayBindingDivisor,
+                                                vaobjPacked, bindingindex, divisor)));
         if (isCallValid)
         {
             context->vertexArrayBindingDivisor(vaobjPacked, bindingindex, divisor);
@@ -6881,12 +7114,14 @@ void GL_APIENTRY GL_VertexArrayElementBuffer(GLuint vaobj, GLuint buffer)
         VertexArrayID vaobjPacked = PackParam<VertexArrayID>(vaobj);
         BufferID bufferPacked     = PackParam<BufferID>(buffer);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLVertexArrayElementBuffer) &&
-                             ValidateVertexArrayElementBuffer(
-                                 context, angle::EntryPoint::GLVertexArrayElementBuffer,
-                                 vaobjPacked, bufferPacked)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertexArrayElementBuffer) &&
+              ValidateVertexArrayElementBuffer(context,
+                                               angle::EntryPoint::GLVertexArrayElementBuffer,
+                                               vaobjPacked, bufferPacked)));
         if (isCallValid)
         {
             context->vertexArrayElementBuffer(vaobjPacked, bufferPacked);
@@ -6917,12 +7152,14 @@ void GL_APIENTRY GL_VertexArrayVertexBuffer(GLuint vaobj,
         VertexArrayID vaobjPacked = PackParam<VertexArrayID>(vaobj);
         BufferID bufferPacked     = PackParam<BufferID>(buffer);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLVertexArrayVertexBuffer) &&
-                             ValidateVertexArrayVertexBuffer(
-                                 context, angle::EntryPoint::GLVertexArrayVertexBuffer, vaobjPacked,
-                                 bindingindex, bufferPacked, offset, stride)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertexArrayVertexBuffer) &&
+              ValidateVertexArrayVertexBuffer(context, angle::EntryPoint::GLVertexArrayVertexBuffer,
+                                              vaobjPacked, bindingindex, bufferPacked, offset,
+                                              stride)));
         if (isCallValid)
         {
             context->vertexArrayVertexBuffer(vaobjPacked, bindingindex, bufferPacked, offset,
@@ -6957,12 +7194,14 @@ void GL_APIENTRY GL_VertexArrayVertexBuffers(GLuint vaobj,
         VertexArrayID vaobjPacked     = PackParam<VertexArrayID>(vaobj);
         const BufferID *buffersPacked = PackParam<const BufferID *>(buffers);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLVertexArrayVertexBuffers) &&
-                             ValidateVertexArrayVertexBuffers(
-                                 context, angle::EntryPoint::GLVertexArrayVertexBuffers,
-                                 vaobjPacked, first, count, buffersPacked, offsets, strides)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertexArrayVertexBuffers) &&
+              ValidateVertexArrayVertexBuffers(
+                  context, angle::EntryPoint::GLVertexArrayVertexBuffers, vaobjPacked, first, count,
+                  buffersPacked, offsets, strides)));
         if (isCallValid)
         {
             context->vertexArrayVertexBuffers(vaobjPacked, first, count, buffersPacked, offsets,
@@ -6995,12 +7234,14 @@ void GL_APIENTRY GL_MultiDrawArraysIndirectCount(GLenum mode,
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLMultiDrawArraysIndirectCount) &&
-                             ValidateMultiDrawArraysIndirectCount(
-                                 context, angle::EntryPoint::GLMultiDrawArraysIndirectCount, mode,
-                                 indirect, drawcount, maxdrawcount, stride)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLMultiDrawArraysIndirectCount) &&
+              ValidateMultiDrawArraysIndirectCount(
+                  context, angle::EntryPoint::GLMultiDrawArraysIndirectCount, mode, indirect,
+                  drawcount, maxdrawcount, stride)));
         if (isCallValid)
         {
             context->multiDrawArraysIndirectCount(mode, indirect, drawcount, maxdrawcount, stride);
@@ -7033,12 +7274,14 @@ void GL_APIENTRY GL_MultiDrawElementsIndirectCount(GLenum mode,
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLMultiDrawElementsIndirectCount) &&
-                             ValidateMultiDrawElementsIndirectCount(
-                                 context, angle::EntryPoint::GLMultiDrawElementsIndirectCount, mode,
-                                 type, indirect, drawcount, maxdrawcount, stride)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLMultiDrawElementsIndirectCount) &&
+              ValidateMultiDrawElementsIndirectCount(
+                  context, angle::EntryPoint::GLMultiDrawElementsIndirectCount, mode, type,
+                  indirect, drawcount, maxdrawcount, stride)));
         if (isCallValid)
         {
             context->multiDrawElementsIndirectCount(mode, type, indirect, drawcount, maxdrawcount,
@@ -7064,8 +7307,9 @@ void GL_APIENTRY GL_PolygonOffsetClamp(GLfloat factor, GLfloat units, GLfloat cl
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidatePolygonOffsetClamp(context, angle::EntryPoint::GLPolygonOffsetClamp, factor,
-                                        units, clamp));
+             ValidatePolygonOffsetClamp(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLPolygonOffsetClamp, factor, units, clamp));
         if (isCallValid)
         {
             ContextPrivatePolygonOffsetClamp(context->getMutablePrivateState(),
@@ -7100,7 +7344,9 @@ void GL_APIENTRY GL_SpecializeShader(GLuint shader,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSpecializeShader) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSpecializeShader) &&
               ValidateSpecializeShader(context, angle::EntryPoint::GLSpecializeShader, shader,
                                        pEntryPoint, numSpecializationConstants, pConstantIndex,
                                        pConstantValue)));
diff --git a/src/libGLESv2/entry_points_gles_1_0_autogen.cpp b/src/libGLESv2/entry_points_gles_1_0_autogen.cpp
index d7c1166ca..be4b1c8cd 100644
--- a/src/libGLESv2/entry_points_gles_1_0_autogen.cpp
+++ b/src/libGLESv2/entry_points_gles_1_0_autogen.cpp
@@ -34,8 +34,12 @@ void GL_APIENTRY GL_AlphaFunc(GLenum func, GLfloat ref)
         AlphaTestFunc funcPacked = PackParam<AlphaTestFunc>(func);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLAlphaFunc) &&
-              ValidateAlphaFunc(context, angle::EntryPoint::GLAlphaFunc, funcPacked, ref)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLAlphaFunc) &&
+              ValidateAlphaFunc(context->getPrivateState(),
+                                context->getMutableErrorSetForValidation(),
+                                angle::EntryPoint::GLAlphaFunc, funcPacked, ref)));
         if (isCallValid)
         {
             ContextPrivateAlphaFunc(context->getMutablePrivateState(),
@@ -61,8 +65,12 @@ void GL_APIENTRY GL_AlphaFuncx(GLenum func, GLfixed ref)
         AlphaTestFunc funcPacked = PackParam<AlphaTestFunc>(func);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLAlphaFuncx) &&
-              ValidateAlphaFuncx(context, angle::EntryPoint::GLAlphaFuncx, funcPacked, ref)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLAlphaFuncx) &&
+              ValidateAlphaFuncx(context->getPrivateState(),
+                                 context->getMutableErrorSetForValidation(),
+                                 angle::EntryPoint::GLAlphaFuncx, funcPacked, ref)));
         if (isCallValid)
         {
             ContextPrivateAlphaFuncx(context->getMutablePrivateState(),
@@ -88,9 +96,12 @@ void GL_APIENTRY GL_ClearColorx(GLfixed red, GLfixed green, GLfixed blue, GLfixe
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLClearColorx) &&
-              ValidateClearColorx(context, angle::EntryPoint::GLClearColorx, red, green, blue,
-                                  alpha)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClearColorx) &&
+              ValidateClearColorx(context->getPrivateState(),
+                                  context->getMutableErrorSetForValidation(),
+                                  angle::EntryPoint::GLClearColorx, red, green, blue, alpha)));
         if (isCallValid)
         {
             ContextPrivateClearColorx(context->getMutablePrivateState(),
@@ -115,8 +126,12 @@ void GL_APIENTRY GL_ClearDepthx(GLfixed depth)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLClearDepthx) &&
-              ValidateClearDepthx(context, angle::EntryPoint::GLClearDepthx, depth)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClearDepthx) &&
+              ValidateClearDepthx(context->getPrivateState(),
+                                  context->getMutableErrorSetForValidation(),
+                                  angle::EntryPoint::GLClearDepthx, depth)));
         if (isCallValid)
         {
             ContextPrivateClearDepthx(context->getMutablePrivateState(),
@@ -140,11 +155,13 @@ void GL_APIENTRY GL_ClientActiveTexture(GLenum texture)
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLClientActiveTexture) &&
-                             ValidateClientActiveTexture(
-                                 context, angle::EntryPoint::GLClientActiveTexture, texture)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClientActiveTexture) &&
+              ValidateClientActiveTexture(context, angle::EntryPoint::GLClientActiveTexture,
+                                          texture)));
         if (isCallValid)
         {
             context->clientActiveTexture(texture);
@@ -168,8 +185,12 @@ void GL_APIENTRY GL_ClipPlanef(GLenum p, const GLfloat *eqn)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLClipPlanef) &&
-              ValidateClipPlanef(context, angle::EntryPoint::GLClipPlanef, p, eqn)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClipPlanef) &&
+              ValidateClipPlanef(context->getPrivateState(),
+                                 context->getMutableErrorSetForValidation(),
+                                 angle::EntryPoint::GLClipPlanef, p, eqn)));
         if (isCallValid)
         {
             ContextPrivateClipPlanef(context->getMutablePrivateState(),
@@ -194,8 +215,12 @@ void GL_APIENTRY GL_ClipPlanex(GLenum plane, const GLfixed *equation)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLClipPlanex) &&
-              ValidateClipPlanex(context, angle::EntryPoint::GLClipPlanex, plane, equation)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClipPlanex) &&
+              ValidateClipPlanex(context->getPrivateState(),
+                                 context->getMutableErrorSetForValidation(),
+                                 angle::EntryPoint::GLClipPlanex, plane, equation)));
         if (isCallValid)
         {
             ContextPrivateClipPlanex(context->getMutablePrivateState(),
@@ -220,8 +245,12 @@ void GL_APIENTRY GL_Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat al
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor4f) &&
-              ValidateColor4f(context, angle::EntryPoint::GLColor4f, red, green, blue, alpha)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor4f) &&
+              ValidateColor4f(context->getPrivateState(),
+                              context->getMutableErrorSetForValidation(),
+                              angle::EntryPoint::GLColor4f, red, green, blue, alpha)));
         if (isCallValid)
         {
             ContextPrivateColor4f(context->getMutablePrivateState(),
@@ -246,8 +275,12 @@ void GL_APIENTRY GL_Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte a
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor4ub) &&
-              ValidateColor4ub(context, angle::EntryPoint::GLColor4ub, red, green, blue, alpha)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor4ub) &&
+              ValidateColor4ub(context->getPrivateState(),
+                               context->getMutableErrorSetForValidation(),
+                               angle::EntryPoint::GLColor4ub, red, green, blue, alpha)));
         if (isCallValid)
         {
             ContextPrivateColor4ub(context->getMutablePrivateState(),
@@ -272,8 +305,12 @@ void GL_APIENTRY GL_Color4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed al
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColor4x) &&
-              ValidateColor4x(context, angle::EntryPoint::GLColor4x, red, green, blue, alpha)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColor4x) &&
+              ValidateColor4x(context->getPrivateState(),
+                              context->getMutableErrorSetForValidation(),
+                              angle::EntryPoint::GLColor4x, red, green, blue, alpha)));
         if (isCallValid)
         {
             ContextPrivateColor4x(context->getMutablePrivateState(),
@@ -302,7 +339,9 @@ void GL_APIENTRY GL_ColorPointer(GLint size, GLenum type, GLsizei stride, const
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColorPointer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColorPointer) &&
               ValidateColorPointer(context, angle::EntryPoint::GLColorPointer, size, typePacked,
                                    stride, pointer)));
         if (isCallValid)
@@ -327,8 +366,12 @@ void GL_APIENTRY GL_DepthRangex(GLfixed n, GLfixed f)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDepthRangex) &&
-              ValidateDepthRangex(context, angle::EntryPoint::GLDepthRangex, n, f)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDepthRangex) &&
+              ValidateDepthRangex(context->getPrivateState(),
+                                  context->getMutableErrorSetForValidation(),
+                                  angle::EntryPoint::GLDepthRangex, n, f)));
         if (isCallValid)
         {
             ContextPrivateDepthRangex(context->getMutablePrivateState(),
@@ -355,7 +398,9 @@ void GL_APIENTRY GL_DisableClientState(GLenum array)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDisableClientState) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDisableClientState) &&
               ValidateDisableClientState(context, angle::EntryPoint::GLDisableClientState,
                                          arrayPacked)));
         if (isCallValid)
@@ -407,8 +452,11 @@ void GL_APIENTRY GL_Fogf(GLenum pname, GLfloat param)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFogf) &&
-              ValidateFogf(context, angle::EntryPoint::GLFogf, pname, param)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFogf) &&
+              ValidateFogf(context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                           angle::EntryPoint::GLFogf, pname, param)));
         if (isCallValid)
         {
             ContextPrivateFogf(context->getMutablePrivateState(),
@@ -433,8 +481,11 @@ void GL_APIENTRY GL_Fogfv(GLenum pname, const GLfloat *params)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFogfv) &&
-              ValidateFogfv(context, angle::EntryPoint::GLFogfv, pname, params)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFogfv) &&
+              ValidateFogfv(context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                            angle::EntryPoint::GLFogfv, pname, params)));
         if (isCallValid)
         {
             ContextPrivateFogfv(context->getMutablePrivateState(),
@@ -459,8 +510,11 @@ void GL_APIENTRY GL_Fogx(GLenum pname, GLfixed param)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFogx) &&
-              ValidateFogx(context, angle::EntryPoint::GLFogx, pname, param)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFogx) &&
+              ValidateFogx(context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                           angle::EntryPoint::GLFogx, pname, param)));
         if (isCallValid)
         {
             ContextPrivateFogx(context->getMutablePrivateState(),
@@ -485,8 +539,11 @@ void GL_APIENTRY GL_Fogxv(GLenum pname, const GLfixed *param)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFogxv) &&
-              ValidateFogxv(context, angle::EntryPoint::GLFogxv, pname, param)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFogxv) &&
+              ValidateFogxv(context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                            angle::EntryPoint::GLFogxv, pname, param)));
         if (isCallValid)
         {
             ContextPrivateFogxv(context->getMutablePrivateState(),
@@ -511,8 +568,12 @@ void GL_APIENTRY GL_Frustumf(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFrustumf) &&
-              ValidateFrustumf(context, angle::EntryPoint::GLFrustumf, l, r, b, t, n, f)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFrustumf) &&
+              ValidateFrustumf(context->getPrivateState(),
+                               context->getMutableErrorSetForValidation(),
+                               angle::EntryPoint::GLFrustumf, l, r, b, t, n, f)));
         if (isCallValid)
         {
             ContextPrivateFrustumf(context->getMutablePrivateState(),
@@ -538,8 +599,12 @@ void GL_APIENTRY GL_Frustumx(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFrustumx) &&
-              ValidateFrustumx(context, angle::EntryPoint::GLFrustumx, l, r, b, t, n, f)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFrustumx) &&
+              ValidateFrustumx(context->getPrivateState(),
+                               context->getMutableErrorSetForValidation(),
+                               angle::EntryPoint::GLFrustumx, l, r, b, t, n, f)));
         if (isCallValid)
         {
             ContextPrivateFrustumx(context->getMutablePrivateState(),
@@ -564,7 +629,9 @@ void GL_APIENTRY GL_GetClipPlanef(GLenum plane, GLfloat *equation)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateGetClipPlanef(context, angle::EntryPoint::GLGetClipPlanef, plane, equation));
+             ValidateGetClipPlanef(context->getPrivateState(),
+                                   context->getMutableErrorSetForValidation(),
+                                   angle::EntryPoint::GLGetClipPlanef, plane, equation));
         if (isCallValid)
         {
             ContextPrivateGetClipPlanef(context->getMutablePrivateState(),
@@ -589,7 +656,9 @@ void GL_APIENTRY GL_GetClipPlanex(GLenum plane, GLfixed *equation)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateGetClipPlanex(context, angle::EntryPoint::GLGetClipPlanex, plane, equation));
+             ValidateGetClipPlanex(context->getPrivateState(),
+                                   context->getMutableErrorSetForValidation(),
+                                   angle::EntryPoint::GLGetClipPlanex, plane, equation));
         if (isCallValid)
         {
             ContextPrivateGetClipPlanex(context->getMutablePrivateState(),
@@ -639,9 +708,11 @@ void GL_APIENTRY GL_GetLightfv(GLenum light, GLenum pname, GLfloat *params)
     if (context)
     {
         LightParameter pnamePacked = PackParam<LightParameter>(pname);
-        bool isCallValid           = (context->skipValidation() ||
-                            ValidateGetLightfv(context, angle::EntryPoint::GLGetLightfv, light,
-                                                         pnamePacked, params));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateGetLightfv(context->getPrivateState(),
+                                context->getMutableErrorSetForValidation(),
+                                angle::EntryPoint::GLGetLightfv, light, pnamePacked, params));
         if (isCallValid)
         {
             ContextPrivateGetLightfv(context->getMutablePrivateState(),
@@ -667,9 +738,11 @@ void GL_APIENTRY GL_GetLightxv(GLenum light, GLenum pname, GLfixed *params)
     if (context)
     {
         LightParameter pnamePacked = PackParam<LightParameter>(pname);
-        bool isCallValid           = (context->skipValidation() ||
-                            ValidateGetLightxv(context, angle::EntryPoint::GLGetLightxv, light,
-                                                         pnamePacked, params));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateGetLightxv(context->getPrivateState(),
+                                context->getMutableErrorSetForValidation(),
+                                angle::EntryPoint::GLGetLightxv, light, pnamePacked, params));
         if (isCallValid)
         {
             ContextPrivateGetLightxv(context->getMutablePrivateState(),
@@ -696,9 +769,11 @@ void GL_APIENTRY GL_GetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
     if (context)
     {
         MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname);
-        bool isCallValid              = (context->skipValidation() ||
-                            ValidateGetMaterialfv(context, angle::EntryPoint::GLGetMaterialfv, face,
-                                                               pnamePacked, params));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateGetMaterialfv(context->getPrivateState(),
+                                   context->getMutableErrorSetForValidation(),
+                                   angle::EntryPoint::GLGetMaterialfv, face, pnamePacked, params));
         if (isCallValid)
         {
             ContextPrivateGetMaterialfv(context->getMutablePrivateState(),
@@ -725,9 +800,11 @@ void GL_APIENTRY GL_GetMaterialxv(GLenum face, GLenum pname, GLfixed *params)
     if (context)
     {
         MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname);
-        bool isCallValid              = (context->skipValidation() ||
-                            ValidateGetMaterialxv(context, angle::EntryPoint::GLGetMaterialxv, face,
-                                                               pnamePacked, params));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateGetMaterialxv(context->getPrivateState(),
+                                   context->getMutableErrorSetForValidation(),
+                                   angle::EntryPoint::GLGetMaterialxv, face, pnamePacked, params));
         if (isCallValid)
         {
             ContextPrivateGetMaterialxv(context->getMutablePrivateState(),
@@ -755,9 +832,11 @@ void GL_APIENTRY GL_GetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
     {
         TextureEnvTarget targetPacked   = PackParam<TextureEnvTarget>(target);
         TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
-        bool isCallValid                = (context->skipValidation() ||
-                            ValidateGetTexEnvfv(context, angle::EntryPoint::GLGetTexEnvfv,
-                                                               targetPacked, pnamePacked, params));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateGetTexEnvfv(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLGetTexEnvfv, targetPacked, pnamePacked, params));
         if (isCallValid)
         {
             ContextPrivateGetTexEnvfv(context->getMutablePrivateState(),
@@ -785,9 +864,11 @@ void GL_APIENTRY GL_GetTexEnviv(GLenum target, GLenum pname, GLint *params)
     {
         TextureEnvTarget targetPacked   = PackParam<TextureEnvTarget>(target);
         TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
-        bool isCallValid                = (context->skipValidation() ||
-                            ValidateGetTexEnviv(context, angle::EntryPoint::GLGetTexEnviv,
-                                                               targetPacked, pnamePacked, params));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateGetTexEnviv(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLGetTexEnviv, targetPacked, pnamePacked, params));
         if (isCallValid)
         {
             ContextPrivateGetTexEnviv(context->getMutablePrivateState(),
@@ -815,9 +896,11 @@ void GL_APIENTRY GL_GetTexEnvxv(GLenum target, GLenum pname, GLfixed *params)
     {
         TextureEnvTarget targetPacked   = PackParam<TextureEnvTarget>(target);
         TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
-        bool isCallValid                = (context->skipValidation() ||
-                            ValidateGetTexEnvxv(context, angle::EntryPoint::GLGetTexEnvxv,
-                                                               targetPacked, pnamePacked, params));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateGetTexEnvxv(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLGetTexEnvxv, targetPacked, pnamePacked, params));
         if (isCallValid)
         {
             ContextPrivateGetTexEnvxv(context->getMutablePrivateState(),
@@ -872,8 +955,12 @@ void GL_APIENTRY GL_LightModelf(GLenum pname, GLfloat param)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLightModelf) &&
-              ValidateLightModelf(context, angle::EntryPoint::GLLightModelf, pname, param)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLightModelf) &&
+              ValidateLightModelf(context->getPrivateState(),
+                                  context->getMutableErrorSetForValidation(),
+                                  angle::EntryPoint::GLLightModelf, pname, param)));
         if (isCallValid)
         {
             ContextPrivateLightModelf(context->getMutablePrivateState(),
@@ -898,8 +985,12 @@ void GL_APIENTRY GL_LightModelfv(GLenum pname, const GLfloat *params)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLightModelfv) &&
-              ValidateLightModelfv(context, angle::EntryPoint::GLLightModelfv, pname, params)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLightModelfv) &&
+              ValidateLightModelfv(context->getPrivateState(),
+                                   context->getMutableErrorSetForValidation(),
+                                   angle::EntryPoint::GLLightModelfv, pname, params)));
         if (isCallValid)
         {
             ContextPrivateLightModelfv(context->getMutablePrivateState(),
@@ -924,8 +1015,12 @@ void GL_APIENTRY GL_LightModelx(GLenum pname, GLfixed param)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLightModelx) &&
-              ValidateLightModelx(context, angle::EntryPoint::GLLightModelx, pname, param)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLightModelx) &&
+              ValidateLightModelx(context->getPrivateState(),
+                                  context->getMutableErrorSetForValidation(),
+                                  angle::EntryPoint::GLLightModelx, pname, param)));
         if (isCallValid)
         {
             ContextPrivateLightModelx(context->getMutablePrivateState(),
@@ -950,8 +1045,12 @@ void GL_APIENTRY GL_LightModelxv(GLenum pname, const GLfixed *param)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLightModelxv) &&
-              ValidateLightModelxv(context, angle::EntryPoint::GLLightModelxv, pname, param)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLightModelxv) &&
+              ValidateLightModelxv(context->getPrivateState(),
+                                   context->getMutableErrorSetForValidation(),
+                                   angle::EntryPoint::GLLightModelxv, pname, param)));
         if (isCallValid)
         {
             ContextPrivateLightModelxv(context->getMutablePrivateState(),
@@ -978,8 +1077,11 @@ void GL_APIENTRY GL_Lightf(GLenum light, GLenum pname, GLfloat param)
         LightParameter pnamePacked = PackParam<LightParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLightf) &&
-              ValidateLightf(context, angle::EntryPoint::GLLightf, light, pnamePacked, param)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLightf) &&
+              ValidateLightf(context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                             angle::EntryPoint::GLLightf, light, pnamePacked, param)));
         if (isCallValid)
         {
             ContextPrivateLightf(context->getMutablePrivateState(),
@@ -1006,8 +1108,12 @@ void GL_APIENTRY GL_Lightfv(GLenum light, GLenum pname, const GLfloat *params)
         LightParameter pnamePacked = PackParam<LightParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLightfv) &&
-              ValidateLightfv(context, angle::EntryPoint::GLLightfv, light, pnamePacked, params)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLightfv) &&
+              ValidateLightfv(context->getPrivateState(),
+                              context->getMutableErrorSetForValidation(),
+                              angle::EntryPoint::GLLightfv, light, pnamePacked, params)));
         if (isCallValid)
         {
             ContextPrivateLightfv(context->getMutablePrivateState(),
@@ -1035,8 +1141,11 @@ void GL_APIENTRY GL_Lightx(GLenum light, GLenum pname, GLfixed param)
         LightParameter pnamePacked = PackParam<LightParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLightx) &&
-              ValidateLightx(context, angle::EntryPoint::GLLightx, light, pnamePacked, param)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLightx) &&
+              ValidateLightx(context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                             angle::EntryPoint::GLLightx, light, pnamePacked, param)));
         if (isCallValid)
         {
             ContextPrivateLightx(context->getMutablePrivateState(),
@@ -1063,8 +1172,12 @@ void GL_APIENTRY GL_Lightxv(GLenum light, GLenum pname, const GLfixed *params)
         LightParameter pnamePacked = PackParam<LightParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLightxv) &&
-              ValidateLightxv(context, angle::EntryPoint::GLLightxv, light, pnamePacked, params)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLightxv) &&
+              ValidateLightxv(context->getPrivateState(),
+                              context->getMutableErrorSetForValidation(),
+                              angle::EntryPoint::GLLightxv, light, pnamePacked, params)));
         if (isCallValid)
         {
             ContextPrivateLightxv(context->getMutablePrivateState(),
@@ -1089,8 +1202,12 @@ void GL_APIENTRY GL_LineWidthx(GLfixed width)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLineWidthx) &&
-              ValidateLineWidthx(context, angle::EntryPoint::GLLineWidthx, width)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLineWidthx) &&
+              ValidateLineWidthx(context->getPrivateState(),
+                                 context->getMutableErrorSetForValidation(),
+                                 angle::EntryPoint::GLLineWidthx, width)));
         if (isCallValid)
         {
             ContextPrivateLineWidthx(context->getMutablePrivateState(),
@@ -1114,8 +1231,12 @@ void GL_APIENTRY GL_LoadIdentity()
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLoadIdentity) &&
-              ValidateLoadIdentity(context, angle::EntryPoint::GLLoadIdentity)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLoadIdentity) &&
+              ValidateLoadIdentity(context->getPrivateState(),
+                                   context->getMutableErrorSetForValidation(),
+                                   angle::EntryPoint::GLLoadIdentity)));
         if (isCallValid)
         {
             ContextPrivateLoadIdentity(context->getMutablePrivateState(),
@@ -1140,8 +1261,12 @@ void GL_APIENTRY GL_LoadMatrixf(const GLfloat *m)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLoadMatrixf) &&
-              ValidateLoadMatrixf(context, angle::EntryPoint::GLLoadMatrixf, m)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLoadMatrixf) &&
+              ValidateLoadMatrixf(context->getPrivateState(),
+                                  context->getMutableErrorSetForValidation(),
+                                  angle::EntryPoint::GLLoadMatrixf, m)));
         if (isCallValid)
         {
             ContextPrivateLoadMatrixf(context->getMutablePrivateState(),
@@ -1166,8 +1291,12 @@ void GL_APIENTRY GL_LoadMatrixx(const GLfixed *m)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLoadMatrixx) &&
-              ValidateLoadMatrixx(context, angle::EntryPoint::GLLoadMatrixx, m)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLoadMatrixx) &&
+              ValidateLoadMatrixx(context->getPrivateState(),
+                                  context->getMutableErrorSetForValidation(),
+                                  angle::EntryPoint::GLLoadMatrixx, m)));
         if (isCallValid)
         {
             ContextPrivateLoadMatrixx(context->getMutablePrivateState(),
@@ -1193,8 +1322,12 @@ void GL_APIENTRY GL_LogicOp(GLenum opcode)
         LogicalOperation opcodePacked = PackParam<LogicalOperation>(opcode);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLogicOp) &&
-              ValidateLogicOp(context, angle::EntryPoint::GLLogicOp, opcodePacked)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLogicOp) &&
+              ValidateLogicOp(context->getPrivateState(),
+                              context->getMutableErrorSetForValidation(),
+                              angle::EntryPoint::GLLogicOp, opcodePacked)));
         if (isCallValid)
         {
             ContextPrivateLogicOp(context->getMutablePrivateState(),
@@ -1221,9 +1354,12 @@ void GL_APIENTRY GL_Materialf(GLenum face, GLenum pname, GLfloat param)
         MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMaterialf) &&
-              ValidateMaterialf(context, angle::EntryPoint::GLMaterialf, face, pnamePacked,
-                                param)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMaterialf) &&
+              ValidateMaterialf(context->getPrivateState(),
+                                context->getMutableErrorSetForValidation(),
+                                angle::EntryPoint::GLMaterialf, face, pnamePacked, param)));
         if (isCallValid)
         {
             ContextPrivateMaterialf(context->getMutablePrivateState(),
@@ -1251,9 +1387,12 @@ void GL_APIENTRY GL_Materialfv(GLenum face, GLenum pname, const GLfloat *params)
         MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMaterialfv) &&
-              ValidateMaterialfv(context, angle::EntryPoint::GLMaterialfv, face, pnamePacked,
-                                 params)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMaterialfv) &&
+              ValidateMaterialfv(context->getPrivateState(),
+                                 context->getMutableErrorSetForValidation(),
+                                 angle::EntryPoint::GLMaterialfv, face, pnamePacked, params)));
         if (isCallValid)
         {
             ContextPrivateMaterialfv(context->getMutablePrivateState(),
@@ -1281,9 +1420,12 @@ void GL_APIENTRY GL_Materialx(GLenum face, GLenum pname, GLfixed param)
         MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMaterialx) &&
-              ValidateMaterialx(context, angle::EntryPoint::GLMaterialx, face, pnamePacked,
-                                param)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMaterialx) &&
+              ValidateMaterialx(context->getPrivateState(),
+                                context->getMutableErrorSetForValidation(),
+                                angle::EntryPoint::GLMaterialx, face, pnamePacked, param)));
         if (isCallValid)
         {
             ContextPrivateMaterialx(context->getMutablePrivateState(),
@@ -1311,9 +1453,12 @@ void GL_APIENTRY GL_Materialxv(GLenum face, GLenum pname, const GLfixed *param)
         MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMaterialxv) &&
-              ValidateMaterialxv(context, angle::EntryPoint::GLMaterialxv, face, pnamePacked,
-                                 param)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMaterialxv) &&
+              ValidateMaterialxv(context->getPrivateState(),
+                                 context->getMutableErrorSetForValidation(),
+                                 angle::EntryPoint::GLMaterialxv, face, pnamePacked, param)));
         if (isCallValid)
         {
             ContextPrivateMaterialxv(context->getMutablePrivateState(),
@@ -1340,8 +1485,12 @@ void GL_APIENTRY GL_MatrixMode(GLenum mode)
         MatrixType modePacked = PackParam<MatrixType>(mode);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMatrixMode) &&
-              ValidateMatrixMode(context, angle::EntryPoint::GLMatrixMode, modePacked)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMatrixMode) &&
+              ValidateMatrixMode(context->getPrivateState(),
+                                 context->getMutableErrorSetForValidation(),
+                                 angle::EntryPoint::GLMatrixMode, modePacked)));
         if (isCallValid)
         {
             ContextPrivateMatrixMode(context->getMutablePrivateState(),
@@ -1366,8 +1515,12 @@ void GL_APIENTRY GL_MultMatrixf(const GLfloat *m)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultMatrixf) &&
-              ValidateMultMatrixf(context, angle::EntryPoint::GLMultMatrixf, m)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultMatrixf) &&
+              ValidateMultMatrixf(context->getPrivateState(),
+                                  context->getMutableErrorSetForValidation(),
+                                  angle::EntryPoint::GLMultMatrixf, m)));
         if (isCallValid)
         {
             ContextPrivateMultMatrixf(context->getMutablePrivateState(),
@@ -1392,8 +1545,12 @@ void GL_APIENTRY GL_MultMatrixx(const GLfixed *m)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultMatrixx) &&
-              ValidateMultMatrixx(context, angle::EntryPoint::GLMultMatrixx, m)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultMatrixx) &&
+              ValidateMultMatrixx(context->getPrivateState(),
+                                  context->getMutableErrorSetForValidation(),
+                                  angle::EntryPoint::GLMultMatrixx, m)));
         if (isCallValid)
         {
             ContextPrivateMultMatrixx(context->getMutablePrivateState(),
@@ -1418,9 +1575,12 @@ void GL_APIENTRY GL_MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord4f) &&
-              ValidateMultiTexCoord4f(context, angle::EntryPoint::GLMultiTexCoord4f, target, s, t,
-                                      r, q)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord4f) &&
+              ValidateMultiTexCoord4f(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLMultiTexCoord4f, target, s, t, r, q)));
         if (isCallValid)
         {
             ContextPrivateMultiTexCoord4f(context->getMutablePrivateState(),
@@ -1447,9 +1607,12 @@ void GL_APIENTRY GL_MultiTexCoord4x(GLenum texture, GLfixed s, GLfixed t, GLfixe
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMultiTexCoord4x) &&
-              ValidateMultiTexCoord4x(context, angle::EntryPoint::GLMultiTexCoord4x, texture, s, t,
-                                      r, q)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiTexCoord4x) &&
+              ValidateMultiTexCoord4x(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLMultiTexCoord4x, texture, s, t, r, q)));
         if (isCallValid)
         {
             ContextPrivateMultiTexCoord4x(context->getMutablePrivateState(),
@@ -1474,8 +1637,12 @@ void GL_APIENTRY GL_Normal3f(GLfloat nx, GLfloat ny, GLfloat nz)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNormal3f) &&
-              ValidateNormal3f(context, angle::EntryPoint::GLNormal3f, nx, ny, nz)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNormal3f) &&
+              ValidateNormal3f(context->getPrivateState(),
+                               context->getMutableErrorSetForValidation(),
+                               angle::EntryPoint::GLNormal3f, nx, ny, nz)));
         if (isCallValid)
         {
             ContextPrivateNormal3f(context->getMutablePrivateState(),
@@ -1500,8 +1667,12 @@ void GL_APIENTRY GL_Normal3x(GLfixed nx, GLfixed ny, GLfixed nz)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNormal3x) &&
-              ValidateNormal3x(context, angle::EntryPoint::GLNormal3x, nx, ny, nz)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNormal3x) &&
+              ValidateNormal3x(context->getPrivateState(),
+                               context->getMutableErrorSetForValidation(),
+                               angle::EntryPoint::GLNormal3x, nx, ny, nz)));
         if (isCallValid)
         {
             ContextPrivateNormal3x(context->getMutablePrivateState(),
@@ -1529,7 +1700,9 @@ void GL_APIENTRY GL_NormalPointer(GLenum type, GLsizei stride, const void *point
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLNormalPointer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLNormalPointer) &&
               ValidateNormalPointer(context, angle::EntryPoint::GLNormalPointer, typePacked, stride,
                                     pointer)));
         if (isCallValid)
@@ -1555,8 +1728,11 @@ void GL_APIENTRY GL_Orthof(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLOrthof) &&
-              ValidateOrthof(context, angle::EntryPoint::GLOrthof, l, r, b, t, n, f)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLOrthof) &&
+              ValidateOrthof(context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                             angle::EntryPoint::GLOrthof, l, r, b, t, n, f)));
         if (isCallValid)
         {
             ContextPrivateOrthof(context->getMutablePrivateState(),
@@ -1582,8 +1758,11 @@ void GL_APIENTRY GL_Orthox(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLOrthox) &&
-              ValidateOrthox(context, angle::EntryPoint::GLOrthox, l, r, b, t, n, f)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLOrthox) &&
+              ValidateOrthox(context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                             angle::EntryPoint::GLOrthox, l, r, b, t, n, f)));
         if (isCallValid)
         {
             ContextPrivateOrthox(context->getMutablePrivateState(),
@@ -1609,9 +1788,12 @@ void GL_APIENTRY GL_PointParameterf(GLenum pname, GLfloat param)
         PointParameter pnamePacked = PackParam<PointParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPointParameterf) &&
-              ValidatePointParameterf(context, angle::EntryPoint::GLPointParameterf, pnamePacked,
-                                      param)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPointParameterf) &&
+              ValidatePointParameterf(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLPointParameterf, pnamePacked, param)));
         if (isCallValid)
         {
             ContextPrivatePointParameterf(context->getMutablePrivateState(),
@@ -1638,9 +1820,12 @@ void GL_APIENTRY GL_PointParameterfv(GLenum pname, const GLfloat *params)
         PointParameter pnamePacked = PackParam<PointParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPointParameterfv) &&
-              ValidatePointParameterfv(context, angle::EntryPoint::GLPointParameterfv, pnamePacked,
-                                       params)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPointParameterfv) &&
+              ValidatePointParameterfv(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLPointParameterfv, pnamePacked, params)));
         if (isCallValid)
         {
             ContextPrivatePointParameterfv(context->getMutablePrivateState(),
@@ -1667,9 +1852,12 @@ void GL_APIENTRY GL_PointParameterx(GLenum pname, GLfixed param)
         PointParameter pnamePacked = PackParam<PointParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPointParameterx) &&
-              ValidatePointParameterx(context, angle::EntryPoint::GLPointParameterx, pnamePacked,
-                                      param)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPointParameterx) &&
+              ValidatePointParameterx(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLPointParameterx, pnamePacked, param)));
         if (isCallValid)
         {
             ContextPrivatePointParameterx(context->getMutablePrivateState(),
@@ -1696,9 +1884,12 @@ void GL_APIENTRY GL_PointParameterxv(GLenum pname, const GLfixed *params)
         PointParameter pnamePacked = PackParam<PointParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPointParameterxv) &&
-              ValidatePointParameterxv(context, angle::EntryPoint::GLPointParameterxv, pnamePacked,
-                                       params)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPointParameterxv) &&
+              ValidatePointParameterxv(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLPointParameterxv, pnamePacked, params)));
         if (isCallValid)
         {
             ContextPrivatePointParameterxv(context->getMutablePrivateState(),
@@ -1723,8 +1914,12 @@ void GL_APIENTRY GL_PointSize(GLfloat size)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPointSize) &&
-              ValidatePointSize(context, angle::EntryPoint::GLPointSize, size)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPointSize) &&
+              ValidatePointSize(context->getPrivateState(),
+                                context->getMutableErrorSetForValidation(),
+                                angle::EntryPoint::GLPointSize, size)));
         if (isCallValid)
         {
             ContextPrivatePointSize(context->getMutablePrivateState(),
@@ -1748,8 +1943,12 @@ void GL_APIENTRY GL_PointSizex(GLfixed size)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPointSizex) &&
-              ValidatePointSizex(context, angle::EntryPoint::GLPointSizex, size)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPointSizex) &&
+              ValidatePointSizex(context->getPrivateState(),
+                                 context->getMutableErrorSetForValidation(),
+                                 angle::EntryPoint::GLPointSizex, size)));
         if (isCallValid)
         {
             ContextPrivatePointSizex(context->getMutablePrivateState(),
@@ -1774,7 +1973,9 @@ void GL_APIENTRY GL_PolygonOffsetx(GLfixed factor, GLfixed units)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidatePolygonOffsetx(context, angle::EntryPoint::GLPolygonOffsetx, factor, units));
+             ValidatePolygonOffsetx(context->getPrivateState(),
+                                    context->getMutableErrorSetForValidation(),
+                                    angle::EntryPoint::GLPolygonOffsetx, factor, units));
         if (isCallValid)
         {
             ContextPrivatePolygonOffsetx(context->getMutablePrivateState(),
@@ -1798,8 +1999,12 @@ void GL_APIENTRY GL_PopMatrix()
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPopMatrix) &&
-              ValidatePopMatrix(context, angle::EntryPoint::GLPopMatrix)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPopMatrix) &&
+              ValidatePopMatrix(context->getPrivateState(),
+                                context->getMutableErrorSetForValidation(),
+                                angle::EntryPoint::GLPopMatrix)));
         if (isCallValid)
         {
             ContextPrivatePopMatrix(context->getMutablePrivateState(),
@@ -1823,8 +2028,12 @@ void GL_APIENTRY GL_PushMatrix()
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPushMatrix) &&
-              ValidatePushMatrix(context, angle::EntryPoint::GLPushMatrix)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPushMatrix) &&
+              ValidatePushMatrix(context->getPrivateState(),
+                                 context->getMutableErrorSetForValidation(),
+                                 angle::EntryPoint::GLPushMatrix)));
         if (isCallValid)
         {
             ContextPrivatePushMatrix(context->getMutablePrivateState(),
@@ -1849,8 +2058,12 @@ void GL_APIENTRY GL_Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRotatef) &&
-              ValidateRotatef(context, angle::EntryPoint::GLRotatef, angle, x, y, z)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRotatef) &&
+              ValidateRotatef(context->getPrivateState(),
+                              context->getMutableErrorSetForValidation(),
+                              angle::EntryPoint::GLRotatef, angle, x, y, z)));
         if (isCallValid)
         {
             ContextPrivateRotatef(context->getMutablePrivateState(),
@@ -1875,8 +2088,12 @@ void GL_APIENTRY GL_Rotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLRotatex) &&
-              ValidateRotatex(context, angle::EntryPoint::GLRotatex, angle, x, y, z)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRotatex) &&
+              ValidateRotatex(context->getPrivateState(),
+                              context->getMutableErrorSetForValidation(),
+                              angle::EntryPoint::GLRotatex, angle, x, y, z)));
         if (isCallValid)
         {
             ContextPrivateRotatex(context->getMutablePrivateState(),
@@ -1901,9 +2118,12 @@ void GL_APIENTRY GL_SampleCoveragex(GLclampx value, GLboolean invert)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSampleCoveragex) &&
-              ValidateSampleCoveragex(context, angle::EntryPoint::GLSampleCoveragex, value,
-                                      invert)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSampleCoveragex) &&
+              ValidateSampleCoveragex(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLSampleCoveragex, value, invert)));
         if (isCallValid)
         {
             ContextPrivateSampleCoveragex(context->getMutablePrivateState(),
@@ -1927,8 +2147,11 @@ void GL_APIENTRY GL_Scalef(GLfloat x, GLfloat y, GLfloat z)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLScalef) &&
-              ValidateScalef(context, angle::EntryPoint::GLScalef, x, y, z)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLScalef) &&
+              ValidateScalef(context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                             angle::EntryPoint::GLScalef, x, y, z)));
         if (isCallValid)
         {
             ContextPrivateScalef(context->getMutablePrivateState(),
@@ -1952,8 +2175,11 @@ void GL_APIENTRY GL_Scalex(GLfixed x, GLfixed y, GLfixed z)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLScalex) &&
-              ValidateScalex(context, angle::EntryPoint::GLScalex, x, y, z)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLScalex) &&
+              ValidateScalex(context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                             angle::EntryPoint::GLScalex, x, y, z)));
         if (isCallValid)
         {
             ContextPrivateScalex(context->getMutablePrivateState(),
@@ -1979,8 +2205,12 @@ void GL_APIENTRY GL_ShadeModel(GLenum mode)
         ShadingModel modePacked = PackParam<ShadingModel>(mode);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLShadeModel) &&
-              ValidateShadeModel(context, angle::EntryPoint::GLShadeModel, modePacked)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLShadeModel) &&
+              ValidateShadeModel(context->getPrivateState(),
+                                 context->getMutableErrorSetForValidation(),
+                                 angle::EntryPoint::GLShadeModel, modePacked)));
         if (isCallValid)
         {
             ContextPrivateShadeModel(context->getMutablePrivateState(),
@@ -2009,7 +2239,9 @@ void GL_APIENTRY GL_TexCoordPointer(GLint size, GLenum type, GLsizei stride, con
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexCoordPointer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexCoordPointer) &&
               ValidateTexCoordPointer(context, angle::EntryPoint::GLTexCoordPointer, size,
                                       typePacked, stride, pointer)));
         if (isCallValid)
@@ -2038,9 +2270,12 @@ void GL_APIENTRY GL_TexEnvf(GLenum target, GLenum pname, GLfloat param)
         TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexEnvf) &&
-              ValidateTexEnvf(context, angle::EntryPoint::GLTexEnvf, targetPacked, pnamePacked,
-                              param)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexEnvf) &&
+              ValidateTexEnvf(context->getPrivateState(),
+                              context->getMutableErrorSetForValidation(),
+                              angle::EntryPoint::GLTexEnvf, targetPacked, pnamePacked, param)));
         if (isCallValid)
         {
             ContextPrivateTexEnvf(context->getMutablePrivateState(),
@@ -2069,9 +2304,12 @@ void GL_APIENTRY GL_TexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
         TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexEnvfv) &&
-              ValidateTexEnvfv(context, angle::EntryPoint::GLTexEnvfv, targetPacked, pnamePacked,
-                               params)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexEnvfv) &&
+              ValidateTexEnvfv(context->getPrivateState(),
+                               context->getMutableErrorSetForValidation(),
+                               angle::EntryPoint::GLTexEnvfv, targetPacked, pnamePacked, params)));
         if (isCallValid)
         {
             ContextPrivateTexEnvfv(context->getMutablePrivateState(),
@@ -2100,9 +2338,12 @@ void GL_APIENTRY GL_TexEnvi(GLenum target, GLenum pname, GLint param)
         TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexEnvi) &&
-              ValidateTexEnvi(context, angle::EntryPoint::GLTexEnvi, targetPacked, pnamePacked,
-                              param)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexEnvi) &&
+              ValidateTexEnvi(context->getPrivateState(),
+                              context->getMutableErrorSetForValidation(),
+                              angle::EntryPoint::GLTexEnvi, targetPacked, pnamePacked, param)));
         if (isCallValid)
         {
             ContextPrivateTexEnvi(context->getMutablePrivateState(),
@@ -2131,9 +2372,12 @@ void GL_APIENTRY GL_TexEnviv(GLenum target, GLenum pname, const GLint *params)
         TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexEnviv) &&
-              ValidateTexEnviv(context, angle::EntryPoint::GLTexEnviv, targetPacked, pnamePacked,
-                               params)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexEnviv) &&
+              ValidateTexEnviv(context->getPrivateState(),
+                               context->getMutableErrorSetForValidation(),
+                               angle::EntryPoint::GLTexEnviv, targetPacked, pnamePacked, params)));
         if (isCallValid)
         {
             ContextPrivateTexEnviv(context->getMutablePrivateState(),
@@ -2162,9 +2406,12 @@ void GL_APIENTRY GL_TexEnvx(GLenum target, GLenum pname, GLfixed param)
         TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexEnvx) &&
-              ValidateTexEnvx(context, angle::EntryPoint::GLTexEnvx, targetPacked, pnamePacked,
-                              param)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexEnvx) &&
+              ValidateTexEnvx(context->getPrivateState(),
+                              context->getMutableErrorSetForValidation(),
+                              angle::EntryPoint::GLTexEnvx, targetPacked, pnamePacked, param)));
         if (isCallValid)
         {
             ContextPrivateTexEnvx(context->getMutablePrivateState(),
@@ -2193,9 +2440,12 @@ void GL_APIENTRY GL_TexEnvxv(GLenum target, GLenum pname, const GLfixed *params)
         TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexEnvxv) &&
-              ValidateTexEnvxv(context, angle::EntryPoint::GLTexEnvxv, targetPacked, pnamePacked,
-                               params)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexEnvxv) &&
+              ValidateTexEnvxv(context->getPrivateState(),
+                               context->getMutableErrorSetForValidation(),
+                               angle::EntryPoint::GLTexEnvxv, targetPacked, pnamePacked, params)));
         if (isCallValid)
         {
             ContextPrivateTexEnvxv(context->getMutablePrivateState(),
@@ -2275,8 +2525,12 @@ void GL_APIENTRY GL_Translatef(GLfloat x, GLfloat y, GLfloat z)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTranslatef) &&
-              ValidateTranslatef(context, angle::EntryPoint::GLTranslatef, x, y, z)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTranslatef) &&
+              ValidateTranslatef(context->getPrivateState(),
+                                 context->getMutableErrorSetForValidation(),
+                                 angle::EntryPoint::GLTranslatef, x, y, z)));
         if (isCallValid)
         {
             ContextPrivateTranslatef(context->getMutablePrivateState(),
@@ -2301,8 +2555,12 @@ void GL_APIENTRY GL_Translatex(GLfixed x, GLfixed y, GLfixed z)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTranslatex) &&
-              ValidateTranslatex(context, angle::EntryPoint::GLTranslatex, x, y, z)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTranslatex) &&
+              ValidateTranslatex(context->getPrivateState(),
+                                 context->getMutableErrorSetForValidation(),
+                                 angle::EntryPoint::GLTranslatex, x, y, z)));
         if (isCallValid)
         {
             ContextPrivateTranslatex(context->getMutablePrivateState(),
@@ -2331,7 +2589,9 @@ void GL_APIENTRY GL_VertexPointer(GLint size, GLenum type, GLsizei stride, const
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLVertexPointer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLVertexPointer) &&
               ValidateVertexPointer(context, angle::EntryPoint::GLVertexPointer, size, typePacked,
                                     stride, pointer)));
         if (isCallValid)
diff --git a/src/libGLESv2/entry_points_gles_2_0_autogen.cpp b/src/libGLESv2/entry_points_gles_2_0_autogen.cpp
index 5e72811f3..5c3d7faba 100644
--- a/src/libGLESv2/entry_points_gles_2_0_autogen.cpp
+++ b/src/libGLESv2/entry_points_gles_2_0_autogen.cpp
@@ -31,9 +31,10 @@ void GL_APIENTRY GL_ActiveTexture(GLenum texture)
 
     if (context)
     {
-        bool isCallValid =
-            (context->skipValidation() ||
-             ValidateActiveTexture(context, angle::EntryPoint::GLActiveTexture, texture));
+        bool isCallValid = (context->skipValidation() ||
+                            ValidateActiveTexture(context->getPrivateState(),
+                                                  context->getMutableErrorSetForValidation(),
+                                                  angle::EntryPoint::GLActiveTexture, texture));
         if (isCallValid)
         {
             ContextPrivateActiveTexture(context->getMutablePrivateState(),
@@ -61,7 +62,9 @@ void GL_APIENTRY GL_AttachShader(GLuint program, GLuint shader)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLAttachShader) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLAttachShader) &&
               ValidateAttachShader(context, angle::EntryPoint::GLAttachShader, programPacked,
                                    shaderPacked)));
         if (isCallValid)
@@ -90,7 +93,9 @@ void GL_APIENTRY GL_BindAttribLocation(GLuint program, GLuint index, const GLcha
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBindAttribLocation) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBindAttribLocation) &&
               ValidateBindAttribLocation(context, angle::EntryPoint::GLBindAttribLocation,
                                          programPacked, index, name)));
         if (isCallValid)
@@ -145,7 +150,9 @@ void GL_APIENTRY GL_BindFramebuffer(GLenum target, GLuint framebuffer)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBindFramebuffer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBindFramebuffer) &&
               ValidateBindFramebuffer(context, angle::EntryPoint::GLBindFramebuffer, target,
                                       framebufferPacked)));
         if (isCallValid)
@@ -173,7 +180,9 @@ void GL_APIENTRY GL_BindRenderbuffer(GLenum target, GLuint renderbuffer)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBindRenderbuffer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBindRenderbuffer) &&
               ValidateBindRenderbuffer(context, angle::EntryPoint::GLBindRenderbuffer, target,
                                        renderbufferPacked)));
         if (isCallValid)
@@ -226,9 +235,12 @@ void GL_APIENTRY GL_BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBlendColor) &&
-              ValidateBlendColor(context, angle::EntryPoint::GLBlendColor, red, green, blue,
-                                 alpha)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBlendColor) &&
+              ValidateBlendColor(context->getPrivateState(),
+                                 context->getMutableErrorSetForValidation(),
+                                 angle::EntryPoint::GLBlendColor, red, green, blue, alpha)));
         if (isCallValid)
         {
             ContextPrivateBlendColor(context->getMutablePrivateState(),
@@ -254,8 +266,12 @@ void GL_APIENTRY GL_BlendEquation(GLenum mode)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBlendEquation) &&
-              ValidateBlendEquation(context, angle::EntryPoint::GLBlendEquation, mode)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBlendEquation) &&
+              ValidateBlendEquation(context->getPrivateState(),
+                                    context->getMutableErrorSetForValidation(),
+                                    angle::EntryPoint::GLBlendEquation, mode)));
         if (isCallValid)
         {
             ContextPrivateBlendEquation(context->getMutablePrivateState(),
@@ -281,10 +297,12 @@ void GL_APIENTRY GL_BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLBlendEquationSeparate) &&
-              ValidateBlendEquationSeparate(context, angle::EntryPoint::GLBlendEquationSeparate,
-                                            modeRGB, modeAlpha)));
+              ValidateBlendEquationSeparate(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLBlendEquationSeparate, modeRGB, modeAlpha)));
         if (isCallValid)
         {
             ContextPrivateBlendEquationSeparate(context->getMutablePrivateState(),
@@ -311,8 +329,12 @@ void GL_APIENTRY GL_BlendFunc(GLenum sfactor, GLenum dfactor)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBlendFunc) &&
-              ValidateBlendFunc(context, angle::EntryPoint::GLBlendFunc, sfactor, dfactor)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBlendFunc) &&
+              ValidateBlendFunc(context->getPrivateState(),
+                                context->getMutableErrorSetForValidation(),
+                                angle::EntryPoint::GLBlendFunc, sfactor, dfactor)));
         if (isCallValid)
         {
             ContextPrivateBlendFunc(context->getMutablePrivateState(),
@@ -344,8 +366,12 @@ void GL_APIENTRY GL_BlendFuncSeparate(GLenum sfactorRGB,
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBlendFuncSeparate) &&
-              ValidateBlendFuncSeparate(context, angle::EntryPoint::GLBlendFuncSeparate, sfactorRGB,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBlendFuncSeparate) &&
+              ValidateBlendFuncSeparate(context->getPrivateState(),
+                                        context->getMutableErrorSetForValidation(),
+                                        angle::EntryPoint::GLBlendFuncSeparate, sfactorRGB,
                                         dfactorRGB, sfactorAlpha, dfactorAlpha)));
         if (isCallValid)
         {
@@ -466,7 +492,9 @@ void GL_APIENTRY GL_Clear(GLbitfield mask)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLClear) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClear) &&
               ValidateClear(context, angle::EntryPoint::GLClear, mask)));
         if (isCallValid)
         {
@@ -491,9 +519,12 @@ void GL_APIENTRY GL_ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLClearColor) &&
-              ValidateClearColor(context, angle::EntryPoint::GLClearColor, red, green, blue,
-                                 alpha)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClearColor) &&
+              ValidateClearColor(context->getPrivateState(),
+                                 context->getMutableErrorSetForValidation(),
+                                 angle::EntryPoint::GLClearColor, red, green, blue, alpha)));
         if (isCallValid)
         {
             ContextPrivateClearColor(context->getMutablePrivateState(),
@@ -518,8 +549,12 @@ void GL_APIENTRY GL_ClearDepthf(GLfloat d)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLClearDepthf) &&
-              ValidateClearDepthf(context, angle::EntryPoint::GLClearDepthf, d)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClearDepthf) &&
+              ValidateClearDepthf(context->getPrivateState(),
+                                  context->getMutableErrorSetForValidation(),
+                                  angle::EntryPoint::GLClearDepthf, d)));
         if (isCallValid)
         {
             ContextPrivateClearDepthf(context->getMutablePrivateState(),
@@ -543,8 +578,12 @@ void GL_APIENTRY GL_ClearStencil(GLint s)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLClearStencil) &&
-              ValidateClearStencil(context, angle::EntryPoint::GLClearStencil, s)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClearStencil) &&
+              ValidateClearStencil(context->getPrivateState(),
+                                   context->getMutableErrorSetForValidation(),
+                                   angle::EntryPoint::GLClearStencil, s)));
         if (isCallValid)
         {
             ContextPrivateClearStencil(context->getMutablePrivateState(),
@@ -570,8 +609,12 @@ void GL_APIENTRY GL_ColorMask(GLboolean red, GLboolean green, GLboolean blue, GL
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLColorMask) &&
-              ValidateColorMask(context, angle::EntryPoint::GLColorMask, red, green, blue, alpha)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLColorMask) &&
+              ValidateColorMask(context->getPrivateState(),
+                                context->getMutableErrorSetForValidation(),
+                                angle::EntryPoint::GLColorMask, red, green, blue, alpha)));
         if (isCallValid)
         {
             ContextPrivateColorMask(context->getMutablePrivateState(),
@@ -598,7 +641,9 @@ void GL_APIENTRY GL_CompileShader(GLuint shader)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCompileShader) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCompileShader) &&
               ValidateCompileShader(context, angle::EntryPoint::GLCompileShader, shaderPacked)));
         if (isCallValid)
         {
@@ -634,12 +679,14 @@ void GL_APIENTRY GL_CompressedTexImage2D(GLenum target,
     {
         TextureTarget targetPacked = PackParam<TextureTarget>(target);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLCompressedTexImage2D) &&
-                             ValidateCompressedTexImage2D(
-                                 context, angle::EntryPoint::GLCompressedTexImage2D, targetPacked,
-                                 level, internalformat, width, height, border, imageSize, data)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCompressedTexImage2D) &&
+              ValidateCompressedTexImage2D(context, angle::EntryPoint::GLCompressedTexImage2D,
+                                           targetPacked, level, internalformat, width, height,
+                                           border, imageSize, data)));
         if (isCallValid)
         {
             context->compressedTexImage2D(targetPacked, level, internalformat, width, height,
@@ -679,7 +726,8 @@ void GL_APIENTRY GL_CompressedTexSubImage2D(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCompressedTexSubImage2D) &&
               ValidateCompressedTexSubImage2D(context, angle::EntryPoint::GLCompressedTexSubImage2D,
                                               targetPacked, level, xoffset, yoffset, width, height,
@@ -721,7 +769,9 @@ void GL_APIENTRY GL_CopyTexImage2D(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCopyTexImage2D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCopyTexImage2D) &&
               ValidateCopyTexImage2D(context, angle::EntryPoint::GLCopyTexImage2D, targetPacked,
                                      level, internalformat, x, y, width, height, border)));
         if (isCallValid)
@@ -761,7 +811,9 @@ void GL_APIENTRY GL_CopyTexSubImage2D(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCopyTexSubImage2D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCopyTexSubImage2D) &&
               ValidateCopyTexSubImage2D(context, angle::EntryPoint::GLCopyTexSubImage2D,
                                         targetPacked, level, xoffset, yoffset, x, y, width,
                                         height)));
@@ -790,7 +842,9 @@ GLuint GL_APIENTRY GL_CreateProgram()
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCreateProgram) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCreateProgram) &&
               ValidateCreateProgram(context, angle::EntryPoint::GLCreateProgram)));
         if (isCallValid)
         {
@@ -824,7 +878,9 @@ GLuint GL_APIENTRY GL_CreateShader(GLenum type)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCreateShader) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCreateShader) &&
               ValidateCreateShader(context, angle::EntryPoint::GLCreateShader, typePacked)));
         if (isCallValid)
         {
@@ -855,7 +911,9 @@ void GL_APIENTRY GL_CullFace(GLenum mode)
     {
         CullFaceMode modePacked = PackParam<CullFaceMode>(mode);
         bool isCallValid        = (context->skipValidation() ||
-                            ValidateCullFace(context, angle::EntryPoint::GLCullFace, modePacked));
+                            ValidateCullFace(context->getPrivateState(),
+                                                    context->getMutableErrorSetForValidation(),
+                                                    angle::EntryPoint::GLCullFace, modePacked));
         if (isCallValid)
         {
             ContextPrivateCullFace(context->getMutablePrivateState(),
@@ -1036,7 +1094,9 @@ void GL_APIENTRY GL_DepthFunc(GLenum func)
     if (context)
     {
         bool isCallValid = (context->skipValidation() ||
-                            ValidateDepthFunc(context, angle::EntryPoint::GLDepthFunc, func));
+                            ValidateDepthFunc(context->getPrivateState(),
+                                              context->getMutableErrorSetForValidation(),
+                                              angle::EntryPoint::GLDepthFunc, func));
         if (isCallValid)
         {
             ContextPrivateDepthFunc(context->getMutablePrivateState(),
@@ -1059,7 +1119,9 @@ void GL_APIENTRY GL_DepthMask(GLboolean flag)
     if (context)
     {
         bool isCallValid = (context->skipValidation() ||
-                            ValidateDepthMask(context, angle::EntryPoint::GLDepthMask, flag));
+                            ValidateDepthMask(context->getPrivateState(),
+                                              context->getMutableErrorSetForValidation(),
+                                              angle::EntryPoint::GLDepthMask, flag));
         if (isCallValid)
         {
             ContextPrivateDepthMask(context->getMutablePrivateState(),
@@ -1082,7 +1144,9 @@ void GL_APIENTRY GL_DepthRangef(GLfloat n, GLfloat f)
     if (context)
     {
         bool isCallValid = (context->skipValidation() ||
-                            ValidateDepthRangef(context, angle::EntryPoint::GLDepthRangef, n, f));
+                            ValidateDepthRangef(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDepthRangef, n, f));
         if (isCallValid)
         {
             ContextPrivateDepthRangef(context->getMutablePrivateState(),
@@ -1110,7 +1174,9 @@ void GL_APIENTRY GL_DetachShader(GLuint program, GLuint shader)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDetachShader) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDetachShader) &&
               ValidateDetachShader(context, angle::EntryPoint::GLDetachShader, programPacked,
                                    shaderPacked)));
         if (isCallValid)
@@ -1134,8 +1200,10 @@ void GL_APIENTRY GL_Disable(GLenum cap)
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateDisable(context, angle::EntryPoint::GLDisable, cap));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateDisable(context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                             angle::EntryPoint::GLDisable, cap));
         if (isCallValid)
         {
             ContextPrivateDisable(context->getMutablePrivateState(),
@@ -1238,8 +1306,10 @@ void GL_APIENTRY GL_Enable(GLenum cap)
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateEnable(context, angle::EntryPoint::GLEnable, cap));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateEnable(context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                            angle::EntryPoint::GLEnable, cap));
         if (isCallValid)
         {
             ContextPrivateEnable(context->getMutablePrivateState(),
@@ -1288,7 +1358,9 @@ void GL_APIENTRY GL_Finish()
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFinish) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFinish) &&
               ValidateFinish(context, angle::EntryPoint::GLFinish)));
         if (isCallValid)
         {
@@ -1313,7 +1385,9 @@ void GL_APIENTRY GL_Flush()
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFlush) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFlush) &&
               ValidateFlush(context, angle::EntryPoint::GLFlush)));
         if (isCallValid)
         {
@@ -1344,12 +1418,14 @@ void GL_APIENTRY GL_FramebufferRenderbuffer(GLenum target,
     {
         RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLFramebufferRenderbuffer) &&
-                             ValidateFramebufferRenderbuffer(
-                                 context, angle::EntryPoint::GLFramebufferRenderbuffer, target,
-                                 attachment, renderbuffertarget, renderbufferPacked)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFramebufferRenderbuffer) &&
+              ValidateFramebufferRenderbuffer(context, angle::EntryPoint::GLFramebufferRenderbuffer,
+                                              target, attachment, renderbuffertarget,
+                                              renderbufferPacked)));
         if (isCallValid)
         {
             context->framebufferRenderbuffer(target, attachment, renderbuffertarget,
@@ -1383,12 +1459,14 @@ void GL_APIENTRY GL_FramebufferTexture2D(GLenum target,
         TextureTarget textargetPacked = PackParam<TextureTarget>(textarget);
         TextureID texturePacked       = PackParam<TextureID>(texture);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLFramebufferTexture2D) &&
-                             ValidateFramebufferTexture2D(
-                                 context, angle::EntryPoint::GLFramebufferTexture2D, target,
-                                 attachment, textargetPacked, texturePacked, level)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFramebufferTexture2D) &&
+              ValidateFramebufferTexture2D(context, angle::EntryPoint::GLFramebufferTexture2D,
+                                           target, attachment, textargetPacked, texturePacked,
+                                           level)));
         if (isCallValid)
         {
             context->framebufferTexture2D(target, attachment, textargetPacked, texturePacked,
@@ -1413,7 +1491,9 @@ void GL_APIENTRY GL_FrontFace(GLenum mode)
     if (context)
     {
         bool isCallValid = (context->skipValidation() ||
-                            ValidateFrontFace(context, angle::EntryPoint::GLFrontFace, mode));
+                            ValidateFrontFace(context->getPrivateState(),
+                                              context->getMutableErrorSetForValidation(),
+                                              angle::EntryPoint::GLFrontFace, mode));
         if (isCallValid)
         {
             ContextPrivateFrontFace(context->getMutablePrivateState(),
@@ -2346,8 +2426,11 @@ void GL_APIENTRY GL_Hint(GLenum target, GLenum mode)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLHint) &&
-              ValidateHint(context, angle::EntryPoint::GLHint, target, mode)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLHint) &&
+              ValidateHint(context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                           angle::EntryPoint::GLHint, target, mode)));
         if (isCallValid)
         {
             ContextPrivateHint(context->getMutablePrivateState(),
@@ -2403,7 +2486,9 @@ GLboolean GL_APIENTRY GL_IsEnabled(GLenum cap)
     if (context)
     {
         bool isCallValid = (context->skipValidation() ||
-                            ValidateIsEnabled(context, angle::EntryPoint::GLIsEnabled, cap));
+                            ValidateIsEnabled(context->getPrivateState(),
+                                              context->getMutableErrorSetForValidation(),
+                                              angle::EntryPoint::GLIsEnabled, cap));
         if (isCallValid)
         {
             returnValue = ContextPrivateIsEnabled(context->getMutablePrivateState(),
@@ -2592,8 +2677,12 @@ void GL_APIENTRY GL_LineWidth(GLfloat width)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLineWidth) &&
-              ValidateLineWidth(context, angle::EntryPoint::GLLineWidth, width)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLineWidth) &&
+              ValidateLineWidth(context->getPrivateState(),
+                                context->getMutableErrorSetForValidation(),
+                                angle::EntryPoint::GLLineWidth, width)));
         if (isCallValid)
         {
             ContextPrivateLineWidth(context->getMutablePrivateState(),
@@ -2619,7 +2708,9 @@ void GL_APIENTRY GL_LinkProgram(GLuint program)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLinkProgram) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLinkProgram) &&
               ValidateLinkProgram(context, angle::EntryPoint::GLLinkProgram, programPacked)));
         if (isCallValid)
         {
@@ -2644,8 +2735,12 @@ void GL_APIENTRY GL_PixelStorei(GLenum pname, GLint param)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPixelStorei) &&
-              ValidatePixelStorei(context, angle::EntryPoint::GLPixelStorei, pname, param)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPixelStorei) &&
+              ValidatePixelStorei(context->getPrivateState(),
+                                  context->getMutableErrorSetForValidation(),
+                                  angle::EntryPoint::GLPixelStorei, pname, param)));
         if (isCallValid)
         {
             ContextPrivatePixelStorei(context->getMutablePrivateState(),
@@ -2670,7 +2765,9 @@ void GL_APIENTRY GL_PolygonOffset(GLfloat factor, GLfloat units)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidatePolygonOffset(context, angle::EntryPoint::GLPolygonOffset, factor, units));
+             ValidatePolygonOffset(context->getPrivateState(),
+                                   context->getMutableErrorSetForValidation(),
+                                   angle::EntryPoint::GLPolygonOffset, factor, units));
         if (isCallValid)
         {
             ContextPrivatePolygonOffset(context->getMutablePrivateState(),
@@ -2705,7 +2802,9 @@ void GL_APIENTRY GL_ReadPixels(GLint x,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLReadPixels) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLReadPixels) &&
               ValidateReadPixels(context, angle::EntryPoint::GLReadPixels, x, y, width, height,
                                  format, type, pixels)));
         if (isCallValid)
@@ -2732,7 +2831,8 @@ void GL_APIENTRY GL_ReleaseShaderCompiler()
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLReleaseShaderCompiler) &&
               ValidateReleaseShaderCompiler(context, angle::EntryPoint::GLReleaseShaderCompiler)));
         if (isCallValid)
@@ -2764,7 +2864,8 @@ void GL_APIENTRY GL_RenderbufferStorage(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLRenderbufferStorage) &&
               ValidateRenderbufferStorage(context, angle::EntryPoint::GLRenderbufferStorage, target,
                                           internalformat, width, height)));
@@ -2792,8 +2893,12 @@ void GL_APIENTRY GL_SampleCoverage(GLfloat value, GLboolean invert)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSampleCoverage) &&
-              ValidateSampleCoverage(context, angle::EntryPoint::GLSampleCoverage, value, invert)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSampleCoverage) &&
+              ValidateSampleCoverage(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLSampleCoverage, value, invert)));
         if (isCallValid)
         {
             ContextPrivateSampleCoverage(context->getMutablePrivateState(),
@@ -2818,7 +2923,8 @@ void GL_APIENTRY GL_Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateScissor(context, angle::EntryPoint::GLScissor, x, y, width, height));
+             ValidateScissor(context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                             angle::EntryPoint::GLScissor, x, y, width, height));
         if (isCallValid)
         {
             ContextPrivateScissor(context->getMutablePrivateState(),
@@ -2852,7 +2958,9 @@ void GL_APIENTRY GL_ShaderBinary(GLsizei count,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLShaderBinary) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLShaderBinary) &&
               ValidateShaderBinary(context, angle::EntryPoint::GLShaderBinary, count, shadersPacked,
                                    binaryFormat, binary, length)));
         if (isCallValid)
@@ -2886,7 +2994,9 @@ void GL_APIENTRY GL_ShaderSource(GLuint shader,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLShaderSource) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLShaderSource) &&
               ValidateShaderSource(context, angle::EntryPoint::GLShaderSource, shaderPacked, count,
                                    string, length)));
         if (isCallValid)
@@ -2910,9 +3020,10 @@ void GL_APIENTRY GL_StencilFunc(GLenum func, GLint ref, GLuint mask)
 
     if (context)
     {
-        bool isCallValid =
-            (context->skipValidation() ||
-             ValidateStencilFunc(context, angle::EntryPoint::GLStencilFunc, func, ref, mask));
+        bool isCallValid = (context->skipValidation() ||
+                            ValidateStencilFunc(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLStencilFunc, func, ref, mask));
         if (isCallValid)
         {
             ContextPrivateStencilFunc(context->getMutablePrivateState(),
@@ -2938,8 +3049,9 @@ void GL_APIENTRY GL_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLu
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateStencilFuncSeparate(context, angle::EntryPoint::GLStencilFuncSeparate, face,
-                                         func, ref, mask));
+             ValidateStencilFuncSeparate(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLStencilFuncSeparate, face, func, ref, mask));
         if (isCallValid)
         {
             ContextPrivateStencilFuncSeparate(context->getMutablePrivateState(),
@@ -2963,7 +3075,9 @@ void GL_APIENTRY GL_StencilMask(GLuint mask)
     if (context)
     {
         bool isCallValid = (context->skipValidation() ||
-                            ValidateStencilMask(context, angle::EntryPoint::GLStencilMask, mask));
+                            ValidateStencilMask(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLStencilMask, mask));
         if (isCallValid)
         {
             ContextPrivateStencilMask(context->getMutablePrivateState(),
@@ -2986,9 +3100,11 @@ void GL_APIENTRY GL_StencilMaskSeparate(GLenum face, GLuint mask)
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateStencilMaskSeparate(
-                                context, angle::EntryPoint::GLStencilMaskSeparate, face, mask));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateStencilMaskSeparate(context->getPrivateState(),
+                                         context->getMutableErrorSetForValidation(),
+                                         angle::EntryPoint::GLStencilMaskSeparate, face, mask));
         if (isCallValid)
         {
             ContextPrivateStencilMaskSeparate(context->getMutablePrivateState(),
@@ -3012,9 +3128,10 @@ void GL_APIENTRY GL_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 
     if (context)
     {
-        bool isCallValid =
-            (context->skipValidation() ||
-             ValidateStencilOp(context, angle::EntryPoint::GLStencilOp, fail, zfail, zpass));
+        bool isCallValid = (context->skipValidation() ||
+                            ValidateStencilOp(context->getPrivateState(),
+                                              context->getMutableErrorSetForValidation(),
+                                              angle::EntryPoint::GLStencilOp, fail, zfail, zpass));
         if (isCallValid)
         {
             ContextPrivateStencilOp(context->getMutablePrivateState(),
@@ -3041,8 +3158,9 @@ void GL_APIENTRY GL_StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail,
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateStencilOpSeparate(context, angle::EntryPoint::GLStencilOpSeparate, face, sfail,
-                                       dpfail, dppass));
+             ValidateStencilOpSeparate(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLStencilOpSeparate, face, sfail, dpfail, dppass));
         if (isCallValid)
         {
             ContextPrivateStencilOpSeparate(context->getMutablePrivateState(),
@@ -3082,7 +3200,9 @@ void GL_APIENTRY GL_TexImage2D(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexImage2D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexImage2D) &&
               ValidateTexImage2D(context, angle::EntryPoint::GLTexImage2D, targetPacked, level,
                                  internalformat, width, height, border, format, type, pixels)));
         if (isCallValid)
@@ -3234,7 +3354,9 @@ void GL_APIENTRY GL_TexSubImage2D(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexSubImage2D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexSubImage2D) &&
               ValidateTexSubImage2D(context, angle::EntryPoint::GLTexSubImage2D, targetPacked,
                                     level, xoffset, yoffset, width, height, format, type, pixels)));
         if (isCallValid)
@@ -3824,9 +3946,10 @@ void GL_APIENTRY GL_VertexAttrib1f(GLuint index, GLfloat x)
 
     if (context)
     {
-        bool isCallValid =
-            (context->skipValidation() ||
-             ValidateVertexAttrib1f(context, angle::EntryPoint::GLVertexAttrib1f, index, x));
+        bool isCallValid = (context->skipValidation() ||
+                            ValidateVertexAttrib1f(context->getPrivateState(),
+                                                   context->getMutableErrorSetForValidation(),
+                                                   angle::EntryPoint::GLVertexAttrib1f, index, x));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib1f(context->getMutablePrivateState(),
@@ -3851,7 +3974,9 @@ void GL_APIENTRY GL_VertexAttrib1fv(GLuint index, const GLfloat *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib1fv(context, angle::EntryPoint::GLVertexAttrib1fv, index, v));
+             ValidateVertexAttrib1fv(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttrib1fv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib1fv(context->getMutablePrivateState(),
@@ -3876,7 +4001,9 @@ void GL_APIENTRY GL_VertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib2f(context, angle::EntryPoint::GLVertexAttrib2f, index, x, y));
+             ValidateVertexAttrib2f(context->getPrivateState(),
+                                    context->getMutableErrorSetForValidation(),
+                                    angle::EntryPoint::GLVertexAttrib2f, index, x, y));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib2f(context->getMutablePrivateState(),
@@ -3901,7 +4028,9 @@ void GL_APIENTRY GL_VertexAttrib2fv(GLuint index, const GLfloat *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib2fv(context, angle::EntryPoint::GLVertexAttrib2fv, index, v));
+             ValidateVertexAttrib2fv(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttrib2fv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib2fv(context->getMutablePrivateState(),
@@ -3926,7 +4055,9 @@ void GL_APIENTRY GL_VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib3f(context, angle::EntryPoint::GLVertexAttrib3f, index, x, y, z));
+             ValidateVertexAttrib3f(context->getPrivateState(),
+                                    context->getMutableErrorSetForValidation(),
+                                    angle::EntryPoint::GLVertexAttrib3f, index, x, y, z));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib3f(context->getMutablePrivateState(),
@@ -3951,7 +4082,9 @@ void GL_APIENTRY GL_VertexAttrib3fv(GLuint index, const GLfloat *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib3fv(context, angle::EntryPoint::GLVertexAttrib3fv, index, v));
+             ValidateVertexAttrib3fv(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttrib3fv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib3fv(context->getMutablePrivateState(),
@@ -3974,9 +4107,11 @@ void GL_APIENTRY GL_VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateVertexAttrib4f(context, angle::EntryPoint::GLVertexAttrib4f,
-                                                   index, x, y, z, w));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateVertexAttrib4f(context->getPrivateState(),
+                                    context->getMutableErrorSetForValidation(),
+                                    angle::EntryPoint::GLVertexAttrib4f, index, x, y, z, w));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4f(context->getMutablePrivateState(),
@@ -4001,7 +4136,9 @@ void GL_APIENTRY GL_VertexAttrib4fv(GLuint index, const GLfloat *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttrib4fv(context, angle::EntryPoint::GLVertexAttrib4fv, index, v));
+             ValidateVertexAttrib4fv(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttrib4fv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttrib4fv(context->getMutablePrivateState(),
@@ -4060,9 +4197,10 @@ void GL_APIENTRY GL_Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
 
     if (context)
     {
-        bool isCallValid =
-            (context->skipValidation() ||
-             ValidateViewport(context, angle::EntryPoint::GLViewport, x, y, width, height));
+        bool isCallValid = (context->skipValidation() ||
+                            ValidateViewport(context->getPrivateState(),
+                                             context->getMutableErrorSetForValidation(),
+                                             angle::EntryPoint::GLViewport, x, y, width, height));
         if (isCallValid)
         {
             ContextPrivateViewport(context->getMutablePrivateState(),
diff --git a/src/libGLESv2/entry_points_gles_3_0_autogen.cpp b/src/libGLESv2/entry_points_gles_3_0_autogen.cpp
index 3905bc6aa..163054bae 100644
--- a/src/libGLESv2/entry_points_gles_3_0_autogen.cpp
+++ b/src/libGLESv2/entry_points_gles_3_0_autogen.cpp
@@ -36,7 +36,9 @@ void GL_APIENTRY GL_BeginQuery(GLenum target, GLuint id)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBeginQuery) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBeginQuery) &&
               ValidateBeginQuery(context, angle::EntryPoint::GLBeginQuery, targetPacked,
                                  idPacked)));
         if (isCallValid)
@@ -64,7 +66,8 @@ void GL_APIENTRY GL_BeginTransformFeedback(GLenum primitiveMode)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLBeginTransformFeedback) &&
               ValidateBeginTransformFeedback(context, angle::EntryPoint::GLBeginTransformFeedback,
                                              primitiveModePacked)));
@@ -178,7 +181,8 @@ void GL_APIENTRY GL_BindTransformFeedback(GLenum target, GLuint id)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLBindTransformFeedback) &&
               ValidateBindTransformFeedback(context, angle::EntryPoint::GLBindTransformFeedback,
                                             target, idPacked)));
@@ -244,7 +248,9 @@ void GL_APIENTRY GL_BlitFramebuffer(GLint srcX0,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBlitFramebuffer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBlitFramebuffer) &&
               ValidateBlitFramebuffer(context, angle::EntryPoint::GLBlitFramebuffer, srcX0, srcY0,
                                       srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)));
         if (isCallValid)
@@ -381,7 +387,9 @@ GLenum GL_APIENTRY GL_ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 tim
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLClientWaitSync) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLClientWaitSync) &&
               ValidateClientWaitSync(context, angle::EntryPoint::GLClientWaitSync, syncPacked,
                                      flags, timeout)));
         if (isCallValid)
@@ -428,7 +436,8 @@ void GL_APIENTRY GL_CompressedTexImage3D(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCompressedTexImage3D) &&
               ValidateCompressedTexImage3D(context, angle::EntryPoint::GLCompressedTexImage3D,
                                            targetPacked, level, internalformat, width, height,
@@ -474,7 +483,8 @@ void GL_APIENTRY GL_CompressedTexSubImage3D(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCompressedTexSubImage3D) &&
               ValidateCompressedTexSubImage3D(context, angle::EntryPoint::GLCompressedTexSubImage3D,
                                               targetPacked, level, xoffset, yoffset, zoffset, width,
@@ -516,7 +526,9 @@ void GL_APIENTRY GL_CopyBufferSubData(GLenum readTarget,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCopyBufferSubData) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCopyBufferSubData) &&
               ValidateCopyBufferSubData(context, angle::EntryPoint::GLCopyBufferSubData,
                                         readTargetPacked, writeTargetPacked, readOffset,
                                         writeOffset, size)));
@@ -558,7 +570,9 @@ void GL_APIENTRY GL_CopyTexSubImage3D(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCopyTexSubImage3D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCopyTexSubImage3D) &&
               ValidateCopyTexSubImage3D(context, angle::EntryPoint::GLCopyTexSubImage3D,
                                         targetPacked, level, xoffset, yoffset, zoffset, x, y, width,
                                         height)));
@@ -751,7 +765,9 @@ void GL_APIENTRY GL_DrawBuffers(GLsizei n, const GLenum *bufs)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDrawBuffers) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDrawBuffers) &&
               ValidateDrawBuffers(context, angle::EntryPoint::GLDrawBuffers, n, bufs)));
         if (isCallValid)
         {
@@ -851,7 +867,9 @@ void GL_APIENTRY GL_EndQuery(GLenum target)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEndQuery) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEndQuery) &&
               ValidateEndQuery(context, angle::EntryPoint::GLEndQuery, targetPacked)));
         if (isCallValid)
         {
@@ -876,7 +894,8 @@ void GL_APIENTRY GL_EndTransformFeedback()
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLEndTransformFeedback) &&
               ValidateEndTransformFeedback(context, angle::EntryPoint::GLEndTransformFeedback)));
         if (isCallValid)
@@ -973,7 +992,8 @@ void GL_APIENTRY GL_FramebufferTextureLayer(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLFramebufferTextureLayer) &&
               ValidateFramebufferTextureLayer(context, angle::EntryPoint::GLFramebufferTextureLayer,
                                               target, attachment, texturePacked, level, layer)));
@@ -1824,7 +1844,8 @@ void GL_APIENTRY GL_InvalidateFramebuffer(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLInvalidateFramebuffer) &&
               ValidateInvalidateFramebuffer(context, angle::EntryPoint::GLInvalidateFramebuffer,
                                             target, numAttachments, attachments)));
@@ -1860,12 +1881,14 @@ void GL_APIENTRY GL_InvalidateSubFramebuffer(GLenum target,
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLInvalidateSubFramebuffer) &&
-                             ValidateInvalidateSubFramebuffer(
-                                 context, angle::EntryPoint::GLInvalidateSubFramebuffer, target,
-                                 numAttachments, attachments, x, y, width, height)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLInvalidateSubFramebuffer) &&
+              ValidateInvalidateSubFramebuffer(
+                  context, angle::EntryPoint::GLInvalidateSubFramebuffer, target, numAttachments,
+                  attachments, x, y, width, height)));
         if (isCallValid)
         {
             context->invalidateSubFramebuffer(target, numAttachments, attachments, x, y, width,
@@ -2089,11 +2112,13 @@ void GL_APIENTRY GL_PauseTransformFeedback()
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLPauseTransformFeedback) &&
-                             ValidatePauseTransformFeedback(
-                                 context, angle::EntryPoint::GLPauseTransformFeedback)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPauseTransformFeedback) &&
+              ValidatePauseTransformFeedback(context,
+                                             angle::EntryPoint::GLPauseTransformFeedback)));
         if (isCallValid)
         {
             context->pauseTransformFeedback();
@@ -2124,7 +2149,9 @@ void GL_APIENTRY GL_ProgramBinary(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramBinary) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramBinary) &&
               ValidateProgramBinary(context, angle::EntryPoint::GLProgramBinary, programPacked,
                                     binaryFormat, binary, length)));
         if (isCallValid)
@@ -2153,7 +2180,9 @@ void GL_APIENTRY GL_ProgramParameteri(GLuint program, GLenum pname, GLint value)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramParameteri) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramParameteri) &&
               ValidateProgramParameteri(context, angle::EntryPoint::GLProgramParameteri,
                                         programPacked, pname, value)));
         if (isCallValid)
@@ -2180,7 +2209,9 @@ void GL_APIENTRY GL_ReadBuffer(GLenum src)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLReadBuffer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLReadBuffer) &&
               ValidateReadBuffer(context, angle::EntryPoint::GLReadBuffer, src)));
         if (isCallValid)
         {
@@ -2210,12 +2241,14 @@ void GL_APIENTRY GL_RenderbufferStorageMultisample(GLenum target,
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLRenderbufferStorageMultisample) &&
-                             ValidateRenderbufferStorageMultisample(
-                                 context, angle::EntryPoint::GLRenderbufferStorageMultisample,
-                                 target, samples, internalformat, width, height)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLRenderbufferStorageMultisample) &&
+              ValidateRenderbufferStorageMultisample(
+                  context, angle::EntryPoint::GLRenderbufferStorageMultisample, target, samples,
+                  internalformat, width, height)));
         if (isCallValid)
         {
             context->renderbufferStorageMultisample(target, samples, internalformat, width, height);
@@ -2238,11 +2271,13 @@ void GL_APIENTRY GL_ResumeTransformFeedback()
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLResumeTransformFeedback) &&
-                             ValidateResumeTransformFeedback(
-                                 context, angle::EntryPoint::GLResumeTransformFeedback)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLResumeTransformFeedback) &&
+              ValidateResumeTransformFeedback(context,
+                                              angle::EntryPoint::GLResumeTransformFeedback)));
         if (isCallValid)
         {
             context->resumeTransformFeedback();
@@ -2391,7 +2426,9 @@ void GL_APIENTRY GL_TexImage3D(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexImage3D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexImage3D) &&
               ValidateTexImage3D(context, angle::EntryPoint::GLTexImage3D, targetPacked, level,
                                  internalformat, width, height, depth, border, format, type,
                                  pixels)));
@@ -2425,7 +2462,9 @@ GL_TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei wi
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexStorage2D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexStorage2D) &&
               ValidateTexStorage2D(context, angle::EntryPoint::GLTexStorage2D, targetPacked, levels,
                                    internalformat, width, height)));
         if (isCallValid)
@@ -2462,7 +2501,9 @@ void GL_APIENTRY GL_TexStorage3D(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexStorage3D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexStorage3D) &&
               ValidateTexStorage3D(context, angle::EntryPoint::GLTexStorage3D, targetPacked, levels,
                                    internalformat, width, height, depth)));
         if (isCallValid)
@@ -2505,7 +2546,9 @@ void GL_APIENTRY GL_TexSubImage3D(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexSubImage3D) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexSubImage3D) &&
               ValidateTexSubImage3D(context, angle::EntryPoint::GLTexSubImage3D, targetPacked,
                                     level, xoffset, yoffset, zoffset, width, height, depth, format,
                                     type, pixels)));
@@ -2539,12 +2582,14 @@ void GL_APIENTRY GL_TransformFeedbackVaryings(GLuint program,
     {
         ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLTransformFeedbackVaryings) &&
-                             ValidateTransformFeedbackVaryings(
-                                 context, angle::EntryPoint::GLTransformFeedbackVaryings,
-                                 programPacked, count, varyings, bufferMode)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTransformFeedbackVaryings) &&
+              ValidateTransformFeedbackVaryings(context,
+                                                angle::EntryPoint::GLTransformFeedbackVaryings,
+                                                programPacked, count, varyings, bufferMode)));
         if (isCallValid)
         {
             context->transformFeedbackVaryings(programPacked, count, varyings, bufferMode);
@@ -3062,9 +3107,11 @@ void GL_APIENTRY GL_VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLi
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateVertexAttribI4i(context, angle::EntryPoint::GLVertexAttribI4i,
-                                                    index, x, y, z, w));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateVertexAttribI4i(context->getPrivateState(),
+                                     context->getMutableErrorSetForValidation(),
+                                     angle::EntryPoint::GLVertexAttribI4i, index, x, y, z, w));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI4i(context->getMutablePrivateState(),
@@ -3090,7 +3137,9 @@ void GL_APIENTRY GL_VertexAttribI4iv(GLuint index, const GLint *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribI4iv(context, angle::EntryPoint::GLVertexAttribI4iv, index, v));
+             ValidateVertexAttribI4iv(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttribI4iv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI4iv(context->getMutablePrivateState(),
@@ -3113,9 +3162,11 @@ void GL_APIENTRY GL_VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z,
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateVertexAttribI4ui(context, angle::EntryPoint::GLVertexAttribI4ui,
-                                                     index, x, y, z, w));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateVertexAttribI4ui(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLVertexAttribI4ui, index, x, y, z, w));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI4ui(context->getMutablePrivateState(),
@@ -3141,7 +3192,9 @@ void GL_APIENTRY GL_VertexAttribI4uiv(GLuint index, const GLuint *v)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateVertexAttribI4uiv(context, angle::EntryPoint::GLVertexAttribI4uiv, index, v));
+             ValidateVertexAttribI4uiv(context->getPrivateState(),
+                                       context->getMutableErrorSetForValidation(),
+                                       angle::EntryPoint::GLVertexAttribI4uiv, index, v));
         if (isCallValid)
         {
             ContextPrivateVertexAttribI4uiv(context->getMutablePrivateState(),
@@ -3202,7 +3255,9 @@ void GL_APIENTRY GL_WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWaitSync) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWaitSync) &&
               ValidateWaitSync(context, angle::EntryPoint::GLWaitSync, syncPacked, flags,
                                timeout)));
         if (isCallValid)
diff --git a/src/libGLESv2/entry_points_gles_3_1_autogen.cpp b/src/libGLESv2/entry_points_gles_3_1_autogen.cpp
index bab601411..a1a158eaf 100644
--- a/src/libGLESv2/entry_points_gles_3_1_autogen.cpp
+++ b/src/libGLESv2/entry_points_gles_3_1_autogen.cpp
@@ -36,7 +36,8 @@ void GL_APIENTRY GL_ActiveShaderProgram(GLuint pipeline, GLuint program)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLActiveShaderProgram) &&
               ValidateActiveShaderProgram(context, angle::EntryPoint::GLActiveShaderProgram,
                                           pipelinePacked, programPacked)));
@@ -75,7 +76,9 @@ void GL_APIENTRY GL_BindImageTexture(GLuint unit,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBindImageTexture) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBindImageTexture) &&
               ValidateBindImageTexture(context, angle::EntryPoint::GLBindImageTexture, unit,
                                        texturePacked, level, layered, layer, access, format)));
         if (isCallValid)
@@ -103,7 +106,8 @@ void GL_APIENTRY GL_BindProgramPipeline(GLuint pipeline)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLBindProgramPipeline) &&
               ValidateBindProgramPipeline(context, angle::EntryPoint::GLBindProgramPipeline,
                                           pipelinePacked)));
@@ -136,7 +140,9 @@ void GL_APIENTRY GL_BindVertexBuffer(GLuint bindingindex,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBindVertexBuffer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBindVertexBuffer) &&
               ValidateBindVertexBuffer(context, angle::EntryPoint::GLBindVertexBuffer, bindingindex,
                                        bufferPacked, offset, stride)));
         if (isCallValid)
@@ -167,7 +173,8 @@ GLuint GL_APIENTRY GL_CreateShaderProgramv(GLenum type, GLsizei count, const GLc
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCreateShaderProgramv) &&
               ValidateCreateShaderProgramv(context, angle::EntryPoint::GLCreateShaderProgramv,
                                            typePacked, count, strings)));
@@ -231,7 +238,9 @@ void GL_APIENTRY GL_DispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GL
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDispatchCompute) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDispatchCompute) &&
               ValidateDispatchCompute(context, angle::EntryPoint::GLDispatchCompute, num_groups_x,
                                       num_groups_y, num_groups_z)));
         if (isCallValid)
@@ -343,7 +352,8 @@ void GL_APIENTRY GL_FramebufferParameteri(GLenum target, GLenum pname, GLint par
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLFramebufferParameteri) &&
               ValidateFramebufferParameteri(context, angle::EntryPoint::GLFramebufferParameteri,
                                             target, pname, param)));
@@ -827,7 +837,9 @@ void GL_APIENTRY GL_MemoryBarrier(GLbitfield barriers)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMemoryBarrier) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMemoryBarrier) &&
               ValidateMemoryBarrier(context, angle::EntryPoint::GLMemoryBarrier, barriers)));
         if (isCallValid)
         {
@@ -851,11 +863,13 @@ void GL_APIENTRY GL_MemoryBarrierByRegion(GLbitfield barriers)
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLMemoryBarrierByRegion) &&
-                             ValidateMemoryBarrierByRegion(
-                                 context, angle::EntryPoint::GLMemoryBarrierByRegion, barriers)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMemoryBarrierByRegion) &&
+              ValidateMemoryBarrierByRegion(context, angle::EntryPoint::GLMemoryBarrierByRegion,
+                                            barriers)));
         if (isCallValid)
         {
             context->memoryBarrierByRegion(barriers);
@@ -882,7 +896,9 @@ void GL_APIENTRY GL_ProgramUniform1f(GLuint program, GLint location, GLfloat v0)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform1f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform1f) &&
               ValidateProgramUniform1f(context, angle::EntryPoint::GLProgramUniform1f,
                                        programPacked, locationPacked, v0)));
         if (isCallValid)
@@ -915,7 +931,9 @@ void GL_APIENTRY GL_ProgramUniform1fv(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform1fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform1fv) &&
               ValidateProgramUniform1fv(context, angle::EntryPoint::GLProgramUniform1fv,
                                         programPacked, locationPacked, count, value)));
         if (isCallValid)
@@ -945,7 +963,9 @@ void GL_APIENTRY GL_ProgramUniform1i(GLuint program, GLint location, GLint v0)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform1i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform1i) &&
               ValidateProgramUniform1i(context, angle::EntryPoint::GLProgramUniform1i,
                                        programPacked, locationPacked, v0)));
         if (isCallValid)
@@ -978,7 +998,9 @@ void GL_APIENTRY GL_ProgramUniform1iv(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform1iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform1iv) &&
               ValidateProgramUniform1iv(context, angle::EntryPoint::GLProgramUniform1iv,
                                         programPacked, locationPacked, count, value)));
         if (isCallValid)
@@ -1008,7 +1030,9 @@ void GL_APIENTRY GL_ProgramUniform1ui(GLuint program, GLint location, GLuint v0)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform1ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform1ui) &&
               ValidateProgramUniform1ui(context, angle::EntryPoint::GLProgramUniform1ui,
                                         programPacked, locationPacked, v0)));
         if (isCallValid)
@@ -1042,7 +1066,9 @@ void GL_APIENTRY GL_ProgramUniform1uiv(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform1uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform1uiv) &&
               ValidateProgramUniform1uiv(context, angle::EntryPoint::GLProgramUniform1uiv,
                                          programPacked, locationPacked, count, value)));
         if (isCallValid)
@@ -1073,7 +1099,9 @@ void GL_APIENTRY GL_ProgramUniform2f(GLuint program, GLint location, GLfloat v0,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform2f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform2f) &&
               ValidateProgramUniform2f(context, angle::EntryPoint::GLProgramUniform2f,
                                        programPacked, locationPacked, v0, v1)));
         if (isCallValid)
@@ -1107,7 +1135,9 @@ void GL_APIENTRY GL_ProgramUniform2fv(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform2fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform2fv) &&
               ValidateProgramUniform2fv(context, angle::EntryPoint::GLProgramUniform2fv,
                                         programPacked, locationPacked, count, value)));
         if (isCallValid)
@@ -1138,7 +1168,9 @@ void GL_APIENTRY GL_ProgramUniform2i(GLuint program, GLint location, GLint v0, G
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform2i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform2i) &&
               ValidateProgramUniform2i(context, angle::EntryPoint::GLProgramUniform2i,
                                        programPacked, locationPacked, v0, v1)));
         if (isCallValid)
@@ -1172,7 +1204,9 @@ void GL_APIENTRY GL_ProgramUniform2iv(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform2iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform2iv) &&
               ValidateProgramUniform2iv(context, angle::EntryPoint::GLProgramUniform2iv,
                                         programPacked, locationPacked, count, value)));
         if (isCallValid)
@@ -1203,7 +1237,9 @@ void GL_APIENTRY GL_ProgramUniform2ui(GLuint program, GLint location, GLuint v0,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform2ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform2ui) &&
               ValidateProgramUniform2ui(context, angle::EntryPoint::GLProgramUniform2ui,
                                         programPacked, locationPacked, v0, v1)));
         if (isCallValid)
@@ -1237,7 +1273,9 @@ void GL_APIENTRY GL_ProgramUniform2uiv(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform2uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform2uiv) &&
               ValidateProgramUniform2uiv(context, angle::EntryPoint::GLProgramUniform2uiv,
                                          programPacked, locationPacked, count, value)));
         if (isCallValid)
@@ -1269,7 +1307,9 @@ GL_ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfl
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform3f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform3f) &&
               ValidateProgramUniform3f(context, angle::EntryPoint::GLProgramUniform3f,
                                        programPacked, locationPacked, v0, v1, v2)));
         if (isCallValid)
@@ -1303,7 +1343,9 @@ void GL_APIENTRY GL_ProgramUniform3fv(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform3fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform3fv) &&
               ValidateProgramUniform3fv(context, angle::EntryPoint::GLProgramUniform3fv,
                                         programPacked, locationPacked, count, value)));
         if (isCallValid)
@@ -1334,7 +1376,9 @@ void GL_APIENTRY GL_ProgramUniform3i(GLuint program, GLint location, GLint v0, G
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform3i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform3i) &&
               ValidateProgramUniform3i(context, angle::EntryPoint::GLProgramUniform3i,
                                        programPacked, locationPacked, v0, v1, v2)));
         if (isCallValid)
@@ -1368,7 +1412,9 @@ void GL_APIENTRY GL_ProgramUniform3iv(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform3iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform3iv) &&
               ValidateProgramUniform3iv(context, angle::EntryPoint::GLProgramUniform3iv,
                                         programPacked, locationPacked, count, value)));
         if (isCallValid)
@@ -1400,7 +1446,9 @@ GL_ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuin
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform3ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform3ui) &&
               ValidateProgramUniform3ui(context, angle::EntryPoint::GLProgramUniform3ui,
                                         programPacked, locationPacked, v0, v1, v2)));
         if (isCallValid)
@@ -1434,7 +1482,9 @@ void GL_APIENTRY GL_ProgramUniform3uiv(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform3uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform3uiv) &&
               ValidateProgramUniform3uiv(context, angle::EntryPoint::GLProgramUniform3uiv,
                                          programPacked, locationPacked, count, value)));
         if (isCallValid)
@@ -1466,7 +1516,9 @@ GL_ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfl
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform4f) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform4f) &&
               ValidateProgramUniform4f(context, angle::EntryPoint::GLProgramUniform4f,
                                        programPacked, locationPacked, v0, v1, v2, v3)));
         if (isCallValid)
@@ -1500,7 +1552,9 @@ void GL_APIENTRY GL_ProgramUniform4fv(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform4fv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform4fv) &&
               ValidateProgramUniform4fv(context, angle::EntryPoint::GLProgramUniform4fv,
                                         programPacked, locationPacked, count, value)));
         if (isCallValid)
@@ -1532,7 +1586,9 @@ GL_ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform4i) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform4i) &&
               ValidateProgramUniform4i(context, angle::EntryPoint::GLProgramUniform4i,
                                        programPacked, locationPacked, v0, v1, v2, v3)));
         if (isCallValid)
@@ -1566,7 +1622,9 @@ void GL_APIENTRY GL_ProgramUniform4iv(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform4iv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform4iv) &&
               ValidateProgramUniform4iv(context, angle::EntryPoint::GLProgramUniform4iv,
                                         programPacked, locationPacked, count, value)));
         if (isCallValid)
@@ -1598,7 +1656,9 @@ GL_ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuin
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform4ui) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform4ui) &&
               ValidateProgramUniform4ui(context, angle::EntryPoint::GLProgramUniform4ui,
                                         programPacked, locationPacked, v0, v1, v2, v3)));
         if (isCallValid)
@@ -1632,7 +1692,9 @@ void GL_APIENTRY GL_ProgramUniform4uiv(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramUniform4uiv) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniform4uiv) &&
               ValidateProgramUniform4uiv(context, angle::EntryPoint::GLProgramUniform4uiv,
                                          programPacked, locationPacked, count, value)));
         if (isCallValid)
@@ -1666,12 +1728,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix2fv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2fv) &&
-                             ValidateProgramUniformMatrix2fv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2fv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix2fv) &&
+              ValidateProgramUniformMatrix2fv(context, angle::EntryPoint::GLProgramUniformMatrix2fv,
+                                              programPacked, locationPacked, count, transpose,
+                                              value)));
         if (isCallValid)
         {
             context->programUniformMatrix2fv(programPacked, locationPacked, count, transpose,
@@ -1704,12 +1768,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix2x3fv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2x3fv) &&
-                             ValidateProgramUniformMatrix2x3fv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2x3fv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix2x3fv) &&
+              ValidateProgramUniformMatrix2x3fv(
+                  context, angle::EntryPoint::GLProgramUniformMatrix2x3fv, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix2x3fv(programPacked, locationPacked, count, transpose,
@@ -1742,12 +1808,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix2x4fv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2x4fv) &&
-                             ValidateProgramUniformMatrix2x4fv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2x4fv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix2x4fv) &&
+              ValidateProgramUniformMatrix2x4fv(
+                  context, angle::EntryPoint::GLProgramUniformMatrix2x4fv, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix2x4fv(programPacked, locationPacked, count, transpose,
@@ -1780,12 +1848,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix3fv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3fv) &&
-                             ValidateProgramUniformMatrix3fv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3fv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix3fv) &&
+              ValidateProgramUniformMatrix3fv(context, angle::EntryPoint::GLProgramUniformMatrix3fv,
+                                              programPacked, locationPacked, count, transpose,
+                                              value)));
         if (isCallValid)
         {
             context->programUniformMatrix3fv(programPacked, locationPacked, count, transpose,
@@ -1818,12 +1888,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix3x2fv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3x2fv) &&
-                             ValidateProgramUniformMatrix3x2fv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3x2fv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix3x2fv) &&
+              ValidateProgramUniformMatrix3x2fv(
+                  context, angle::EntryPoint::GLProgramUniformMatrix3x2fv, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix3x2fv(programPacked, locationPacked, count, transpose,
@@ -1856,12 +1928,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix3x4fv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3x4fv) &&
-                             ValidateProgramUniformMatrix3x4fv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3x4fv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix3x4fv) &&
+              ValidateProgramUniformMatrix3x4fv(
+                  context, angle::EntryPoint::GLProgramUniformMatrix3x4fv, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix3x4fv(programPacked, locationPacked, count, transpose,
@@ -1894,12 +1968,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix4fv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4fv) &&
-                             ValidateProgramUniformMatrix4fv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4fv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix4fv) &&
+              ValidateProgramUniformMatrix4fv(context, angle::EntryPoint::GLProgramUniformMatrix4fv,
+                                              programPacked, locationPacked, count, transpose,
+                                              value)));
         if (isCallValid)
         {
             context->programUniformMatrix4fv(programPacked, locationPacked, count, transpose,
@@ -1932,12 +2008,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix4x2fv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4x2fv) &&
-                             ValidateProgramUniformMatrix4x2fv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4x2fv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix4x2fv) &&
+              ValidateProgramUniformMatrix4x2fv(
+                  context, angle::EntryPoint::GLProgramUniformMatrix4x2fv, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix4x2fv(programPacked, locationPacked, count, transpose,
@@ -1970,12 +2048,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix4x3fv(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4x3fv) &&
-                             ValidateProgramUniformMatrix4x3fv(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4x3fv,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix4x3fv) &&
+              ValidateProgramUniformMatrix4x3fv(
+                  context, angle::EntryPoint::GLProgramUniformMatrix4x3fv, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix4x3fv(programPacked, locationPacked, count, transpose,
@@ -2001,8 +2081,12 @@ void GL_APIENTRY GL_SampleMaski(GLuint maskNumber, GLbitfield mask)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSampleMaski) &&
-              ValidateSampleMaski(context, angle::EntryPoint::GLSampleMaski, maskNumber, mask)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSampleMaski) &&
+              ValidateSampleMaski(context->getPrivateState(),
+                                  context->getMutableErrorSetForValidation(),
+                                  angle::EntryPoint::GLSampleMaski, maskNumber, mask)));
         if (isCallValid)
         {
             ContextPrivateSampleMaski(context->getMutablePrivateState(),
@@ -2038,7 +2122,8 @@ void GL_APIENTRY GL_TexStorage2DMultisample(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLTexStorage2DMultisample) &&
               ValidateTexStorage2DMultisample(context, angle::EntryPoint::GLTexStorage2DMultisample,
                                               targetPacked, samples, internalformat, width, height,
@@ -2072,7 +2157,9 @@ void GL_APIENTRY GL_UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLUseProgramStages) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLUseProgramStages) &&
               ValidateUseProgramStages(context, angle::EntryPoint::GLUseProgramStages,
                                        pipelinePacked, stages, programPacked)));
         if (isCallValid)
@@ -2101,7 +2188,8 @@ void GL_APIENTRY GL_ValidateProgramPipeline(GLuint pipeline)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLValidateProgramPipeline) &&
               ValidateValidateProgramPipeline(context, angle::EntryPoint::GLValidateProgramPipeline,
                                               pipelinePacked)));
@@ -2222,7 +2310,8 @@ void GL_APIENTRY GL_VertexBindingDivisor(GLuint bindingindex, GLuint divisor)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLVertexBindingDivisor) &&
               ValidateVertexBindingDivisor(context, angle::EntryPoint::GLVertexBindingDivisor,
                                            bindingindex, divisor)));
diff --git a/src/libGLESv2/entry_points_gles_3_2_autogen.cpp b/src/libGLESv2/entry_points_gles_3_2_autogen.cpp
index 104494525..1640cde1a 100644
--- a/src/libGLESv2/entry_points_gles_3_2_autogen.cpp
+++ b/src/libGLESv2/entry_points_gles_3_2_autogen.cpp
@@ -33,7 +33,9 @@ void GL_APIENTRY GL_BlendBarrier()
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBlendBarrier) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBlendBarrier) &&
               ValidateBlendBarrier(context, angle::EntryPoint::GLBlendBarrier)));
         if (isCallValid)
         {
@@ -59,8 +61,9 @@ void GL_APIENTRY GL_BlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum mo
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateBlendEquationSeparatei(context, angle::EntryPoint::GLBlendEquationSeparatei,
-                                            buf, modeRGB, modeAlpha));
+             ValidateBlendEquationSeparatei(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLBlendEquationSeparatei, buf, modeRGB, modeAlpha));
         if (isCallValid)
         {
             ContextPrivateBlendEquationSeparatei(context->getMutablePrivateState(),
@@ -84,9 +87,10 @@ void GL_APIENTRY GL_BlendEquationi(GLuint buf, GLenum mode)
 
     if (context)
     {
-        bool isCallValid =
-            (context->skipValidation() ||
-             ValidateBlendEquationi(context, angle::EntryPoint::GLBlendEquationi, buf, mode));
+        bool isCallValid = (context->skipValidation() ||
+                            ValidateBlendEquationi(context->getPrivateState(),
+                                                   context->getMutableErrorSetForValidation(),
+                                                   angle::EntryPoint::GLBlendEquationi, buf, mode));
         if (isCallValid)
         {
             ContextPrivateBlendEquationi(context->getMutablePrivateState(),
@@ -116,8 +120,9 @@ GL_BlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateBlendFuncSeparatei(context, angle::EntryPoint::GLBlendFuncSeparatei, buf,
-                                        srcRGB, dstRGB, srcAlpha, dstAlpha));
+             ValidateBlendFuncSeparatei(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLBlendFuncSeparatei, buf, srcRGB, dstRGB, srcAlpha, dstAlpha));
         if (isCallValid)
         {
             ContextPrivateBlendFuncSeparatei(context->getMutablePrivateState(),
@@ -143,9 +148,10 @@ void GL_APIENTRY GL_BlendFunci(GLuint buf, GLenum src, GLenum dst)
 
     if (context)
     {
-        bool isCallValid =
-            (context->skipValidation() ||
-             ValidateBlendFunci(context, angle::EntryPoint::GLBlendFunci, buf, src, dst));
+        bool isCallValid = (context->skipValidation() ||
+                            ValidateBlendFunci(context->getPrivateState(),
+                                               context->getMutableErrorSetForValidation(),
+                                               angle::EntryPoint::GLBlendFunci, buf, src, dst));
         if (isCallValid)
         {
             ContextPrivateBlendFunci(context->getMutablePrivateState(),
@@ -169,9 +175,10 @@ void GL_APIENTRY GL_ColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean
 
     if (context)
     {
-        bool isCallValid =
-            (context->skipValidation() ||
-             ValidateColorMaski(context, angle::EntryPoint::GLColorMaski, index, r, g, b, a));
+        bool isCallValid = (context->skipValidation() ||
+                            ValidateColorMaski(context->getPrivateState(),
+                                               context->getMutableErrorSetForValidation(),
+                                               angle::EntryPoint::GLColorMaski, index, r, g, b, a));
         if (isCallValid)
         {
             ContextPrivateColorMaski(context->getMutablePrivateState(),
@@ -217,7 +224,9 @@ void GL_APIENTRY GL_CopyImageSubData(GLuint srcName,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCopyImageSubData) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCopyImageSubData) &&
               ValidateCopyImageSubData(context, angle::EntryPoint::GLCopyImageSubData, srcName,
                                        srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget,
                                        dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth)));
@@ -346,9 +355,10 @@ void GL_APIENTRY GL_Disablei(GLenum target, GLuint index)
 
     if (context)
     {
-        bool isCallValid =
-            (context->skipValidation() ||
-             ValidateDisablei(context, angle::EntryPoint::GLDisablei, target, index));
+        bool isCallValid = (context->skipValidation() ||
+                            ValidateDisablei(context->getPrivateState(),
+                                             context->getMutableErrorSetForValidation(),
+                                             angle::EntryPoint::GLDisablei, target, index));
         if (isCallValid)
         {
             ContextPrivateDisablei(context->getMutablePrivateState(),
@@ -485,8 +495,10 @@ void GL_APIENTRY GL_Enablei(GLenum target, GLuint index)
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            ValidateEnablei(context, angle::EntryPoint::GLEnablei, target, index));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateEnablei(context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                             angle::EntryPoint::GLEnablei, target, index));
         if (isCallValid)
         {
             ContextPrivateEnablei(context->getMutablePrivateState(),
@@ -518,7 +530,9 @@ void GL_APIENTRY GL_FramebufferTexture(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFramebufferTexture) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFramebufferTexture) &&
               ValidateFramebufferTexture(context, angle::EntryPoint::GLFramebufferTexture, target,
                                          attachment, texturePacked, level)));
         if (isCallValid)
@@ -911,9 +925,10 @@ GLboolean GL_APIENTRY GL_IsEnabledi(GLenum target, GLuint index)
     GLboolean returnValue;
     if (context)
     {
-        bool isCallValid =
-            (context->skipValidation() ||
-             ValidateIsEnabledi(context, angle::EntryPoint::GLIsEnabledi, target, index));
+        bool isCallValid = (context->skipValidation() ||
+                            ValidateIsEnabledi(context->getPrivateState(),
+                                               context->getMutableErrorSetForValidation(),
+                                               angle::EntryPoint::GLIsEnabledi, target, index));
         if (isCallValid)
         {
             returnValue =
@@ -944,8 +959,12 @@ void GL_APIENTRY GL_MinSampleShading(GLfloat value)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMinSampleShading) &&
-              ValidateMinSampleShading(context, angle::EntryPoint::GLMinSampleShading, value)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMinSampleShading) &&
+              ValidateMinSampleShading(context->getPrivateState(),
+                                       context->getMutableErrorSetForValidation(),
+                                       angle::EntryPoint::GLMinSampleShading, value)));
         if (isCallValid)
         {
             ContextPrivateMinSampleShading(context->getMutablePrivateState(),
@@ -1023,9 +1042,12 @@ void GL_APIENTRY GL_PatchParameteri(GLenum pname, GLint value)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPatchParameteri) &&
-              ValidatePatchParameteri(context, angle::EntryPoint::GLPatchParameteri, pname,
-                                      value)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPatchParameteri) &&
+              ValidatePatchParameteri(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLPatchParameteri, pname, value)));
         if (isCallValid)
         {
             ContextPrivatePatchParameteri(context->getMutablePrivateState(),
@@ -1082,10 +1104,13 @@ void GL_APIENTRY GL_PrimitiveBoundingBox(GLfloat minX,
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLPrimitiveBoundingBox) &&
-              ValidatePrimitiveBoundingBox(context, angle::EntryPoint::GLPrimitiveBoundingBox, minX,
-                                           minY, minZ, minW, maxX, maxY, maxZ, maxW)));
+              ValidatePrimitiveBoundingBox(context->getPrivateState(),
+                                           context->getMutableErrorSetForValidation(),
+                                           angle::EntryPoint::GLPrimitiveBoundingBox, minX, minY,
+                                           minZ, minW, maxX, maxY, maxZ, maxW)));
         if (isCallValid)
         {
             ContextPrivatePrimitiveBoundingBox(context->getMutablePrivateState(),
@@ -1150,7 +1175,9 @@ void GL_APIENTRY GL_ReadnPixels(GLint x,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLReadnPixels) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLReadnPixels) &&
               ValidateReadnPixels(context, angle::EntryPoint::GLReadnPixels, x, y, width, height,
                                   format, type, bufSize, data)));
         if (isCallValid)
@@ -1237,7 +1264,9 @@ void GL_APIENTRY GL_TexBuffer(GLenum target, GLenum internalformat, GLuint buffe
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexBuffer) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexBuffer) &&
               ValidateTexBuffer(context, angle::EntryPoint::GLTexBuffer, targetPacked,
                                 internalformat, bufferPacked)));
         if (isCallValid)
@@ -1274,7 +1303,9 @@ void GL_APIENTRY GL_TexBufferRange(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexBufferRange) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexBufferRange) &&
               ValidateTexBufferRange(context, angle::EntryPoint::GLTexBufferRange, targetPacked,
                                      internalformat, bufferPacked, offset, size)));
         if (isCallValid)
@@ -1369,7 +1400,8 @@ void GL_APIENTRY GL_TexStorage3DMultisample(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLTexStorage3DMultisample) &&
               ValidateTexStorage3DMultisample(context, angle::EntryPoint::GLTexStorage3DMultisample,
                                               targetPacked, samples, internalformat, width, height,
diff --git a/src/libGLESv2/entry_points_gles_ext_autogen.cpp b/src/libGLESv2/entry_points_gles_ext_autogen.cpp
index fb963679c..56d549267 100644
--- a/src/libGLESv2/entry_points_gles_ext_autogen.cpp
+++ b/src/libGLESv2/entry_points_gles_ext_autogen.cpp
@@ -46,11 +46,13 @@ void GL_APIENTRY GL_BeginPerfMonitorAMD(GLuint monitor)
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLBeginPerfMonitorAMD) &&
-                             ValidateBeginPerfMonitorAMD(
-                                 context, angle::EntryPoint::GLBeginPerfMonitorAMD, monitor)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBeginPerfMonitorAMD) &&
+              ValidateBeginPerfMonitorAMD(context, angle::EntryPoint::GLBeginPerfMonitorAMD,
+                                          monitor)));
         if (isCallValid)
         {
             context->beginPerfMonitor(monitor);
@@ -99,7 +101,9 @@ void GL_APIENTRY GL_EndPerfMonitorAMD(GLuint monitor)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEndPerfMonitorAMD) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEndPerfMonitorAMD) &&
               ValidateEndPerfMonitorAMD(context, angle::EntryPoint::GLEndPerfMonitorAMD, monitor)));
         if (isCallValid)
         {
@@ -349,12 +353,14 @@ void GL_APIENTRY GL_SelectPerfMonitorCountersAMD(GLuint monitor,
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLSelectPerfMonitorCountersAMD) &&
-                             ValidateSelectPerfMonitorCountersAMD(
-                                 context, angle::EntryPoint::GLSelectPerfMonitorCountersAMD,
-                                 monitor, enable, group, numCounters, counterList)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLSelectPerfMonitorCountersAMD) &&
+              ValidateSelectPerfMonitorCountersAMD(
+                  context, angle::EntryPoint::GLSelectPerfMonitorCountersAMD, monitor, enable,
+                  group, numCounters, counterList)));
         if (isCallValid)
         {
             context->selectPerfMonitorCounters(monitor, enable, group, numCounters, counterList);
@@ -470,7 +476,8 @@ void GL_APIENTRY GL_MultiDrawArraysInstancedBaseInstanceANGLE(GLenum mode,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLMultiDrawArraysInstancedBaseInstanceANGLE) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLMultiDrawArraysInstancedBaseInstanceANGLE) &&
               ValidateMultiDrawArraysInstancedBaseInstanceANGLE(
                   context, angle::EntryPoint::GLMultiDrawArraysInstancedBaseInstanceANGLE,
                   modePacked, firsts, counts, instanceCounts, baseInstances, drawcount)));
@@ -516,7 +523,7 @@ GL_MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context,
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
                   angle::EntryPoint::GLMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE) &&
               ValidateMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(
                   context,
@@ -572,7 +579,9 @@ void GL_APIENTRY GL_CopyTexture3DANGLE(GLuint sourceId,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLCopyTexture3DANGLE) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCopyTexture3DANGLE) &&
               ValidateCopyTexture3DANGLE(
                   context, angle::EntryPoint::GLCopyTexture3DANGLE, sourceIdPacked, sourceLevel,
                   destTargetPacked, destIdPacked, destLevel, internalFormat, destType, unpackFlipY,
@@ -631,7 +640,8 @@ void GL_APIENTRY GL_CopySubTexture3DANGLE(GLuint sourceId,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCopySubTexture3DANGLE) &&
               ValidateCopySubTexture3DANGLE(context, angle::EntryPoint::GLCopySubTexture3DANGLE,
                                             sourceIdPacked, sourceLevel, destTargetPacked,
@@ -682,12 +692,14 @@ void GL_APIENTRY GL_BlitFramebufferANGLE(GLint srcX0,
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLBlitFramebufferANGLE) &&
-                             ValidateBlitFramebufferANGLE(
-                                 context, angle::EntryPoint::GLBlitFramebufferANGLE, srcX0, srcY0,
-                                 srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBlitFramebufferANGLE) &&
+              ValidateBlitFramebufferANGLE(context, angle::EntryPoint::GLBlitFramebufferANGLE,
+                                           srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
+                                           mask, filter)));
         if (isCallValid)
         {
             context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
@@ -722,7 +734,8 @@ void GL_APIENTRY GL_RenderbufferStorageMultisampleANGLE(GLenum target,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLRenderbufferStorageMultisampleANGLE) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLRenderbufferStorageMultisampleANGLE) &&
               ValidateRenderbufferStorageMultisampleANGLE(
                   context, angle::EntryPoint::GLRenderbufferStorageMultisampleANGLE, target,
                   samples, internalformat, width, height)));
@@ -1009,8 +1022,12 @@ void GL_APIENTRY GL_LogicOpANGLE(GLenum opcode)
         LogicalOperation opcodePacked = PackParam<LogicalOperation>(opcode);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLogicOpANGLE) &&
-              ValidateLogicOpANGLE(context, angle::EntryPoint::GLLogicOpANGLE, opcodePacked)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLogicOpANGLE) &&
+              ValidateLogicOpANGLE(context->getPrivateState(),
+                                   context->getMutableErrorSetForValidation(),
+                                   angle::EntryPoint::GLLogicOpANGLE, opcodePacked)));
         if (isCallValid)
         {
             ContextPrivateLogicOpANGLE(context->getMutablePrivateState(),
@@ -1054,13 +1071,15 @@ void GL_APIENTRY GL_TexStorageMemFlags2DANGLE(GLenum target,
         TextureType targetPacked    = PackParam<TextureType>(target);
         MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLTexStorageMemFlags2DANGLE) &&
-                             ValidateTexStorageMemFlags2DANGLE(
-                                 context, angle::EntryPoint::GLTexStorageMemFlags2DANGLE,
-                                 targetPacked, levels, internalFormat, width, height, memoryPacked,
-                                 offset, createFlags, usageFlags, imageCreateInfoPNext)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexStorageMemFlags2DANGLE) &&
+              ValidateTexStorageMemFlags2DANGLE(
+                  context, angle::EntryPoint::GLTexStorageMemFlags2DANGLE, targetPacked, levels,
+                  internalFormat, width, height, memoryPacked, offset, createFlags, usageFlags,
+                  imageCreateInfoPNext)));
         if (isCallValid)
         {
             context->texStorageMemFlags2D(targetPacked, levels, internalFormat, width, height,
@@ -1110,7 +1129,8 @@ void GL_APIENTRY GL_TexStorageMemFlags2DMultisampleANGLE(GLenum target,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLTexStorageMemFlags2DMultisampleANGLE) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLTexStorageMemFlags2DMultisampleANGLE) &&
               ValidateTexStorageMemFlags2DMultisampleANGLE(
                   context, angle::EntryPoint::GLTexStorageMemFlags2DMultisampleANGLE, targetPacked,
                   samples, internalFormat, width, height, fixedSampleLocations, memoryPacked,
@@ -1163,7 +1183,8 @@ void GL_APIENTRY GL_TexStorageMemFlags3DANGLE(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLTexStorageMemFlags3DANGLE) &&
               ValidateTexStorageMemFlags3DANGLE(
                   context, angle::EntryPoint::GLTexStorageMemFlags3DANGLE, targetPacked, levels,
@@ -1219,7 +1240,8 @@ void GL_APIENTRY GL_TexStorageMemFlags3DMultisampleANGLE(GLenum target,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLTexStorageMemFlags3DMultisampleANGLE) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLTexStorageMemFlags3DMultisampleANGLE) &&
               ValidateTexStorageMemFlags3DMultisampleANGLE(
                   context, angle::EntryPoint::GLTexStorageMemFlags3DMultisampleANGLE, targetPacked,
                   samples, internalFormat, width, height, depth, fixedSampleLocations, memoryPacked,
@@ -1258,12 +1280,14 @@ void GL_APIENTRY GL_ImportMemoryZirconHandleANGLE(GLuint memory,
         MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
         HandleType handleTypePacked = PackParam<HandleType>(handleType);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLImportMemoryZirconHandleANGLE) &&
-                             ValidateImportMemoryZirconHandleANGLE(
-                                 context, angle::EntryPoint::GLImportMemoryZirconHandleANGLE,
-                                 memoryPacked, size, handleTypePacked, handle)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLImportMemoryZirconHandleANGLE) &&
+              ValidateImportMemoryZirconHandleANGLE(
+                  context, angle::EntryPoint::GLImportMemoryZirconHandleANGLE, memoryPacked, size,
+                  handleTypePacked, handle)));
         if (isCallValid)
         {
             context->importMemoryZirconHandle(memoryPacked, size, handleTypePacked, handle);
@@ -1297,7 +1321,8 @@ void GL_APIENTRY GL_MultiDrawArraysANGLE(GLenum mode,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLMultiDrawArraysANGLE) &&
               ValidateMultiDrawArraysANGLE(context, angle::EntryPoint::GLMultiDrawArraysANGLE,
                                            modePacked, firsts, counts, drawcount)));
@@ -1332,12 +1357,14 @@ void GL_APIENTRY GL_MultiDrawArraysInstancedANGLE(GLenum mode,
     {
         PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLMultiDrawArraysInstancedANGLE) &&
-                             ValidateMultiDrawArraysInstancedANGLE(
-                                 context, angle::EntryPoint::GLMultiDrawArraysInstancedANGLE,
-                                 modePacked, firsts, counts, instanceCounts, drawcount)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLMultiDrawArraysInstancedANGLE) &&
+              ValidateMultiDrawArraysInstancedANGLE(
+                  context, angle::EntryPoint::GLMultiDrawArraysInstancedANGLE, modePacked, firsts,
+                  counts, instanceCounts, drawcount)));
         if (isCallValid)
         {
             context->multiDrawArraysInstanced(modePacked, firsts, counts, instanceCounts,
@@ -1373,7 +1400,8 @@ void GL_APIENTRY GL_MultiDrawElementsANGLE(GLenum mode,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLMultiDrawElementsANGLE) &&
               ValidateMultiDrawElementsANGLE(context, angle::EntryPoint::GLMultiDrawElementsANGLE,
                                              modePacked, counts, typePacked, indices, drawcount)));
@@ -1414,7 +1442,8 @@ void GL_APIENTRY GL_MultiDrawElementsInstancedANGLE(GLenum mode,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLMultiDrawElementsInstancedANGLE) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLMultiDrawElementsInstancedANGLE) &&
               ValidateMultiDrawElementsInstancedANGLE(
                   context, angle::EntryPoint::GLMultiDrawElementsInstancedANGLE, modePacked, counts,
                   typePacked, indices, instanceCounts, drawcount)));
@@ -1448,9 +1477,12 @@ void GL_APIENTRY GL_PolygonModeANGLE(GLenum face, GLenum mode)
         PolygonMode modePacked = PackParam<PolygonMode>(mode);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPolygonModeANGLE) &&
-              ValidatePolygonModeANGLE(context, angle::EntryPoint::GLPolygonModeANGLE, face,
-                                       modePacked)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPolygonModeANGLE) &&
+              ValidatePolygonModeANGLE(context->getPrivateState(),
+                                       context->getMutableErrorSetForValidation(),
+                                       angle::EntryPoint::GLPolygonModeANGLE, face, modePacked)));
         if (isCallValid)
         {
             ContextPrivatePolygonMode(context->getMutablePrivateState(),
@@ -1480,8 +1512,9 @@ void GL_APIENTRY GL_ProvokingVertexANGLE(GLenum provokeMode)
             PackParam<ProvokingVertexConvention>(provokeMode);
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateProvokingVertexANGLE(context, angle::EntryPoint::GLProvokingVertexANGLE,
-                                          provokeModePacked));
+             ValidateProvokingVertexANGLE(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLProvokingVertexANGLE, provokeModePacked));
         if (isCallValid)
         {
             ContextPrivateProvokingVertex(context->getMutablePrivateState(),
@@ -1509,11 +1542,13 @@ void GL_APIENTRY GL_RequestExtensionANGLE(const GLchar *name)
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLRequestExtensionANGLE) &&
-                             ValidateRequestExtensionANGLE(
-                                 context, angle::EntryPoint::GLRequestExtensionANGLE, name)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLRequestExtensionANGLE) &&
+              ValidateRequestExtensionANGLE(context, angle::EntryPoint::GLRequestExtensionANGLE,
+                                            name)));
         if (isCallValid)
         {
             context->requestExtension(name);
@@ -1536,11 +1571,13 @@ void GL_APIENTRY GL_DisableExtensionANGLE(const GLchar *name)
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLDisableExtensionANGLE) &&
-                             ValidateDisableExtensionANGLE(
-                                 context, angle::EntryPoint::GLDisableExtensionANGLE, name)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDisableExtensionANGLE) &&
+              ValidateDisableExtensionANGLE(context, angle::EntryPoint::GLDisableExtensionANGLE,
+                                            name)));
         if (isCallValid)
         {
             context->disableExtension(name);
@@ -2095,12 +2132,14 @@ void GL_APIENTRY GL_ReadPixelsRobustANGLE(GLint x,
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLReadPixelsRobustANGLE) &&
-                             ValidateReadPixelsRobustANGLE(
-                                 context, angle::EntryPoint::GLReadPixelsRobustANGLE, x, y, width,
-                                 height, format, type, bufSize, length, columns, rows, pixels)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLReadPixelsRobustANGLE) &&
+              ValidateReadPixelsRobustANGLE(context, angle::EntryPoint::GLReadPixelsRobustANGLE, x,
+                                            y, width, height, format, type, bufSize, length,
+                                            columns, rows, pixels)));
         if (isCallValid)
         {
             context->readPixelsRobust(x, y, width, height, format, type, bufSize, length, columns,
@@ -2141,7 +2180,8 @@ void GL_APIENTRY GL_TexImage2DRobustANGLE(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLTexImage2DRobustANGLE) &&
               ValidateTexImage2DRobustANGLE(context, angle::EntryPoint::GLTexImage2DRobustANGLE,
                                             targetPacked, level, internalformat, width, height,
@@ -2252,7 +2292,8 @@ void GL_APIENTRY GL_TexSubImage2DRobustANGLE(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLTexSubImage2DRobustANGLE) &&
               ValidateTexSubImage2DRobustANGLE(
                   context, angle::EntryPoint::GLTexSubImage2DRobustANGLE, targetPacked, level,
@@ -2299,7 +2340,8 @@ void GL_APIENTRY GL_TexImage3DRobustANGLE(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLTexImage3DRobustANGLE) &&
               ValidateTexImage3DRobustANGLE(context, angle::EntryPoint::GLTexImage3DRobustANGLE,
                                             targetPacked, level, internalformat, width, height,
@@ -2349,7 +2391,8 @@ void GL_APIENTRY GL_TexSubImage3DRobustANGLE(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLTexSubImage3DRobustANGLE) &&
               ValidateTexSubImage3DRobustANGLE(
                   context, angle::EntryPoint::GLTexSubImage3DRobustANGLE, targetPacked, level,
@@ -2395,7 +2438,8 @@ void GL_APIENTRY GL_CompressedTexImage2DRobustANGLE(GLenum target,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLCompressedTexImage2DRobustANGLE) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLCompressedTexImage2DRobustANGLE) &&
               ValidateCompressedTexImage2DRobustANGLE(
                   context, angle::EntryPoint::GLCompressedTexImage2DRobustANGLE, targetPacked,
                   level, internalformat, width, height, border, imageSize, dataSize, data)));
@@ -2439,7 +2483,8 @@ void GL_APIENTRY GL_CompressedTexSubImage2DRobustANGLE(GLenum target,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLCompressedTexSubImage2DRobustANGLE) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLCompressedTexSubImage2DRobustANGLE) &&
               ValidateCompressedTexSubImage2DRobustANGLE(
                   context, angle::EntryPoint::GLCompressedTexSubImage2DRobustANGLE, targetPacked,
                   level, xoffset, yoffset, width, height, format, imageSize, dataSize, data)));
@@ -2484,7 +2529,8 @@ void GL_APIENTRY GL_CompressedTexImage3DRobustANGLE(GLenum target,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLCompressedTexImage3DRobustANGLE) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLCompressedTexImage3DRobustANGLE) &&
               ValidateCompressedTexImage3DRobustANGLE(
                   context, angle::EntryPoint::GLCompressedTexImage3DRobustANGLE, targetPacked,
                   level, internalformat, width, height, depth, border, imageSize, dataSize, data)));
@@ -2532,7 +2578,8 @@ void GL_APIENTRY GL_CompressedTexSubImage3DRobustANGLE(GLenum target,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLCompressedTexSubImage3DRobustANGLE) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLCompressedTexSubImage3DRobustANGLE) &&
               ValidateCompressedTexSubImage3DRobustANGLE(
                   context, angle::EntryPoint::GLCompressedTexSubImage3DRobustANGLE, targetPacked,
                   level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize,
@@ -3379,12 +3426,14 @@ void GL_APIENTRY GL_ReadnPixelsRobustANGLE(GLint x,
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLReadnPixelsRobustANGLE) &&
-                             ValidateReadnPixelsRobustANGLE(
-                                 context, angle::EntryPoint::GLReadnPixelsRobustANGLE, x, y, width,
-                                 height, format, type, bufSize, length, columns, rows, data)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLReadnPixelsRobustANGLE) &&
+              ValidateReadnPixelsRobustANGLE(context, angle::EntryPoint::GLReadnPixelsRobustANGLE,
+                                             x, y, width, height, format, type, bufSize, length,
+                                             columns, rows, data)));
         if (isCallValid)
         {
             context->readnPixelsRobust(x, y, width, height, format, type, bufSize, length, columns,
@@ -3897,12 +3946,14 @@ void GL_APIENTRY GL_ImportSemaphoreZirconHandleANGLE(GLuint semaphore,
         SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore);
         HandleType handleTypePacked = PackParam<HandleType>(handleType);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLImportSemaphoreZirconHandleANGLE) &&
-                             ValidateImportSemaphoreZirconHandleANGLE(
-                                 context, angle::EntryPoint::GLImportSemaphoreZirconHandleANGLE,
-                                 semaphorePacked, handleTypePacked, handle)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLImportSemaphoreZirconHandleANGLE) &&
+              ValidateImportSemaphoreZirconHandleANGLE(
+                  context, angle::EntryPoint::GLImportSemaphoreZirconHandleANGLE, semaphorePacked,
+                  handleTypePacked, handle)));
         if (isCallValid)
         {
             context->importSemaphoreZirconHandle(semaphorePacked, handleTypePacked, handle);
@@ -3931,7 +3982,8 @@ void GL_APIENTRY GL_FramebufferMemorylessPixelLocalStorageANGLE(GLint plane, GLe
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLFramebufferMemorylessPixelLocalStorageANGLE) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLFramebufferMemorylessPixelLocalStorageANGLE) &&
               ValidateFramebufferMemorylessPixelLocalStorageANGLE(
                   context, angle::EntryPoint::GLFramebufferMemorylessPixelLocalStorageANGLE, plane,
                   internalformat)));
@@ -3966,7 +4018,8 @@ void GL_APIENTRY GL_FramebufferTexturePixelLocalStorageANGLE(GLint plane,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLFramebufferTexturePixelLocalStorageANGLE) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLFramebufferTexturePixelLocalStorageANGLE) &&
               ValidateFramebufferTexturePixelLocalStorageANGLE(
                   context, angle::EntryPoint::GLFramebufferTexturePixelLocalStorageANGLE, plane,
                   backingtexturePacked, level, layer)));
@@ -3997,7 +4050,8 @@ void GL_APIENTRY GL_FramebufferPixelLocalClearValuefvANGLE(GLint plane, const GL
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLFramebufferPixelLocalClearValuefvANGLE) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLFramebufferPixelLocalClearValuefvANGLE) &&
               ValidateFramebufferPixelLocalClearValuefvANGLE(
                   context, angle::EntryPoint::GLFramebufferPixelLocalClearValuefvANGLE, plane,
                   value)));
@@ -4028,7 +4082,8 @@ void GL_APIENTRY GL_FramebufferPixelLocalClearValueivANGLE(GLint plane, const GL
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLFramebufferPixelLocalClearValueivANGLE) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLFramebufferPixelLocalClearValueivANGLE) &&
               ValidateFramebufferPixelLocalClearValueivANGLE(
                   context, angle::EntryPoint::GLFramebufferPixelLocalClearValueivANGLE, plane,
                   value)));
@@ -4059,7 +4114,8 @@ void GL_APIENTRY GL_FramebufferPixelLocalClearValueuivANGLE(GLint plane, const G
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLFramebufferPixelLocalClearValueuivANGLE) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLFramebufferPixelLocalClearValueuivANGLE) &&
               ValidateFramebufferPixelLocalClearValueuivANGLE(
                   context, angle::EntryPoint::GLFramebufferPixelLocalClearValueuivANGLE, plane,
                   value)));
@@ -4088,7 +4144,8 @@ void GL_APIENTRY GL_BeginPixelLocalStorageANGLE(GLsizei n, const GLenum *loadops
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLBeginPixelLocalStorageANGLE) &&
               ValidateBeginPixelLocalStorageANGLE(
                   context, angle::EntryPoint::GLBeginPixelLocalStorageANGLE, n, loadops)));
@@ -4192,7 +4249,8 @@ void GL_APIENTRY GL_FramebufferPixelLocalStorageRestoreANGLE()
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLFramebufferPixelLocalStorageRestoreANGLE) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLFramebufferPixelLocalStorageRestoreANGLE) &&
               ValidateFramebufferPixelLocalStorageRestoreANGLE(
                   context, angle::EntryPoint::GLFramebufferPixelLocalStorageRestoreANGLE)));
         if (isCallValid)
@@ -4374,7 +4432,8 @@ void GL_APIENTRY GL_TexImage2DExternalANGLE(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLTexImage2DExternalANGLE) &&
               ValidateTexImage2DExternalANGLE(context, angle::EntryPoint::GLTexImage2DExternalANGLE,
                                               targetPacked, level, internalformat, width, height,
@@ -4406,7 +4465,8 @@ void GL_APIENTRY GL_InvalidateTextureANGLE(GLenum target)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLInvalidateTextureANGLE) &&
               ValidateInvalidateTextureANGLE(context, angle::EntryPoint::GLInvalidateTextureANGLE,
                                              targetPacked)));
@@ -4446,7 +4506,8 @@ void GL_APIENTRY GL_TexStorage2DMultisampleANGLE(GLenum target,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLTexStorage2DMultisampleANGLE) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLTexStorage2DMultisampleANGLE) &&
               ValidateTexStorage2DMultisampleANGLE(
                   context, angle::EntryPoint::GLTexStorage2DMultisampleANGLE, targetPacked, samples,
                   internalformat, width, height, fixedsamplelocations)));
@@ -4502,9 +4563,12 @@ void GL_APIENTRY GL_SampleMaskiANGLE(GLuint maskNumber, GLbitfield mask)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSampleMaskiANGLE) &&
-              ValidateSampleMaskiANGLE(context, angle::EntryPoint::GLSampleMaskiANGLE, maskNumber,
-                                       mask)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSampleMaskiANGLE) &&
+              ValidateSampleMaskiANGLE(context->getPrivateState(),
+                                       context->getMutableErrorSetForValidation(),
+                                       angle::EntryPoint::GLSampleMaskiANGLE, maskNumber, mask)));
         if (isCallValid)
         {
             ContextPrivateSampleMaski(context->getMutablePrivateState(),
@@ -4576,7 +4640,8 @@ void GL_APIENTRY GL_AcquireTexturesANGLE(GLuint numTextures,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLAcquireTexturesANGLE) &&
               ValidateAcquireTexturesANGLE(context, angle::EntryPoint::GLAcquireTexturesANGLE,
                                            numTextures, texturesPacked, layouts)));
@@ -4610,7 +4675,8 @@ void GL_APIENTRY GL_ReleaseTexturesANGLE(GLuint numTextures,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLReleaseTexturesANGLE) &&
               ValidateReleaseTexturesANGLE(context, angle::EntryPoint::GLReleaseTexturesANGLE,
                                            numTextures, texturesPacked, layouts)));
@@ -4660,12 +4726,14 @@ void GL_APIENTRY GL_BindUniformLocationCHROMIUM(GLuint program, GLint location,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLBindUniformLocationCHROMIUM) &&
-                             ValidateBindUniformLocationCHROMIUM(
-                                 context, angle::EntryPoint::GLBindUniformLocationCHROMIUM,
-                                 programPacked, locationPacked, name)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBindUniformLocationCHROMIUM) &&
+              ValidateBindUniformLocationCHROMIUM(context,
+                                                  angle::EntryPoint::GLBindUniformLocationCHROMIUM,
+                                                  programPacked, locationPacked, name)));
         if (isCallValid)
         {
             context->bindUniformLocation(programPacked, locationPacked, name);
@@ -4692,12 +4760,14 @@ void GL_APIENTRY GL_CompressedCopyTextureCHROMIUM(GLuint sourceId, GLuint destId
         TextureID sourceIdPacked = PackParam<TextureID>(sourceId);
         TextureID destIdPacked   = PackParam<TextureID>(destId);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLCompressedCopyTextureCHROMIUM) &&
-                             ValidateCompressedCopyTextureCHROMIUM(
-                                 context, angle::EntryPoint::GLCompressedCopyTextureCHROMIUM,
-                                 sourceIdPacked, destIdPacked)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLCompressedCopyTextureCHROMIUM) &&
+              ValidateCompressedCopyTextureCHROMIUM(
+                  context, angle::EntryPoint::GLCompressedCopyTextureCHROMIUM, sourceIdPacked,
+                  destIdPacked)));
         if (isCallValid)
         {
             context->compressedCopyTexture(sourceIdPacked, destIdPacked);
@@ -4742,7 +4812,8 @@ void GL_APIENTRY GL_CopyTextureCHROMIUM(GLuint sourceId,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCopyTextureCHROMIUM) &&
               ValidateCopyTextureCHROMIUM(
                   context, angle::EntryPoint::GLCopyTextureCHROMIUM, sourceIdPacked, sourceLevel,
@@ -4797,7 +4868,8 @@ void GL_APIENTRY GL_CopySubTextureCHROMIUM(GLuint sourceId,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCopySubTextureCHROMIUM) &&
               ValidateCopySubTextureCHROMIUM(
                   context, angle::EntryPoint::GLCopySubTextureCHROMIUM, sourceIdPacked, sourceLevel,
@@ -4831,10 +4903,12 @@ void GL_APIENTRY GL_CoverageModulationCHROMIUM(GLenum components)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCoverageModulationCHROMIUM) &&
               ValidateCoverageModulationCHROMIUM(
-                  context, angle::EntryPoint::GLCoverageModulationCHROMIUM, components)));
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLCoverageModulationCHROMIUM, components)));
         if (isCallValid)
         {
             ContextPrivateCoverageModulation(context->getMutablePrivateState(),
@@ -4864,7 +4938,8 @@ void GL_APIENTRY GL_LoseContextCHROMIUM(GLenum current, GLenum other)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLLoseContextCHROMIUM) &&
               ValidateLoseContextCHROMIUM(context, angle::EntryPoint::GLLoseContextCHROMIUM,
                                           currentPacked, otherPacked)));
@@ -4898,12 +4973,14 @@ void GL_APIENTRY GL_EGLImageTargetTexStorageEXT(GLenum target,
     {
         egl::ImageID imagePacked = PackParam<egl::ImageID>(image);
         SCOPED_EGL_IMAGE_SHARE_CONTEXT_LOCK(context, imagePacked);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLEGLImageTargetTexStorageEXT) &&
-                             ValidateEGLImageTargetTexStorageEXT(
-                                 context, angle::EntryPoint::GLEGLImageTargetTexStorageEXT, target,
-                                 imagePacked, attrib_list)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEGLImageTargetTexStorageEXT) &&
+              ValidateEGLImageTargetTexStorageEXT(context,
+                                                  angle::EntryPoint::GLEGLImageTargetTexStorageEXT,
+                                                  target, imagePacked, attrib_list)));
         if (isCallValid)
         {
             context->eGLImageTargetTexStorage(target, imagePacked, attrib_list);
@@ -4931,12 +5008,14 @@ void GL_APIENTRY GL_EGLImageTargetTextureStorageEXT(GLuint texture,
     {
         egl::ImageID imagePacked = PackParam<egl::ImageID>(image);
         SCOPED_EGL_IMAGE_SHARE_CONTEXT_LOCK(context, imagePacked);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLEGLImageTargetTextureStorageEXT) &&
-                             ValidateEGLImageTargetTextureStorageEXT(
-                                 context, angle::EntryPoint::GLEGLImageTargetTextureStorageEXT,
-                                 texture, imagePacked, attrib_list)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLEGLImageTargetTextureStorageEXT) &&
+              ValidateEGLImageTargetTextureStorageEXT(
+                  context, angle::EntryPoint::GLEGLImageTargetTextureStorageEXT, texture,
+                  imagePacked, attrib_list)));
         if (isCallValid)
         {
             context->eGLImageTargetTextureStorage(texture, imagePacked, attrib_list);
@@ -5085,7 +5164,8 @@ void GL_APIENTRY GL_BindFragDataLocationEXT(GLuint program, GLuint color, const
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLBindFragDataLocationEXT) &&
               ValidateBindFragDataLocationEXT(context, angle::EntryPoint::GLBindFragDataLocationEXT,
                                               programPacked, color, name)));
@@ -5116,12 +5196,14 @@ void GL_APIENTRY GL_BindFragDataLocationIndexedEXT(GLuint program,
     {
         ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLBindFragDataLocationIndexedEXT) &&
-                             ValidateBindFragDataLocationIndexedEXT(
-                                 context, angle::EntryPoint::GLBindFragDataLocationIndexedEXT,
-                                 programPacked, colorNumber, index, name)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLBindFragDataLocationIndexedEXT) &&
+              ValidateBindFragDataLocationIndexedEXT(
+                  context, angle::EntryPoint::GLBindFragDataLocationIndexedEXT, programPacked,
+                  colorNumber, index, name)));
         if (isCallValid)
         {
             context->bindFragDataLocationIndexed(programPacked, colorNumber, index, name);
@@ -5235,7 +5317,9 @@ void GL_APIENTRY GL_BufferStorageEXT(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBufferStorageEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBufferStorageEXT) &&
               ValidateBufferStorageEXT(context, angle::EntryPoint::GLBufferStorageEXT, targetPacked,
                                        size, data, flags)));
         if (isCallValid)
@@ -5262,9 +5346,11 @@ void GL_APIENTRY GL_ClipControlEXT(GLenum origin, GLenum depth)
     {
         ClipOrigin originPacked   = PackParam<ClipOrigin>(origin);
         ClipDepthMode depthPacked = PackParam<ClipDepthMode>(depth);
-        bool isCallValid          = (context->skipValidation() ||
-                            ValidateClipControlEXT(context, angle::EntryPoint::GLClipControlEXT,
-                                                            originPacked, depthPacked));
+        bool isCallValid =
+            (context->skipValidation() ||
+             ValidateClipControlEXT(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLClipControlEXT, originPacked, depthPacked));
         if (isCallValid)
         {
             ContextPrivateClipControl(context->getMutablePrivateState(),
@@ -5318,13 +5404,15 @@ void GL_APIENTRY GL_CopyImageSubDataEXT(GLuint srcName,
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLCopyImageSubDataEXT) &&
-                             ValidateCopyImageSubDataEXT(
-                                 context, angle::EntryPoint::GLCopyImageSubDataEXT, srcName,
-                                 srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget,
-                                 dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCopyImageSubDataEXT) &&
+              ValidateCopyImageSubDataEXT(context, angle::EntryPoint::GLCopyImageSubDataEXT,
+                                          srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
+                                          dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth,
+                                          srcHeight, srcDepth)));
         if (isCallValid)
         {
             context->copyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
@@ -5386,7 +5474,9 @@ void GL_APIENTRY GL_LabelObjectEXT(GLenum type, GLuint object, GLsizei length, c
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLLabelObjectEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLLabelObjectEXT) &&
               ValidateLabelObjectEXT(context, angle::EntryPoint::GLLabelObjectEXT, type, object,
                                      length, label)));
         if (isCallValid)
@@ -5416,7 +5506,8 @@ void GL_APIENTRY GL_InsertEventMarkerEXT(GLsizei length, const GLchar *marker)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLInsertEventMarkerEXT) &&
               ValidateInsertEventMarkerEXT(context, angle::EntryPoint::GLInsertEventMarkerEXT,
                                            length, marker)));
@@ -5445,7 +5536,9 @@ void GL_APIENTRY GL_PopGroupMarkerEXT()
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPopGroupMarkerEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPopGroupMarkerEXT) &&
               ValidatePopGroupMarkerEXT(context, angle::EntryPoint::GLPopGroupMarkerEXT)));
         if (isCallValid)
         {
@@ -5473,7 +5566,9 @@ void GL_APIENTRY GL_PushGroupMarkerEXT(GLsizei length, const GLchar *marker)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPushGroupMarkerEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPushGroupMarkerEXT) &&
               ValidatePushGroupMarkerEXT(context, angle::EntryPoint::GLPushGroupMarkerEXT, length,
                                          marker)));
         if (isCallValid)
@@ -5507,7 +5602,8 @@ void GL_APIENTRY GL_DiscardFramebufferEXT(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLDiscardFramebufferEXT) &&
               ValidateDiscardFramebufferEXT(context, angle::EntryPoint::GLDiscardFramebufferEXT,
                                             target, numAttachments, attachments)));
@@ -5539,7 +5635,9 @@ void GL_APIENTRY GL_BeginQueryEXT(GLenum target, GLuint id)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBeginQueryEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBeginQueryEXT) &&
               ValidateBeginQueryEXT(context, angle::EntryPoint::GLBeginQueryEXT, targetPacked,
                                     idPacked)));
         if (isCallValid)
@@ -5593,7 +5691,9 @@ void GL_APIENTRY GL_EndQueryEXT(GLenum target)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLEndQueryEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEndQueryEXT) &&
               ValidateEndQueryEXT(context, angle::EntryPoint::GLEndQueryEXT, targetPacked)));
         if (isCallValid)
         {
@@ -5841,7 +5941,9 @@ void GL_APIENTRY GL_QueryCounterEXT(GLuint id, GLenum target)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLQueryCounterEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLQueryCounterEXT) &&
               ValidateQueryCounterEXT(context, angle::EntryPoint::GLQueryCounterEXT, idPacked,
                                       targetPacked)));
         if (isCallValid)
@@ -5869,7 +5971,9 @@ void GL_APIENTRY GL_DrawBuffersEXT(GLsizei n, const GLenum *bufs)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDrawBuffersEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDrawBuffersEXT) &&
               ValidateDrawBuffersEXT(context, angle::EntryPoint::GLDrawBuffersEXT, n, bufs)));
         if (isCallValid)
         {
@@ -5898,7 +6002,8 @@ void GL_APIENTRY GL_BlendEquationSeparateiEXT(GLuint buf, GLenum modeRGB, GLenum
         bool isCallValid =
             (context->skipValidation() ||
              ValidateBlendEquationSeparateiEXT(
-                 context, angle::EntryPoint::GLBlendEquationSeparateiEXT, buf, modeRGB, modeAlpha));
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLBlendEquationSeparateiEXT, buf, modeRGB, modeAlpha));
         if (isCallValid)
         {
             ContextPrivateBlendEquationSeparatei(context->getMutablePrivateState(),
@@ -5924,7 +6029,9 @@ void GL_APIENTRY GL_BlendEquationiEXT(GLuint buf, GLenum mode)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateBlendEquationiEXT(context, angle::EntryPoint::GLBlendEquationiEXT, buf, mode));
+             ValidateBlendEquationiEXT(context->getPrivateState(),
+                                       context->getMutableErrorSetForValidation(),
+                                       angle::EntryPoint::GLBlendEquationiEXT, buf, mode));
         if (isCallValid)
         {
             ContextPrivateBlendEquationi(context->getMutablePrivateState(),
@@ -5954,8 +6061,10 @@ GL_BlendFuncSeparateiEXT(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlp
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateBlendFuncSeparateiEXT(context, angle::EntryPoint::GLBlendFuncSeparateiEXT, buf,
-                                           srcRGB, dstRGB, srcAlpha, dstAlpha));
+             ValidateBlendFuncSeparateiEXT(context->getPrivateState(),
+                                           context->getMutableErrorSetForValidation(),
+                                           angle::EntryPoint::GLBlendFuncSeparateiEXT, buf, srcRGB,
+                                           dstRGB, srcAlpha, dstAlpha));
         if (isCallValid)
         {
             ContextPrivateBlendFuncSeparatei(context->getMutablePrivateState(),
@@ -5983,7 +6092,9 @@ void GL_APIENTRY GL_BlendFunciEXT(GLuint buf, GLenum src, GLenum dst)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateBlendFunciEXT(context, angle::EntryPoint::GLBlendFunciEXT, buf, src, dst));
+             ValidateBlendFunciEXT(context->getPrivateState(),
+                                   context->getMutableErrorSetForValidation(),
+                                   angle::EntryPoint::GLBlendFunciEXT, buf, src, dst));
         if (isCallValid)
         {
             ContextPrivateBlendFunci(context->getMutablePrivateState(),
@@ -6009,7 +6120,9 @@ void GL_APIENTRY GL_ColorMaskiEXT(GLuint index, GLboolean r, GLboolean g, GLbool
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateColorMaskiEXT(context, angle::EntryPoint::GLColorMaskiEXT, index, r, g, b, a));
+             ValidateColorMaskiEXT(context->getPrivateState(),
+                                   context->getMutableErrorSetForValidation(),
+                                   angle::EntryPoint::GLColorMaskiEXT, index, r, g, b, a));
         if (isCallValid)
         {
             ContextPrivateColorMaski(context->getMutablePrivateState(),
@@ -6032,9 +6145,10 @@ void GL_APIENTRY GL_DisableiEXT(GLenum target, GLuint index)
 
     if (context)
     {
-        bool isCallValid =
-            (context->skipValidation() ||
-             ValidateDisableiEXT(context, angle::EntryPoint::GLDisableiEXT, target, index));
+        bool isCallValid = (context->skipValidation() ||
+                            ValidateDisableiEXT(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDisableiEXT, target, index));
         if (isCallValid)
         {
             ContextPrivateDisablei(context->getMutablePrivateState(),
@@ -6057,9 +6171,10 @@ void GL_APIENTRY GL_EnableiEXT(GLenum target, GLuint index)
 
     if (context)
     {
-        bool isCallValid =
-            (context->skipValidation() ||
-             ValidateEnableiEXT(context, angle::EntryPoint::GLEnableiEXT, target, index));
+        bool isCallValid = (context->skipValidation() ||
+                            ValidateEnableiEXT(context->getPrivateState(),
+                                               context->getMutableErrorSetForValidation(),
+                                               angle::EntryPoint::GLEnableiEXT, target, index));
         if (isCallValid)
         {
             ContextPrivateEnablei(context->getMutablePrivateState(),
@@ -6085,7 +6200,9 @@ GLboolean GL_APIENTRY GL_IsEnablediEXT(GLenum target, GLuint index)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateIsEnablediEXT(context, angle::EntryPoint::GLIsEnablediEXT, target, index));
+             ValidateIsEnablediEXT(context->getPrivateState(),
+                                   context->getMutableErrorSetForValidation(),
+                                   angle::EntryPoint::GLIsEnablediEXT, target, index));
         if (isCallValid)
         {
             returnValue =
@@ -6242,12 +6359,14 @@ void GL_APIENTRY GL_MultiDrawElementsBaseVertexEXT(GLenum mode,
         PrimitiveMode modePacked    = PackParam<PrimitiveMode>(mode);
         DrawElementsType typePacked = PackParam<DrawElementsType>(type);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLMultiDrawElementsBaseVertexEXT) &&
-                             ValidateMultiDrawElementsBaseVertexEXT(
-                                 context, angle::EntryPoint::GLMultiDrawElementsBaseVertexEXT,
-                                 modePacked, count, typePacked, indices, drawcount, basevertex)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLMultiDrawElementsBaseVertexEXT) &&
+              ValidateMultiDrawElementsBaseVertexEXT(
+                  context, angle::EntryPoint::GLMultiDrawElementsBaseVertexEXT, modePacked, count,
+                  typePacked, indices, drawcount, basevertex)));
         if (isCallValid)
         {
             context->multiDrawElementsBaseVertex(modePacked, count, typePacked, indices, drawcount,
@@ -6282,12 +6401,14 @@ void GL_APIENTRY GL_BufferStorageExternalEXT(GLenum target,
     {
         BufferBinding targetPacked = PackParam<BufferBinding>(target);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLBufferStorageExternalEXT) &&
-                             ValidateBufferStorageExternalEXT(
-                                 context, angle::EntryPoint::GLBufferStorageExternalEXT,
-                                 targetPacked, offset, size, clientBuffer, flags)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBufferStorageExternalEXT) &&
+              ValidateBufferStorageExternalEXT(context,
+                                               angle::EntryPoint::GLBufferStorageExternalEXT,
+                                               targetPacked, offset, size, clientBuffer, flags)));
         if (isCallValid)
         {
             context->bufferStorageExternal(targetPacked, offset, size, clientBuffer, flags);
@@ -6319,12 +6440,14 @@ void GL_APIENTRY GL_NamedBufferStorageExternalEXT(GLuint buffer,
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLNamedBufferStorageExternalEXT) &&
-                             ValidateNamedBufferStorageExternalEXT(
-                                 context, angle::EntryPoint::GLNamedBufferStorageExternalEXT,
-                                 buffer, offset, size, clientBuffer, flags)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLNamedBufferStorageExternalEXT) &&
+              ValidateNamedBufferStorageExternalEXT(
+                  context, angle::EntryPoint::GLNamedBufferStorageExternalEXT, buffer, offset, size,
+                  clientBuffer, flags)));
         if (isCallValid)
         {
             context->namedBufferStorageExternal(buffer, offset, size, clientBuffer, flags);
@@ -6359,7 +6482,8 @@ void GL_APIENTRY GL_FramebufferTextureEXT(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLFramebufferTextureEXT) &&
               ValidateFramebufferTextureEXT(context, angle::EntryPoint::GLFramebufferTextureEXT,
                                             target, attachment, texturePacked, level)));
@@ -6487,12 +6611,14 @@ void GL_APIENTRY GL_FlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GL
     {
         BufferBinding targetPacked = PackParam<BufferBinding>(target);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLFlushMappedBufferRangeEXT) &&
-                             ValidateFlushMappedBufferRangeEXT(
-                                 context, angle::EntryPoint::GLFlushMappedBufferRangeEXT,
-                                 targetPacked, offset, length)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFlushMappedBufferRangeEXT) &&
+              ValidateFlushMappedBufferRangeEXT(context,
+                                                angle::EntryPoint::GLFlushMappedBufferRangeEXT,
+                                                targetPacked, offset, length)));
         if (isCallValid)
         {
             context->flushMappedBufferRange(targetPacked, offset, length);
@@ -6526,7 +6652,9 @@ void *GL_APIENTRY GL_MapBufferRangeEXT(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMapBufferRangeEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMapBufferRangeEXT) &&
               ValidateMapBufferRangeEXT(context, angle::EntryPoint::GLMapBufferRangeEXT,
                                         targetPacked, offset, length, access)));
         if (isCallValid)
@@ -6568,7 +6696,8 @@ void GL_APIENTRY GL_BufferStorageMemEXT(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLBufferStorageMemEXT) &&
               ValidateBufferStorageMemEXT(context, angle::EntryPoint::GLBufferStorageMemEXT,
                                           targetPacked, size, memoryPacked, offset)));
@@ -6599,7 +6728,8 @@ void GL_APIENTRY GL_CreateMemoryObjectsEXT(GLsizei n, GLuint *memoryObjects)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCreateMemoryObjectsEXT) &&
               ValidateCreateMemoryObjectsEXT(context, angle::EntryPoint::GLCreateMemoryObjectsEXT,
                                              n, memoryObjectsPacked)));
@@ -6776,12 +6906,14 @@ void GL_APIENTRY GL_MemoryObjectParameterivEXT(GLuint memoryObject,
     {
         MemoryObjectID memoryObjectPacked = PackParam<MemoryObjectID>(memoryObject);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLMemoryObjectParameterivEXT) &&
-                             ValidateMemoryObjectParameterivEXT(
-                                 context, angle::EntryPoint::GLMemoryObjectParameterivEXT,
-                                 memoryObjectPacked, pname, params)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMemoryObjectParameterivEXT) &&
+              ValidateMemoryObjectParameterivEXT(context,
+                                                 angle::EntryPoint::GLMemoryObjectParameterivEXT,
+                                                 memoryObjectPacked, pname, params)));
         if (isCallValid)
         {
             context->memoryObjectParameteriv(memoryObjectPacked, pname, params);
@@ -6819,7 +6951,9 @@ void GL_APIENTRY GL_TexStorageMem2DEXT(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexStorageMem2DEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexStorageMem2DEXT) &&
               ValidateTexStorageMem2DEXT(context, angle::EntryPoint::GLTexStorageMem2DEXT,
                                          targetPacked, levels, internalFormat, width, height,
                                          memoryPacked, offset)));
@@ -6860,13 +6994,15 @@ void GL_APIENTRY GL_TexStorageMem2DMultisampleEXT(GLenum target,
         TextureType targetPacked    = PackParam<TextureType>(target);
         MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLTexStorageMem2DMultisampleEXT) &&
-                             ValidateTexStorageMem2DMultisampleEXT(
-                                 context, angle::EntryPoint::GLTexStorageMem2DMultisampleEXT,
-                                 targetPacked, samples, internalFormat, width, height,
-                                 fixedSampleLocations, memoryPacked, offset)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLTexStorageMem2DMultisampleEXT) &&
+              ValidateTexStorageMem2DMultisampleEXT(
+                  context, angle::EntryPoint::GLTexStorageMem2DMultisampleEXT, targetPacked,
+                  samples, internalFormat, width, height, fixedSampleLocations, memoryPacked,
+                  offset)));
         if (isCallValid)
         {
             context->texStorageMem2DMultisample(targetPacked, samples, internalFormat, width,
@@ -6906,7 +7042,9 @@ void GL_APIENTRY GL_TexStorageMem3DEXT(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexStorageMem3DEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexStorageMem3DEXT) &&
               ValidateTexStorageMem3DEXT(context, angle::EntryPoint::GLTexStorageMem3DEXT,
                                          targetPacked, levels, internalFormat, width, height, depth,
                                          memoryPacked, offset)));
@@ -6948,13 +7086,15 @@ void GL_APIENTRY GL_TexStorageMem3DMultisampleEXT(GLenum target,
         TextureType targetPacked    = PackParam<TextureType>(target);
         MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLTexStorageMem3DMultisampleEXT) &&
-                             ValidateTexStorageMem3DMultisampleEXT(
-                                 context, angle::EntryPoint::GLTexStorageMem3DMultisampleEXT,
-                                 targetPacked, samples, internalFormat, width, height, depth,
-                                 fixedSampleLocations, memoryPacked, offset)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLTexStorageMem3DMultisampleEXT) &&
+              ValidateTexStorageMem3DMultisampleEXT(
+                  context, angle::EntryPoint::GLTexStorageMem3DMultisampleEXT, targetPacked,
+                  samples, internalFormat, width, height, depth, fixedSampleLocations, memoryPacked,
+                  offset)));
         if (isCallValid)
         {
             context->texStorageMem3DMultisample(targetPacked, samples, internalFormat, width,
@@ -6988,7 +7128,9 @@ void GL_APIENTRY GL_ImportMemoryFdEXT(GLuint memory, GLuint64 size, GLenum handl
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLImportMemoryFdEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLImportMemoryFdEXT) &&
               ValidateImportMemoryFdEXT(context, angle::EntryPoint::GLImportMemoryFdEXT,
                                         memoryPacked, size, handleTypePacked, fd)));
         if (isCallValid)
@@ -7021,12 +7163,14 @@ void GL_APIENTRY GL_MultiDrawArraysIndirectEXT(GLenum mode,
     {
         PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLMultiDrawArraysIndirectEXT) &&
-                             ValidateMultiDrawArraysIndirectEXT(
-                                 context, angle::EntryPoint::GLMultiDrawArraysIndirectEXT,
-                                 modePacked, indirect, drawcount, stride)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMultiDrawArraysIndirectEXT) &&
+              ValidateMultiDrawArraysIndirectEXT(context,
+                                                 angle::EntryPoint::GLMultiDrawArraysIndirectEXT,
+                                                 modePacked, indirect, drawcount, stride)));
         if (isCallValid)
         {
             context->multiDrawArraysIndirect(modePacked, indirect, drawcount, stride);
@@ -7059,12 +7203,14 @@ void GL_APIENTRY GL_MultiDrawElementsIndirectEXT(GLenum mode,
         PrimitiveMode modePacked    = PackParam<PrimitiveMode>(mode);
         DrawElementsType typePacked = PackParam<DrawElementsType>(type);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLMultiDrawElementsIndirectEXT) &&
-                             ValidateMultiDrawElementsIndirectEXT(
-                                 context, angle::EntryPoint::GLMultiDrawElementsIndirectEXT,
-                                 modePacked, typePacked, indirect, drawcount, stride)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLMultiDrawElementsIndirectEXT) &&
+              ValidateMultiDrawElementsIndirectEXT(
+                  context, angle::EntryPoint::GLMultiDrawElementsIndirectEXT, modePacked,
+                  typePacked, indirect, drawcount, stride)));
         if (isCallValid)
         {
             context->multiDrawElementsIndirect(modePacked, typePacked, indirect, drawcount, stride);
@@ -7103,7 +7249,8 @@ void GL_APIENTRY GL_FramebufferTexture2DMultisampleEXT(GLenum target,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLFramebufferTexture2DMultisampleEXT) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLFramebufferTexture2DMultisampleEXT) &&
               ValidateFramebufferTexture2DMultisampleEXT(
                   context, angle::EntryPoint::GLFramebufferTexture2DMultisampleEXT, target,
                   attachment, textargetPacked, texturePacked, level, samples)));
@@ -7137,12 +7284,14 @@ void GL_APIENTRY GL_RenderbufferStorageMultisampleEXT(GLenum target,
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLRenderbufferStorageMultisampleEXT) &&
-                             ValidateRenderbufferStorageMultisampleEXT(
-                                 context, angle::EntryPoint::GLRenderbufferStorageMultisampleEXT,
-                                 target, samples, internalformat, width, height)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLRenderbufferStorageMultisampleEXT) &&
+              ValidateRenderbufferStorageMultisampleEXT(
+                  context, angle::EntryPoint::GLRenderbufferStorageMultisampleEXT, target, samples,
+                  internalformat, width, height)));
         if (isCallValid)
         {
             context->renderbufferStorageMultisampleEXT(target, samples, internalformat, width,
@@ -7186,8 +7335,9 @@ void GL_APIENTRY GL_PolygonOffsetClampEXT(GLfloat factor, GLfloat units, GLfloat
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidatePolygonOffsetClampEXT(context, angle::EntryPoint::GLPolygonOffsetClampEXT,
-                                           factor, units, clamp));
+             ValidatePolygonOffsetClampEXT(
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLPolygonOffsetClampEXT, factor, units, clamp));
         if (isCallValid)
         {
             ContextPrivatePolygonOffsetClamp(context->getMutablePrivateState(),
@@ -7223,10 +7373,13 @@ void GL_APIENTRY GL_PrimitiveBoundingBoxEXT(GLfloat minX,
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLPrimitiveBoundingBoxEXT) &&
-              ValidatePrimitiveBoundingBoxEXT(context, angle::EntryPoint::GLPrimitiveBoundingBoxEXT,
-                                              minX, minY, minZ, minW, maxX, maxY, maxZ, maxW)));
+              ValidatePrimitiveBoundingBoxEXT(context->getPrivateState(),
+                                              context->getMutableErrorSetForValidation(),
+                                              angle::EntryPoint::GLPrimitiveBoundingBoxEXT, minX,
+                                              minY, minZ, minW, maxX, maxY, maxZ, maxW)));
         if (isCallValid)
         {
             ContextPrivatePrimitiveBoundingBox(context->getMutablePrivateState(),
@@ -7369,7 +7522,9 @@ void GL_APIENTRY GL_ReadnPixelsEXT(GLint x,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLReadnPixelsEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLReadnPixelsEXT) &&
               ValidateReadnPixelsEXT(context, angle::EntryPoint::GLReadnPixelsEXT, x, y, width,
                                      height, format, type, bufSize, data)));
         if (isCallValid)
@@ -7518,12 +7673,14 @@ void GL_APIENTRY GL_SemaphoreParameterui64vEXT(GLuint semaphore,
     {
         SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLSemaphoreParameterui64vEXT) &&
-                             ValidateSemaphoreParameterui64vEXT(
-                                 context, angle::EntryPoint::GLSemaphoreParameterui64vEXT,
-                                 semaphorePacked, pname, params)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSemaphoreParameterui64vEXT) &&
+              ValidateSemaphoreParameterui64vEXT(context,
+                                                 angle::EntryPoint::GLSemaphoreParameterui64vEXT,
+                                                 semaphorePacked, pname, params)));
         if (isCallValid)
         {
             context->semaphoreParameterui64v(semaphorePacked, pname, params);
@@ -7560,7 +7717,9 @@ void GL_APIENTRY GL_SignalSemaphoreEXT(GLuint semaphore,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSignalSemaphoreEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSignalSemaphoreEXT) &&
               ValidateSignalSemaphoreEXT(context, angle::EntryPoint::GLSignalSemaphoreEXT,
                                          semaphorePacked, numBufferBarriers, buffersPacked,
                                          numTextureBarriers, texturesPacked, dstLayouts)));
@@ -7602,7 +7761,9 @@ void GL_APIENTRY GL_WaitSemaphoreEXT(GLuint semaphore,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWaitSemaphoreEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWaitSemaphoreEXT) &&
               ValidateWaitSemaphoreEXT(context, angle::EntryPoint::GLWaitSemaphoreEXT,
                                        semaphorePacked, numBufferBarriers, buffersPacked,
                                        numTextureBarriers, texturesPacked, srcLayouts)));
@@ -7639,7 +7800,8 @@ void GL_APIENTRY GL_ImportSemaphoreFdEXT(GLuint semaphore, GLenum handleType, GL
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLImportSemaphoreFdEXT) &&
               ValidateImportSemaphoreFdEXT(context, angle::EntryPoint::GLImportSemaphoreFdEXT,
                                            semaphorePacked, handleTypePacked, fd)));
@@ -7671,7 +7833,8 @@ void GL_APIENTRY GL_ActiveShaderProgramEXT(GLuint pipeline, GLuint program)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLActiveShaderProgramEXT) &&
               ValidateActiveShaderProgramEXT(context, angle::EntryPoint::GLActiveShaderProgramEXT,
                                              pipelinePacked, programPacked)));
@@ -7700,7 +7863,8 @@ void GL_APIENTRY GL_BindProgramPipelineEXT(GLuint pipeline)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLBindProgramPipelineEXT) &&
               ValidateBindProgramPipelineEXT(context, angle::EntryPoint::GLBindProgramPipelineEXT,
                                              pipelinePacked)));
@@ -7731,7 +7895,8 @@ GLuint GL_APIENTRY GL_CreateShaderProgramvEXT(GLenum type, GLsizei count, const
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCreateShaderProgramvEXT) &&
               ValidateCreateShaderProgramvEXT(context, angle::EntryPoint::GLCreateShaderProgramvEXT,
                                               typePacked, count, strings)));
@@ -7919,7 +8084,8 @@ void GL_APIENTRY GL_ProgramParameteriEXT(GLuint program, GLenum pname, GLint val
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramParameteriEXT) &&
               ValidateProgramParameteriEXT(context, angle::EntryPoint::GLProgramParameteriEXT,
                                            programPacked, pname, value)));
@@ -7949,7 +8115,8 @@ void GL_APIENTRY GL_ProgramUniform1fEXT(GLuint program, GLint location, GLfloat
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform1fEXT) &&
               ValidateProgramUniform1fEXT(context, angle::EntryPoint::GLProgramUniform1fEXT,
                                           programPacked, locationPacked, v0)));
@@ -7984,7 +8151,8 @@ void GL_APIENTRY GL_ProgramUniform1fvEXT(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform1fvEXT) &&
               ValidateProgramUniform1fvEXT(context, angle::EntryPoint::GLProgramUniform1fvEXT,
                                            programPacked, locationPacked, count, value)));
@@ -8015,7 +8183,8 @@ void GL_APIENTRY GL_ProgramUniform1iEXT(GLuint program, GLint location, GLint v0
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform1iEXT) &&
               ValidateProgramUniform1iEXT(context, angle::EntryPoint::GLProgramUniform1iEXT,
                                           programPacked, locationPacked, v0)));
@@ -8050,7 +8219,8 @@ void GL_APIENTRY GL_ProgramUniform1ivEXT(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform1ivEXT) &&
               ValidateProgramUniform1ivEXT(context, angle::EntryPoint::GLProgramUniform1ivEXT,
                                            programPacked, locationPacked, count, value)));
@@ -8081,7 +8251,8 @@ void GL_APIENTRY GL_ProgramUniform1uiEXT(GLuint program, GLint location, GLuint
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform1uiEXT) &&
               ValidateProgramUniform1uiEXT(context, angle::EntryPoint::GLProgramUniform1uiEXT,
                                            programPacked, locationPacked, v0)));
@@ -8116,7 +8287,8 @@ void GL_APIENTRY GL_ProgramUniform1uivEXT(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform1uivEXT) &&
               ValidateProgramUniform1uivEXT(context, angle::EntryPoint::GLProgramUniform1uivEXT,
                                             programPacked, locationPacked, count, value)));
@@ -8148,7 +8320,8 @@ void GL_APIENTRY GL_ProgramUniform2fEXT(GLuint program, GLint location, GLfloat
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform2fEXT) &&
               ValidateProgramUniform2fEXT(context, angle::EntryPoint::GLProgramUniform2fEXT,
                                           programPacked, locationPacked, v0, v1)));
@@ -8183,7 +8356,8 @@ void GL_APIENTRY GL_ProgramUniform2fvEXT(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform2fvEXT) &&
               ValidateProgramUniform2fvEXT(context, angle::EntryPoint::GLProgramUniform2fvEXT,
                                            programPacked, locationPacked, count, value)));
@@ -8215,7 +8389,8 @@ void GL_APIENTRY GL_ProgramUniform2iEXT(GLuint program, GLint location, GLint v0
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform2iEXT) &&
               ValidateProgramUniform2iEXT(context, angle::EntryPoint::GLProgramUniform2iEXT,
                                           programPacked, locationPacked, v0, v1)));
@@ -8250,7 +8425,8 @@ void GL_APIENTRY GL_ProgramUniform2ivEXT(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform2ivEXT) &&
               ValidateProgramUniform2ivEXT(context, angle::EntryPoint::GLProgramUniform2ivEXT,
                                            programPacked, locationPacked, count, value)));
@@ -8282,7 +8458,8 @@ void GL_APIENTRY GL_ProgramUniform2uiEXT(GLuint program, GLint location, GLuint
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform2uiEXT) &&
               ValidateProgramUniform2uiEXT(context, angle::EntryPoint::GLProgramUniform2uiEXT,
                                            programPacked, locationPacked, v0, v1)));
@@ -8317,7 +8494,8 @@ void GL_APIENTRY GL_ProgramUniform2uivEXT(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform2uivEXT) &&
               ValidateProgramUniform2uivEXT(context, angle::EntryPoint::GLProgramUniform2uivEXT,
                                             programPacked, locationPacked, count, value)));
@@ -8350,7 +8528,8 @@ GL_ProgramUniform3fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, G
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform3fEXT) &&
               ValidateProgramUniform3fEXT(context, angle::EntryPoint::GLProgramUniform3fEXT,
                                           programPacked, locationPacked, v0, v1, v2)));
@@ -8385,7 +8564,8 @@ void GL_APIENTRY GL_ProgramUniform3fvEXT(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform3fvEXT) &&
               ValidateProgramUniform3fvEXT(context, angle::EntryPoint::GLProgramUniform3fvEXT,
                                            programPacked, locationPacked, count, value)));
@@ -8418,7 +8598,8 @@ GL_ProgramUniform3iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform3iEXT) &&
               ValidateProgramUniform3iEXT(context, angle::EntryPoint::GLProgramUniform3iEXT,
                                           programPacked, locationPacked, v0, v1, v2)));
@@ -8453,7 +8634,8 @@ void GL_APIENTRY GL_ProgramUniform3ivEXT(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform3ivEXT) &&
               ValidateProgramUniform3ivEXT(context, angle::EntryPoint::GLProgramUniform3ivEXT,
                                            programPacked, locationPacked, count, value)));
@@ -8486,7 +8668,8 @@ GL_ProgramUniform3uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GL
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform3uiEXT) &&
               ValidateProgramUniform3uiEXT(context, angle::EntryPoint::GLProgramUniform3uiEXT,
                                            programPacked, locationPacked, v0, v1, v2)));
@@ -8521,7 +8704,8 @@ void GL_APIENTRY GL_ProgramUniform3uivEXT(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform3uivEXT) &&
               ValidateProgramUniform3uivEXT(context, angle::EntryPoint::GLProgramUniform3uivEXT,
                                             programPacked, locationPacked, count, value)));
@@ -8558,7 +8742,8 @@ void GL_APIENTRY GL_ProgramUniform4fEXT(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform4fEXT) &&
               ValidateProgramUniform4fEXT(context, angle::EntryPoint::GLProgramUniform4fEXT,
                                           programPacked, locationPacked, v0, v1, v2, v3)));
@@ -8593,7 +8778,8 @@ void GL_APIENTRY GL_ProgramUniform4fvEXT(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform4fvEXT) &&
               ValidateProgramUniform4fvEXT(context, angle::EntryPoint::GLProgramUniform4fvEXT,
                                            programPacked, locationPacked, count, value)));
@@ -8626,7 +8812,8 @@ GL_ProgramUniform4iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform4iEXT) &&
               ValidateProgramUniform4iEXT(context, angle::EntryPoint::GLProgramUniform4iEXT,
                                           programPacked, locationPacked, v0, v1, v2, v3)));
@@ -8661,7 +8848,8 @@ void GL_APIENTRY GL_ProgramUniform4ivEXT(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform4ivEXT) &&
               ValidateProgramUniform4ivEXT(context, angle::EntryPoint::GLProgramUniform4ivEXT,
                                            programPacked, locationPacked, count, value)));
@@ -8694,7 +8882,8 @@ GL_ProgramUniform4uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GL
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform4uiEXT) &&
               ValidateProgramUniform4uiEXT(context, angle::EntryPoint::GLProgramUniform4uiEXT,
                                            programPacked, locationPacked, v0, v1, v2, v3)));
@@ -8729,7 +8918,8 @@ void GL_APIENTRY GL_ProgramUniform4uivEXT(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLProgramUniform4uivEXT) &&
               ValidateProgramUniform4uivEXT(context, angle::EntryPoint::GLProgramUniform4uivEXT,
                                             programPacked, locationPacked, count, value)));
@@ -8764,12 +8954,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix2fvEXT(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2fvEXT) &&
-                             ValidateProgramUniformMatrix2fvEXT(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2fvEXT,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix2fvEXT) &&
+              ValidateProgramUniformMatrix2fvEXT(
+                  context, angle::EntryPoint::GLProgramUniformMatrix2fvEXT, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix2fv(programPacked, locationPacked, count, transpose,
@@ -8802,12 +8994,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix2x3fvEXT(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2x3fvEXT) &&
-                             ValidateProgramUniformMatrix2x3fvEXT(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2x3fvEXT,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLProgramUniformMatrix2x3fvEXT) &&
+              ValidateProgramUniformMatrix2x3fvEXT(
+                  context, angle::EntryPoint::GLProgramUniformMatrix2x3fvEXT, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix2x3fv(programPacked, locationPacked, count, transpose,
@@ -8840,12 +9034,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix2x4fvEXT(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2x4fvEXT) &&
-                             ValidateProgramUniformMatrix2x4fvEXT(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix2x4fvEXT,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLProgramUniformMatrix2x4fvEXT) &&
+              ValidateProgramUniformMatrix2x4fvEXT(
+                  context, angle::EntryPoint::GLProgramUniformMatrix2x4fvEXT, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix2x4fv(programPacked, locationPacked, count, transpose,
@@ -8878,12 +9074,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix3fvEXT(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3fvEXT) &&
-                             ValidateProgramUniformMatrix3fvEXT(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3fvEXT,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix3fvEXT) &&
+              ValidateProgramUniformMatrix3fvEXT(
+                  context, angle::EntryPoint::GLProgramUniformMatrix3fvEXT, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix3fv(programPacked, locationPacked, count, transpose,
@@ -8916,12 +9114,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix3x2fvEXT(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3x2fvEXT) &&
-                             ValidateProgramUniformMatrix3x2fvEXT(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3x2fvEXT,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLProgramUniformMatrix3x2fvEXT) &&
+              ValidateProgramUniformMatrix3x2fvEXT(
+                  context, angle::EntryPoint::GLProgramUniformMatrix3x2fvEXT, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix3x2fv(programPacked, locationPacked, count, transpose,
@@ -8954,12 +9154,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix3x4fvEXT(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3x4fvEXT) &&
-                             ValidateProgramUniformMatrix3x4fvEXT(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix3x4fvEXT,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLProgramUniformMatrix3x4fvEXT) &&
+              ValidateProgramUniformMatrix3x4fvEXT(
+                  context, angle::EntryPoint::GLProgramUniformMatrix3x4fvEXT, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix3x4fv(programPacked, locationPacked, count, transpose,
@@ -8992,12 +9194,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix4fvEXT(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4fvEXT) &&
-                             ValidateProgramUniformMatrix4fvEXT(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4fvEXT,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramUniformMatrix4fvEXT) &&
+              ValidateProgramUniformMatrix4fvEXT(
+                  context, angle::EntryPoint::GLProgramUniformMatrix4fvEXT, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix4fv(programPacked, locationPacked, count, transpose,
@@ -9030,12 +9234,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix4x2fvEXT(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4x2fvEXT) &&
-                             ValidateProgramUniformMatrix4x2fvEXT(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4x2fvEXT,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLProgramUniformMatrix4x2fvEXT) &&
+              ValidateProgramUniformMatrix4x2fvEXT(
+                  context, angle::EntryPoint::GLProgramUniformMatrix4x2fvEXT, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix4x2fv(programPacked, locationPacked, count, transpose,
@@ -9068,12 +9274,14 @@ void GL_APIENTRY GL_ProgramUniformMatrix4x3fvEXT(GLuint program,
         ShaderProgramID programPacked  = PackParam<ShaderProgramID>(program);
         UniformLocation locationPacked = PackParam<UniformLocation>(location);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4x3fvEXT) &&
-                             ValidateProgramUniformMatrix4x3fvEXT(
-                                 context, angle::EntryPoint::GLProgramUniformMatrix4x3fvEXT,
-                                 programPacked, locationPacked, count, transpose, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLProgramUniformMatrix4x3fvEXT) &&
+              ValidateProgramUniformMatrix4x3fvEXT(
+                  context, angle::EntryPoint::GLProgramUniformMatrix4x3fvEXT, programPacked,
+                  locationPacked, count, transpose, value)));
         if (isCallValid)
         {
             context->programUniformMatrix4x3fv(programPacked, locationPacked, count, transpose,
@@ -9103,7 +9311,8 @@ void GL_APIENTRY GL_UseProgramStagesEXT(GLuint pipeline, GLbitfield stages, GLui
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLUseProgramStagesEXT) &&
               ValidateUseProgramStagesEXT(context, angle::EntryPoint::GLUseProgramStagesEXT,
                                           pipelinePacked, stages, programPacked)));
@@ -9133,7 +9342,8 @@ void GL_APIENTRY GL_ValidateProgramPipelineEXT(GLuint pipeline)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLValidateProgramPipelineEXT) &&
               ValidateValidateProgramPipelineEXT(
                   context, angle::EntryPoint::GLValidateProgramPipelineEXT, pipelinePacked)));
@@ -9161,11 +9371,13 @@ void GL_APIENTRY GL_FramebufferFetchBarrierEXT()
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLFramebufferFetchBarrierEXT) &&
-                             ValidateFramebufferFetchBarrierEXT(
-                                 context, angle::EntryPoint::GLFramebufferFetchBarrierEXT)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFramebufferFetchBarrierEXT) &&
+              ValidateFramebufferFetchBarrierEXT(context,
+                                                 angle::EntryPoint::GLFramebufferFetchBarrierEXT)));
         if (isCallValid)
         {
             context->framebufferFetchBarrier();
@@ -9198,9 +9410,12 @@ void GL_APIENTRY GL_PatchParameteriEXT(GLenum pname, GLint value)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPatchParameteriEXT) &&
-              ValidatePatchParameteriEXT(context, angle::EntryPoint::GLPatchParameteriEXT, pname,
-                                         value)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPatchParameteriEXT) &&
+              ValidatePatchParameteriEXT(context->getPrivateState(),
+                                         context->getMutableErrorSetForValidation(),
+                                         angle::EntryPoint::GLPatchParameteriEXT, pname, value)));
         if (isCallValid)
         {
             ContextPrivatePatchParameteri(context->getMutablePrivateState(),
@@ -9462,7 +9677,9 @@ void GL_APIENTRY GL_TexBufferEXT(GLenum target, GLenum internalformat, GLuint bu
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexBufferEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexBufferEXT) &&
               ValidateTexBufferEXT(context, angle::EntryPoint::GLTexBufferEXT, targetPacked,
                                    internalformat, bufferPacked)));
         if (isCallValid)
@@ -9499,7 +9716,9 @@ void GL_APIENTRY GL_TexBufferRangeEXT(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexBufferRangeEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexBufferRangeEXT) &&
               ValidateTexBufferRangeEXT(context, angle::EntryPoint::GLTexBufferRangeEXT,
                                         targetPacked, internalformat, bufferPacked, offset, size)));
         if (isCallValid)
@@ -9567,7 +9786,9 @@ void GL_APIENTRY GL_TexStorage1DEXT(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexStorage1DEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexStorage1DEXT) &&
               ValidateTexStorage1DEXT(context, angle::EntryPoint::GLTexStorage1DEXT, target, levels,
                                       internalformat, width)));
         if (isCallValid)
@@ -9602,7 +9823,9 @@ void GL_APIENTRY GL_TexStorage2DEXT(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexStorage2DEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexStorage2DEXT) &&
               ValidateTexStorage2DEXT(context, angle::EntryPoint::GLTexStorage2DEXT, targetPacked,
                                       levels, internalformat, width, height)));
         if (isCallValid)
@@ -9639,7 +9862,9 @@ void GL_APIENTRY GL_TexStorage3DEXT(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexStorage3DEXT) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexStorage3DEXT) &&
               ValidateTexStorage3DEXT(context, angle::EntryPoint::GLTexStorage3DEXT, targetPacked,
                                       levels, internalformat, width, height, depth)));
         if (isCallValid)
@@ -9675,7 +9900,9 @@ void GL_APIENTRY GL_BlendBarrierKHR()
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBlendBarrierKHR) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBlendBarrierKHR) &&
               ValidateBlendBarrierKHR(context, angle::EntryPoint::GLBlendBarrierKHR)));
         if (isCallValid)
         {
@@ -10053,7 +10280,8 @@ void GL_APIENTRY GL_MaxShaderCompilerThreadsKHR(GLuint count)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLMaxShaderCompilerThreadsKHR) &&
               ValidateMaxShaderCompilerThreadsKHR(
                   context, angle::EntryPoint::GLMaxShaderCompilerThreadsKHR, count)));
@@ -10091,7 +10319,8 @@ void GL_APIENTRY GL_FramebufferParameteriMESA(GLenum target, GLenum pname, GLint
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLFramebufferParameteriMESA) &&
               ValidateFramebufferParameteriMESA(
                   context, angle::EntryPoint::GLFramebufferParameteriMESA, target, pname, param)));
@@ -10175,7 +10404,9 @@ void GL_APIENTRY GL_FinishFenceNV(GLuint fence)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLFinishFenceNV) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFinishFenceNV) &&
               ValidateFinishFenceNV(context, angle::EntryPoint::GLFinishFenceNV, fencePacked)));
         if (isCallValid)
         {
@@ -10287,7 +10518,9 @@ void GL_APIENTRY GL_SetFenceNV(GLuint fence, GLenum condition)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLSetFenceNV) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLSetFenceNV) &&
               ValidateSetFenceNV(context, angle::EntryPoint::GLSetFenceNV, fencePacked,
                                  condition)));
         if (isCallValid)
@@ -10315,7 +10548,9 @@ GLboolean GL_APIENTRY GL_TestFenceNV(GLuint fence)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTestFenceNV) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTestFenceNV) &&
               ValidateTestFenceNV(context, angle::EntryPoint::GLTestFenceNV, fencePacked)));
         if (isCallValid)
         {
@@ -10361,7 +10596,9 @@ void GL_APIENTRY GL_BlitFramebufferNV(GLint srcX0,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBlitFramebufferNV) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBlitFramebufferNV) &&
               ValidateBlitFramebufferNV(context, angle::EntryPoint::GLBlitFramebufferNV, srcX0,
                                         srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
                                         filter)));
@@ -10395,9 +10632,12 @@ void GL_APIENTRY GL_PolygonModeNV(GLenum face, GLenum mode)
         PolygonMode modePacked = PackParam<PolygonMode>(mode);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLPolygonModeNV) &&
-              ValidatePolygonModeNV(context, angle::EntryPoint::GLPolygonModeNV, face,
-                                    modePacked)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLPolygonModeNV) &&
+              ValidatePolygonModeNV(context->getPrivateState(),
+                                    context->getMutableErrorSetForValidation(),
+                                    angle::EntryPoint::GLPolygonModeNV, face, modePacked)));
         if (isCallValid)
         {
             ContextPrivatePolygonModeNV(context->getMutablePrivateState(),
@@ -10437,7 +10677,8 @@ void GL_APIENTRY GL_EGLImageTargetRenderbufferStorageOES(GLenum target, GLeglIma
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLEGLImageTargetRenderbufferStorageOES) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLEGLImageTargetRenderbufferStorageOES) &&
               ValidateEGLImageTargetRenderbufferStorageOES(
                   context, angle::EntryPoint::GLEGLImageTargetRenderbufferStorageOES, target,
                   imagePacked)));
@@ -10467,12 +10708,14 @@ void GL_APIENTRY GL_EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES imag
         TextureType targetPacked = PackParam<TextureType>(target);
         egl::ImageID imagePacked = PackParam<egl::ImageID>(image);
         SCOPED_EGL_IMAGE_SHARE_CONTEXT_LOCK(context, imagePacked);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLEGLImageTargetTexture2DOES) &&
-                             ValidateEGLImageTargetTexture2DOES(
-                                 context, angle::EntryPoint::GLEGLImageTargetTexture2DOES,
-                                 targetPacked, imagePacked)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLEGLImageTargetTexture2DOES) &&
+              ValidateEGLImageTargetTexture2DOES(context,
+                                                 angle::EntryPoint::GLEGLImageTargetTexture2DOES,
+                                                 targetPacked, imagePacked)));
         if (isCallValid)
         {
             context->eGLImageTargetTexture2D(targetPacked, imagePacked);
@@ -10525,13 +10768,15 @@ void GL_APIENTRY GL_CopyImageSubDataOES(GLuint srcName,
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLCopyImageSubDataOES) &&
-                             ValidateCopyImageSubDataOES(
-                                 context, angle::EntryPoint::GLCopyImageSubDataOES, srcName,
-                                 srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget,
-                                 dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCopyImageSubDataOES) &&
+              ValidateCopyImageSubDataOES(context, angle::EntryPoint::GLCopyImageSubDataOES,
+                                          srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
+                                          dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth,
+                                          srcHeight, srcDepth)));
         if (isCallValid)
         {
             context->copyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
@@ -10569,7 +10814,8 @@ void GL_APIENTRY GL_BlendEquationSeparateiOES(GLuint buf, GLenum modeRGB, GLenum
         bool isCallValid =
             (context->skipValidation() ||
              ValidateBlendEquationSeparateiOES(
-                 context, angle::EntryPoint::GLBlendEquationSeparateiOES, buf, modeRGB, modeAlpha));
+                 context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                 angle::EntryPoint::GLBlendEquationSeparateiOES, buf, modeRGB, modeAlpha));
         if (isCallValid)
         {
             ContextPrivateBlendEquationSeparatei(context->getMutablePrivateState(),
@@ -10595,7 +10841,9 @@ void GL_APIENTRY GL_BlendEquationiOES(GLuint buf, GLenum mode)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateBlendEquationiOES(context, angle::EntryPoint::GLBlendEquationiOES, buf, mode));
+             ValidateBlendEquationiOES(context->getPrivateState(),
+                                       context->getMutableErrorSetForValidation(),
+                                       angle::EntryPoint::GLBlendEquationiOES, buf, mode));
         if (isCallValid)
         {
             ContextPrivateBlendEquationi(context->getMutablePrivateState(),
@@ -10625,8 +10873,10 @@ GL_BlendFuncSeparateiOES(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlp
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateBlendFuncSeparateiOES(context, angle::EntryPoint::GLBlendFuncSeparateiOES, buf,
-                                           srcRGB, dstRGB, srcAlpha, dstAlpha));
+             ValidateBlendFuncSeparateiOES(context->getPrivateState(),
+                                           context->getMutableErrorSetForValidation(),
+                                           angle::EntryPoint::GLBlendFuncSeparateiOES, buf, srcRGB,
+                                           dstRGB, srcAlpha, dstAlpha));
         if (isCallValid)
         {
             ContextPrivateBlendFuncSeparatei(context->getMutablePrivateState(),
@@ -10654,7 +10904,9 @@ void GL_APIENTRY GL_BlendFunciOES(GLuint buf, GLenum src, GLenum dst)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateBlendFunciOES(context, angle::EntryPoint::GLBlendFunciOES, buf, src, dst));
+             ValidateBlendFunciOES(context->getPrivateState(),
+                                   context->getMutableErrorSetForValidation(),
+                                   angle::EntryPoint::GLBlendFunciOES, buf, src, dst));
         if (isCallValid)
         {
             ContextPrivateBlendFunci(context->getMutablePrivateState(),
@@ -10680,7 +10932,9 @@ void GL_APIENTRY GL_ColorMaskiOES(GLuint index, GLboolean r, GLboolean g, GLbool
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateColorMaskiOES(context, angle::EntryPoint::GLColorMaskiOES, index, r, g, b, a));
+             ValidateColorMaskiOES(context->getPrivateState(),
+                                   context->getMutableErrorSetForValidation(),
+                                   angle::EntryPoint::GLColorMaskiOES, index, r, g, b, a));
         if (isCallValid)
         {
             ContextPrivateColorMaski(context->getMutablePrivateState(),
@@ -10703,9 +10957,10 @@ void GL_APIENTRY GL_DisableiOES(GLenum target, GLuint index)
 
     if (context)
     {
-        bool isCallValid =
-            (context->skipValidation() ||
-             ValidateDisableiOES(context, angle::EntryPoint::GLDisableiOES, target, index));
+        bool isCallValid = (context->skipValidation() ||
+                            ValidateDisableiOES(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDisableiOES, target, index));
         if (isCallValid)
         {
             ContextPrivateDisablei(context->getMutablePrivateState(),
@@ -10728,9 +10983,10 @@ void GL_APIENTRY GL_EnableiOES(GLenum target, GLuint index)
 
     if (context)
     {
-        bool isCallValid =
-            (context->skipValidation() ||
-             ValidateEnableiOES(context, angle::EntryPoint::GLEnableiOES, target, index));
+        bool isCallValid = (context->skipValidation() ||
+                            ValidateEnableiOES(context->getPrivateState(),
+                                               context->getMutableErrorSetForValidation(),
+                                               angle::EntryPoint::GLEnableiOES, target, index));
         if (isCallValid)
         {
             ContextPrivateEnablei(context->getMutablePrivateState(),
@@ -10756,7 +11012,9 @@ GLboolean GL_APIENTRY GL_IsEnablediOES(GLenum target, GLuint index)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             ValidateIsEnablediOES(context, angle::EntryPoint::GLIsEnablediOES, target, index));
+             ValidateIsEnablediOES(context->getPrivateState(),
+                                   context->getMutableErrorSetForValidation(),
+                                   angle::EntryPoint::GLIsEnablediOES, target, index));
         if (isCallValid)
         {
             returnValue =
@@ -10907,7 +11165,9 @@ void GL_APIENTRY GL_DrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDrawTexfOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDrawTexfOES) &&
               ValidateDrawTexfOES(context, angle::EntryPoint::GLDrawTexfOES, x, y, z, width,
                                   height)));
         if (isCallValid)
@@ -10934,7 +11194,9 @@ void GL_APIENTRY GL_DrawTexfvOES(const GLfloat *coords)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDrawTexfvOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDrawTexfvOES) &&
               ValidateDrawTexfvOES(context, angle::EntryPoint::GLDrawTexfvOES, coords)));
         if (isCallValid)
         {
@@ -10960,7 +11222,9 @@ void GL_APIENTRY GL_DrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint he
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDrawTexiOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDrawTexiOES) &&
               ValidateDrawTexiOES(context, angle::EntryPoint::GLDrawTexiOES, x, y, z, width,
                                   height)));
         if (isCallValid)
@@ -10987,7 +11251,9 @@ void GL_APIENTRY GL_DrawTexivOES(const GLint *coords)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDrawTexivOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDrawTexivOES) &&
               ValidateDrawTexivOES(context, angle::EntryPoint::GLDrawTexivOES, coords)));
         if (isCallValid)
         {
@@ -11013,7 +11279,9 @@ void GL_APIENTRY GL_DrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDrawTexsOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDrawTexsOES) &&
               ValidateDrawTexsOES(context, angle::EntryPoint::GLDrawTexsOES, x, y, z, width,
                                   height)));
         if (isCallValid)
@@ -11040,7 +11308,9 @@ void GL_APIENTRY GL_DrawTexsvOES(const GLshort *coords)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDrawTexsvOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDrawTexsvOES) &&
               ValidateDrawTexsvOES(context, angle::EntryPoint::GLDrawTexsvOES, coords)));
         if (isCallValid)
         {
@@ -11067,7 +11337,9 @@ void GL_APIENTRY GL_DrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDrawTexxOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDrawTexxOES) &&
               ValidateDrawTexxOES(context, angle::EntryPoint::GLDrawTexxOES, x, y, z, width,
                                   height)));
         if (isCallValid)
@@ -11094,7 +11366,9 @@ void GL_APIENTRY GL_DrawTexxvOES(const GLfixed *coords)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLDrawTexxvOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLDrawTexxvOES) &&
               ValidateDrawTexxvOES(context, angle::EntryPoint::GLDrawTexxvOES, coords)));
         if (isCallValid)
         {
@@ -11126,7 +11400,9 @@ void GL_APIENTRY GL_BindFramebufferOES(GLenum target, GLuint framebuffer)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBindFramebufferOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBindFramebufferOES) &&
               ValidateBindFramebufferOES(context, angle::EntryPoint::GLBindFramebufferOES, target,
                                          framebufferPacked)));
         if (isCallValid)
@@ -11154,7 +11430,8 @@ void GL_APIENTRY GL_BindRenderbufferOES(GLenum target, GLuint renderbuffer)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLBindRenderbufferOES) &&
               ValidateBindRenderbufferOES(context, angle::EntryPoint::GLBindRenderbufferOES, target,
                                           renderbufferPacked)));
@@ -11181,11 +11458,13 @@ GLenum GL_APIENTRY GL_CheckFramebufferStatusOES(GLenum target)
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLCheckFramebufferStatusOES) &&
-                             ValidateCheckFramebufferStatusOES(
-                                 context, angle::EntryPoint::GLCheckFramebufferStatusOES, target)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCheckFramebufferStatusOES) &&
+              ValidateCheckFramebufferStatusOES(
+                  context, angle::EntryPoint::GLCheckFramebufferStatusOES, target)));
         if (isCallValid)
         {
             returnValue = context->checkFramebufferStatus(target);
@@ -11280,12 +11559,14 @@ void GL_APIENTRY GL_FramebufferRenderbufferOES(GLenum target,
     {
         RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLFramebufferRenderbufferOES) &&
-                             ValidateFramebufferRenderbufferOES(
-                                 context, angle::EntryPoint::GLFramebufferRenderbufferOES, target,
-                                 attachment, renderbuffertarget, renderbufferPacked)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFramebufferRenderbufferOES) &&
+              ValidateFramebufferRenderbufferOES(
+                  context, angle::EntryPoint::GLFramebufferRenderbufferOES, target, attachment,
+                  renderbuffertarget, renderbufferPacked)));
         if (isCallValid)
         {
             context->framebufferRenderbuffer(target, attachment, renderbuffertarget,
@@ -11319,12 +11600,14 @@ void GL_APIENTRY GL_FramebufferTexture2DOES(GLenum target,
         TextureTarget textargetPacked = PackParam<TextureTarget>(textarget);
         TextureID texturePacked       = PackParam<TextureID>(texture);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLFramebufferTexture2DOES) &&
-                             ValidateFramebufferTexture2DOES(
-                                 context, angle::EntryPoint::GLFramebufferTexture2DOES, target,
-                                 attachment, textargetPacked, texturePacked, level)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFramebufferTexture2DOES) &&
+              ValidateFramebufferTexture2DOES(context, angle::EntryPoint::GLFramebufferTexture2DOES,
+                                              target, attachment, textargetPacked, texturePacked,
+                                              level)));
         if (isCallValid)
         {
             context->framebufferTexture2D(target, attachment, textargetPacked, texturePacked,
@@ -11566,7 +11849,8 @@ void GL_APIENTRY GL_RenderbufferStorageOES(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLRenderbufferStorageOES) &&
               ValidateRenderbufferStorageOES(context, angle::EntryPoint::GLRenderbufferStorageOES,
                                              target, internalformat, width, height)));
@@ -11602,7 +11886,8 @@ void GL_APIENTRY GL_FramebufferTextureOES(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLFramebufferTextureOES) &&
               ValidateFramebufferTextureOES(context, angle::EntryPoint::GLFramebufferTextureOES,
                                             target, attachment, texturePacked, level)));
@@ -11673,7 +11958,9 @@ void GL_APIENTRY GL_ProgramBinaryOES(GLuint program,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLProgramBinaryOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLProgramBinaryOES) &&
               ValidateProgramBinaryOES(context, angle::EntryPoint::GLProgramBinaryOES,
                                        programPacked, binaryFormat, binary, length)));
         if (isCallValid)
@@ -11734,7 +12021,9 @@ void *GL_APIENTRY GL_MapBufferOES(GLenum target, GLenum access)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLMapBufferOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMapBufferOES) &&
               ValidateMapBufferOES(context, angle::EntryPoint::GLMapBufferOES, targetPacked,
                                    access)));
         if (isCallValid)
@@ -11769,7 +12058,9 @@ GLboolean GL_APIENTRY GL_UnmapBufferOES(GLenum target)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLUnmapBufferOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLUnmapBufferOES) &&
               ValidateUnmapBufferOES(context, angle::EntryPoint::GLUnmapBufferOES, targetPacked)));
         if (isCallValid)
         {
@@ -11802,7 +12093,8 @@ void GL_APIENTRY GL_CurrentPaletteMatrixOES(GLuint matrixpaletteindex)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCurrentPaletteMatrixOES) &&
               ValidateCurrentPaletteMatrixOES(context, angle::EntryPoint::GLCurrentPaletteMatrixOES,
                                               matrixpaletteindex)));
@@ -11827,11 +12119,13 @@ void GL_APIENTRY GL_LoadPaletteFromModelViewMatrixOES()
     if (context)
     {
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLLoadPaletteFromModelViewMatrixOES) &&
-                             ValidateLoadPaletteFromModelViewMatrixOES(
-                                 context, angle::EntryPoint::GLLoadPaletteFromModelViewMatrixOES)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLLoadPaletteFromModelViewMatrixOES) &&
+              ValidateLoadPaletteFromModelViewMatrixOES(
+                  context, angle::EntryPoint::GLLoadPaletteFromModelViewMatrixOES)));
         if (isCallValid)
         {
             context->loadPaletteFromModelViewMatrix();
@@ -11860,7 +12154,8 @@ void GL_APIENTRY GL_MatrixIndexPointerOES(GLint size,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLMatrixIndexPointerOES) &&
               ValidateMatrixIndexPointerOES(context, angle::EntryPoint::GLMatrixIndexPointerOES,
                                             size, type, stride, pointer)));
@@ -11889,7 +12184,9 @@ void GL_APIENTRY GL_WeightPointerOES(GLint size, GLenum type, GLsizei stride, co
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLWeightPointerOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLWeightPointerOES) &&
               ValidateWeightPointerOES(context, angle::EntryPoint::GLWeightPointerOES, size, type,
                                        stride, pointer)));
         if (isCallValid)
@@ -11921,7 +12218,8 @@ void GL_APIENTRY GL_PointSizePointerOES(GLenum type, GLsizei stride, const void
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLPointSizePointerOES) &&
               ValidatePointSizePointerOES(context, angle::EntryPoint::GLPointSizePointerOES,
                                           typePacked, stride, pointer)));
@@ -11960,10 +12258,13 @@ void GL_APIENTRY GL_PrimitiveBoundingBoxOES(GLfloat minX,
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLPrimitiveBoundingBoxOES) &&
-              ValidatePrimitiveBoundingBoxOES(context, angle::EntryPoint::GLPrimitiveBoundingBoxOES,
-                                              minX, minY, minZ, minW, maxX, maxY, maxZ, maxW)));
+              ValidatePrimitiveBoundingBoxOES(context->getPrivateState(),
+                                              context->getMutableErrorSetForValidation(),
+                                              angle::EntryPoint::GLPrimitiveBoundingBoxOES, minX,
+                                              minY, minZ, minW, maxX, maxY, maxZ, maxW)));
         if (isCallValid)
         {
             ContextPrivatePrimitiveBoundingBox(context->getMutablePrivateState(),
@@ -11994,7 +12295,9 @@ GLbitfield GL_APIENTRY GL_QueryMatrixxOES(GLfixed *mantissa, GLint *exponent)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLQueryMatrixxOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLQueryMatrixxOES) &&
               ValidateQueryMatrixxOES(context, angle::EntryPoint::GLQueryMatrixxOES, mantissa,
                                       exponent)));
         if (isCallValid)
@@ -12026,11 +12329,14 @@ void GL_APIENTRY GL_MinSampleShadingOES(GLfloat value)
 
     if (context)
     {
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLMinSampleShadingOES) &&
-                             ValidateMinSampleShadingOES(
-                                 context, angle::EntryPoint::GLMinSampleShadingOES, value)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLMinSampleShadingOES) &&
+              ValidateMinSampleShadingOES(context->getPrivateState(),
+                                          context->getMutableErrorSetForValidation(),
+                                          angle::EntryPoint::GLMinSampleShadingOES, value)));
         if (isCallValid)
         {
             ContextPrivateMinSampleShading(context->getMutablePrivateState(),
@@ -12082,7 +12388,8 @@ void GL_APIENTRY GL_CompressedTexImage3DOES(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCompressedTexImage3DOES) &&
               ValidateCompressedTexImage3DOES(context, angle::EntryPoint::GLCompressedTexImage3DOES,
                                               targetPacked, level, internalformat, width, height,
@@ -12128,7 +12435,8 @@ void GL_APIENTRY GL_CompressedTexSubImage3DOES(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLCompressedTexSubImage3DOES) &&
               ValidateCompressedTexSubImage3DOES(
                   context, angle::EntryPoint::GLCompressedTexSubImage3DOES, targetPacked, level,
@@ -12169,12 +12477,14 @@ void GL_APIENTRY GL_CopyTexSubImage3DOES(GLenum target,
     {
         TextureTarget targetPacked = PackParam<TextureTarget>(target);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLCopyTexSubImage3DOES) &&
-                             ValidateCopyTexSubImage3DOES(
-                                 context, angle::EntryPoint::GLCopyTexSubImage3DOES, targetPacked,
-                                 level, xoffset, yoffset, zoffset, x, y, width, height)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLCopyTexSubImage3DOES) &&
+              ValidateCopyTexSubImage3DOES(context, angle::EntryPoint::GLCopyTexSubImage3DOES,
+                                           targetPacked, level, xoffset, yoffset, zoffset, x, y,
+                                           width, height)));
         if (isCallValid)
         {
             context->copyTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, x, y, width,
@@ -12210,12 +12520,14 @@ void GL_APIENTRY GL_FramebufferTexture3DOES(GLenum target,
         TextureTarget textargetPacked = PackParam<TextureTarget>(textarget);
         TextureID texturePacked       = PackParam<TextureID>(texture);
         SCOPED_SHARE_CONTEXT_LOCK(context);
-        bool isCallValid = (context->skipValidation() ||
-                            (ValidatePixelLocalStorageInactive(
-                                 context, angle::EntryPoint::GLFramebufferTexture3DOES) &&
-                             ValidateFramebufferTexture3DOES(
-                                 context, angle::EntryPoint::GLFramebufferTexture3DOES, target,
-                                 attachment, textargetPacked, texturePacked, level, zoffset)));
+        bool isCallValid =
+            (context->skipValidation() ||
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLFramebufferTexture3DOES) &&
+              ValidateFramebufferTexture3DOES(context, angle::EntryPoint::GLFramebufferTexture3DOES,
+                                              target, attachment, textargetPacked, texturePacked,
+                                              level, zoffset)));
         if (isCallValid)
         {
             context->framebufferTexture3D(target, attachment, textargetPacked, texturePacked, level,
@@ -12257,7 +12569,9 @@ void GL_APIENTRY GL_TexImage3DOES(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexImage3DOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexImage3DOES) &&
               ValidateTexImage3DOES(context, angle::EntryPoint::GLTexImage3DOES, targetPacked,
                                     level, internalformat, width, height, depth, border, format,
                                     type, pixels)));
@@ -12302,7 +12616,9 @@ void GL_APIENTRY GL_TexSubImage3DOES(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexSubImage3DOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexSubImage3DOES) &&
               ValidateTexSubImage3DOES(context, angle::EntryPoint::GLTexSubImage3DOES, targetPacked,
                                        level, xoffset, yoffset, zoffset, width, height, depth,
                                        format, type, pixels)));
@@ -12568,7 +12884,9 @@ void GL_APIENTRY GL_TexBufferOES(GLenum target, GLenum internalformat, GLuint bu
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexBufferOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexBufferOES) &&
               ValidateTexBufferOES(context, angle::EntryPoint::GLTexBufferOES, targetPacked,
                                    internalformat, bufferPacked)));
         if (isCallValid)
@@ -12605,7 +12923,9 @@ void GL_APIENTRY GL_TexBufferRangeOES(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexBufferRangeOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexBufferRangeOES) &&
               ValidateTexBufferRangeOES(context, angle::EntryPoint::GLTexBufferRangeOES,
                                         targetPacked, internalformat, bufferPacked, offset, size)));
         if (isCallValid)
@@ -12718,7 +13038,9 @@ void GL_APIENTRY GL_TexGenfOES(GLenum coord, GLenum pname, GLfloat param)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexGenfOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexGenfOES) &&
               ValidateTexGenfOES(context, angle::EntryPoint::GLTexGenfOES, coord, pname, param)));
         if (isCallValid)
         {
@@ -12746,7 +13068,9 @@ void GL_APIENTRY GL_TexGenfvOES(GLenum coord, GLenum pname, const GLfloat *param
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexGenfvOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexGenfvOES) &&
               ValidateTexGenfvOES(context, angle::EntryPoint::GLTexGenfvOES, coord, pname,
                                   params)));
         if (isCallValid)
@@ -12774,7 +13098,9 @@ void GL_APIENTRY GL_TexGeniOES(GLenum coord, GLenum pname, GLint param)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexGeniOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexGeniOES) &&
               ValidateTexGeniOES(context, angle::EntryPoint::GLTexGeniOES, coord, pname, param)));
         if (isCallValid)
         {
@@ -12802,7 +13128,9 @@ void GL_APIENTRY GL_TexGenivOES(GLenum coord, GLenum pname, const GLint *params)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexGenivOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexGenivOES) &&
               ValidateTexGenivOES(context, angle::EntryPoint::GLTexGenivOES, coord, pname,
                                   params)));
         if (isCallValid)
@@ -12830,7 +13158,9 @@ void GL_APIENTRY GL_TexGenxOES(GLenum coord, GLenum pname, GLfixed param)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexGenxOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexGenxOES) &&
               ValidateTexGenxOES(context, angle::EntryPoint::GLTexGenxOES, coord, pname, param)));
         if (isCallValid)
         {
@@ -12858,7 +13188,9 @@ void GL_APIENTRY GL_TexGenxvOES(GLenum coord, GLenum pname, const GLfixed *param
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLTexGenxvOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLTexGenxvOES) &&
               ValidateTexGenxvOES(context, angle::EntryPoint::GLTexGenxvOES, coord, pname,
                                   params)));
         if (isCallValid)
@@ -12911,7 +13243,8 @@ void GL_APIENTRY GL_TexStorage3DMultisampleOES(GLenum target,
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context,
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
                                                 angle::EntryPoint::GLTexStorage3DMultisampleOES) &&
               ValidateTexStorage3DMultisampleOES(
                   context, angle::EntryPoint::GLTexStorage3DMultisampleOES, targetPacked, samples,
@@ -12943,7 +13276,9 @@ void GL_APIENTRY GL_BindVertexArrayOES(GLuint array)
         SCOPED_SHARE_CONTEXT_LOCK(context);
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLBindVertexArrayOES) &&
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLBindVertexArrayOES) &&
               ValidateBindVertexArrayOES(context, angle::EntryPoint::GLBindVertexArrayOES,
                                          arrayPacked)));
         if (isCallValid)
@@ -13071,7 +13406,8 @@ void GL_APIENTRY GL_FramebufferTextureMultiviewOVR(GLenum target,
         bool isCallValid =
             (context->skipValidation() ||
              (ValidatePixelLocalStorageInactive(
-                  context, angle::EntryPoint::GLFramebufferTextureMultiviewOVR) &&
+                  context->getPrivateState(), context->getMutableErrorSetForValidation(),
+                  angle::EntryPoint::GLFramebufferTextureMultiviewOVR) &&
               ValidateFramebufferTextureMultiviewOVR(
                   context, angle::EntryPoint::GLFramebufferTextureMultiviewOVR, target, attachment,
                   texturePacked, level, baseViewIndex, numViews)));
@@ -13105,8 +13441,12 @@ void GL_APIENTRY GL_ShadingRateQCOM(GLenum rate)
     {
         bool isCallValid =
             (context->skipValidation() ||
-             (ValidatePixelLocalStorageInactive(context, angle::EntryPoint::GLShadingRateQCOM) &&
-              ValidateShadingRateQCOM(context, angle::EntryPoint::GLShadingRateQCOM, rate)));
+             (ValidatePixelLocalStorageInactive(context->getPrivateState(),
+                                                context->getMutableErrorSetForValidation(),
+                                                angle::EntryPoint::GLShadingRateQCOM) &&
+              ValidateShadingRateQCOM(context->getPrivateState(),
+                                      context->getMutableErrorSetForValidation(),
+                                      angle::EntryPoint::GLShadingRateQCOM, rate)));
         if (isCallValid)
         {
             ContextPrivateShadingRate(context->getMutablePrivateState(),