commit c9a42949e3ceabf5ac4b68c069532af5b7d05276
author Shahbaz Youssefi <syoussefi@chromium.org> Wed Jul 12 15:07:17 2023 -0400
committer Angle LUCI CQ <angle-scoped@luci-project-accounts.iam.gserviceaccount.com> Thu Jul 13 16:51:50 2023 +0000
tree d732de268a8afa55473a650a31a756883bbdcb6f
parent 79f5b73a6129d2f245fa4d096366ff07b7e162c0

Make validation make straight calls to ErrorSet

... and avoid going through the context (just to get a const cast).
This change is also in preparation for an follow up where some entry
points directly use ErrorSet and don't access context at all.

Bug: angleproject:8224
Change-Id: Idef0a88d9407870e7a84b4fe6967fbff175c269b
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4678350
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>

src/libANGLE/Context.cpp

diff --git a/src/libANGLE/Context.cpp b/src/libANGLE/Context.cpp
index 6caaebc..ba281b5 100644
--- a/src/libANGLE/Context.cpp
+++ b/src/libANGLE/Context.cpp
@@ -3045,35 +3045,6 @@
     mErrors.handleError(errorCode, message, file, function, line);
 }
 
-void Context::validationError(angle::EntryPoint entryPoint,
-                              GLenum errorCode,
-                              const char *message) const
-{
-    const_cast<Context *>(this)->mErrors.validationError(entryPoint, errorCode, message);
-}
-
-void Context::validationErrorF(angle::EntryPoint entryPoint,
-                               GLenum errorCode,
-                               const char *format,
-                               ...) const
-{
-    va_list vargs;
-    va_start(vargs, format);
-    constexpr size_t kMessageSize = 256;
-    char message[kMessageSize];
-    int r = vsnprintf(message, kMessageSize, format, vargs);
-    va_end(vargs);
-
-    if (r > 0)
-    {
-        validationError(entryPoint, errorCode, message);
-    }
-    else
-    {
-        validationError(entryPoint, errorCode, format);
-    }
-}
-
 // Get one of the recorded errors and clear its flag, if any.
 // [OpenGL ES 2.0.24] section 2.5 page 13.
 GLenum Context::getError()
@@ -9959,6 +9930,28 @@
     pushError(errorCode);
 }
 
+void ErrorSet::validationErrorF(angle::EntryPoint entryPoint,
+                                GLenum errorCode,
+                                const char *format,
+                                ...)
+{
+    va_list vargs;
+    va_start(vargs, format);
+    constexpr size_t kMessageSize = 256;
+    char message[kMessageSize];
+    int r = vsnprintf(message, kMessageSize, format, vargs);
+    va_end(vargs);
+
+    if (r > 0)
+    {
+        validationError(entryPoint, errorCode, message);
+    }
+    else
+    {
+        validationError(entryPoint, errorCode, format);
+    }
+}
+
 void ErrorSet::pushError(GLenum errorCode)
 {
     ASSERT(errorCode != GL_NO_ERROR);

src/libANGLE/Context.h

diff --git a/src/libANGLE/Context.h b/src/libANGLE/Context.h
index 24d7ff0..bd990ea 100644
--- a/src/libANGLE/Context.h
+++ b/src/libANGLE/Context.h
@@ -104,6 +104,8 @@
                      unsigned int line);
 
     void validationError(angle::EntryPoint entryPoint, GLenum errorCode, const char *message);
+    ANGLE_FORMAT_PRINTF(4, 5)
+    void validationErrorF(angle::EntryPoint entryPoint, GLenum errorCode, const char *format, ...);
 
     bool skipValidation() const
     {
@@ -552,13 +554,6 @@
                      const char *function,
                      unsigned int line);
 
-    void validationError(angle::EntryPoint entryPoint, GLenum errorCode, const char *message) const;
-    ANGLE_FORMAT_PRINTF(4, 5)
-    void validationErrorF(angle::EntryPoint entryPoint,
-                          GLenum errorCode,
-                          const char *format,
-                          ...) const;
-
     bool isResetNotificationEnabled() const;
 
     bool isRobustnessEnabled() const;
@@ -632,6 +627,8 @@
     void markContextLost(GraphicsResetStatus status) { mErrors.markContextLost(status); }
     bool isContextLost() const { return mErrors.isContextLost(); }
 
+    ErrorSet *getMutableErrorSetForValidation() const { return &mErrors; }
+
     // Specific methods needed for validation.
     bool getQueryParameterInfo(GLenum pname, GLenum *type, unsigned int *numParams) const;
     bool getIndexedQueryParameterInfo(GLenum target, GLenum *type, unsigned int *numParams) const;
@@ -854,7 +851,7 @@
     bool mDisplaySemaphoreShareGroup;
 
     // Recorded errors
-    ErrorSet mErrors;
+    mutable ErrorSet mErrors;
 
     // Stores for each buffer binding type whether is it allowed to be used in this context.
     angle::PackedEnumBitSet<BufferBinding> mValidBufferBindings;

src/libANGLE/entry_points_utils.cpp

diff --git a/src/libANGLE/entry_points_utils.cpp b/src/libANGLE/entry_points_utils.cpp
index 680d478..6399508 100644
--- a/src/libANGLE/entry_points_utils.cpp
+++ b/src/libANGLE/entry_points_utils.cpp
@@ -15,7 +15,8 @@
 bool GeneratePixelLocalStorageActiveError(const Context *context, angle::EntryPoint entryPoint)
 {
     ASSERT(context->getState().getPixelLocalStorageActivePlanes() != 0);
-    context->validationError(entryPoint, GL_INVALID_OPERATION, err::kPLSActive);
+    context->getMutableErrorSetForValidation()->validationError(entryPoint, GL_INVALID_OPERATION,
+                                                                err::kPLSActive);
     return false;
 }
 }  // namespace gl

src/libANGLE/validationES.cpp

diff --git a/src/libANGLE/validationES.cpp b/src/libANGLE/validationES.cpp
index f0d0d3b..486d640 100644
--- a/src/libANGLE/validationES.cpp
+++ b/src/libANGLE/validationES.cpp
@@ -257,13 +257,13 @@
             if (!context->getExtensions().textureBorderClampAny() &&
                 context->getClientVersion() < ES_3_2)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
                 return false;
             }
             if (restrictedWrapModes)
             {
                 // OES_EGL_image_external and ANGLE_texture_rectangle specify this error.
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidWrapModeTexture);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidWrapModeTexture);
                 return false;
             }
             break;
@@ -273,7 +273,7 @@
             if (restrictedWrapModes)
             {
                 // OES_EGL_image_external and ANGLE_texture_rectangle specify this error.
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidWrapModeTexture);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidWrapModeTexture);
                 return false;
             }
             break;
@@ -281,19 +281,19 @@
         case GL_MIRROR_CLAMP_TO_EDGE_EXT:
             if (!context->getExtensions().textureMirrorClampToEdgeEXT)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
                 return false;
             }
             if (restrictedWrapModes)
             {
                 // OES_EGL_image_external and ANGLE_texture_rectangle specify this error.
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidWrapModeTexture);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidWrapModeTexture);
                 return false;
             }
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureWrap);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureWrap);
             return false;
     }
 
@@ -319,13 +319,13 @@
             if (restrictedMinFilter)
             {
                 // OES_EGL_image_external specifies this error.
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFilterTexture);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFilterTexture);
                 return false;
             }
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureFilterParam);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureFilterParam);
             return false;
     }
 
@@ -344,7 +344,7 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureFilterParam);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureFilterParam);
             return false;
     }
 
@@ -364,7 +364,7 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kUnknownParameter);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kUnknownParameter);
             return false;
     }
 
@@ -390,7 +390,7 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kUnknownParameter);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kUnknownParameter);
             return false;
     }
 
@@ -404,7 +404,7 @@
 {
     if (!context->getExtensions().textureSRGBDecodeEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
         return false;
     }
 
@@ -415,7 +415,7 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kUnknownParameter);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kUnknownParameter);
             return false;
     }
 
@@ -429,7 +429,7 @@
 {
     if (!context->getExtensions().textureFormatSRGBOverrideEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
         return false;
     }
 
@@ -440,7 +440,7 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kUnknownParameter);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kUnknownParameter);
             return false;
     }
 
@@ -452,7 +452,7 @@
 {
     if (!context->getExtensions().textureFilterAnisotropicEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
         return false;
     }
 
@@ -472,7 +472,7 @@
 
     if (paramValue < 1 || paramValue > largest)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kOutsideOfBounds);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kOutsideOfBounds);
         return false;
     }
 
@@ -865,7 +865,7 @@
     {
         if (primcount < 0)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kNegativePrimcount);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativePrimcount);
             return false;
         }
 
@@ -899,7 +899,7 @@
     {
         if (primcount < 0)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kNegativePrimcount);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativePrimcount);
             return false;
         }
 
@@ -949,7 +949,7 @@
         }
     }
 
-    context->validationError(entryPoint, GL_INVALID_OPERATION, kNoZeroDivisor);
+    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNoZeroDivisor);
     return false;
 }
 
@@ -1063,7 +1063,7 @@
 {
     if (width < 0 || height < 0 || depth < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeSize);
         return false;
     }
     // TexSubImage parameters can be NPOT without textureNPOT extension,
@@ -1073,13 +1073,13 @@
     if (!isSubImage && !hasNPOTSupport &&
         (level != 0 && (!isPow2(width) || !isPow2(height) || !isPow2(depth))))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureNotPow2);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kTextureNotPow2);
         return false;
     }
 
     if (!ValidMipLevel(context, target, level))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
         return false;
     }
 
@@ -1276,7 +1276,7 @@
     if (formatInfo.internalFormat == GL_NONE)
     {
         UNREACHABLE();
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInternalErrorFormatNotFound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInternalErrorFormatNotFound);
         return false;
     }
     const Extents size(width, height, depth);
@@ -1286,7 +1286,7 @@
     GLuint endByte  = 0;
     if (!formatInfo.computePackUnpackEndByte(type, size, unpack, targetIs3D, &endByte))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kIntegerOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kIntegerOverflow);
         return false;
     }
 
@@ -1300,13 +1300,13 @@
             (checkedEndByte.ValueOrDie() > static_cast<size_t>(pixelUnpackBuffer->getSize())))
         {
             // Overflow past the end of the buffer
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kIntegerOverflow);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kIntegerOverflow);
             return false;
         }
         if (pixelUnpackBuffer->hasWebGLXFBBindingConflict(context->isWebGL()))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kPixelUnpackBufferBoundForTransformFeedback);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                   kPixelUnpackBufferBoundForTransformFeedback);
             return false;
         }
     }
@@ -1315,13 +1315,13 @@
         ASSERT(imageSize >= 0);
         if (pixels == nullptr && imageSize != 0)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kImageSizeMustBeZero);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kImageSizeMustBeZero);
             return false;
         }
 
         if (pixels != nullptr && endByte > static_cast<GLuint>(imageSize))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kImageSizeTooSmall);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kImageSizeTooSmall);
             return false;
         }
     }
@@ -1367,7 +1367,7 @@
     constexpr GLsizei kMaxWebGLStride = 255;
     if (stride > kMaxWebGLStride)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kStrideExceedsWebGLLimit);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kStrideExceedsWebGLLimit);
         return false;
     }
 
@@ -1382,13 +1382,13 @@
     size_t sizeMask = (typeSize - 1);
     if ((reinterpret_cast<intptr_t>(ptr) & sizeMask) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kOffsetMustBeMultipleOfType);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kOffsetMustBeMultipleOfType);
         return false;
     }
 
     if ((stride & sizeMask) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kStrideMustBeMultipleOfType);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kStrideMustBeMultipleOfType);
         return false;
     }
 
@@ -1410,11 +1410,11 @@
     {
         if (context->getShader(id))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kExpectedProgramName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExpectedProgramName);
         }
         else
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProgramName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidProgramName);
         }
     }
 
@@ -1441,11 +1441,11 @@
     {
         if (context->getProgramNoResolveLink(id))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kExpectedShaderName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExpectedShaderName);
         }
         else
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidShaderName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidShaderName);
         }
     }
 
@@ -1460,7 +1460,7 @@
     {
         if (context->getClientMajorVersion() < 3 && !context->getExtensions().drawBuffersEXT)
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidAttachment);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidAttachment);
             return false;
         }
 
@@ -1468,7 +1468,7 @@
         const int colorAttachment = (attachment - GL_COLOR_ATTACHMENT0_EXT);
         if (colorAttachment >= context->getCaps().maxColorAttachments)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidAttachment);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidAttachment);
             return false;
         }
     }
@@ -1484,13 +1484,13 @@
             case GL_DEPTH_STENCIL_ATTACHMENT:
                 if (!context->isWebGL() && context->getClientMajorVersion() < 3)
                 {
-                    context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidAttachment);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidAttachment);
                     return false;
                 }
                 break;
 
             default:
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidAttachment);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidAttachment);
                 return false;
         }
     }
@@ -1511,13 +1511,13 @@
         case GL_RENDERBUFFER:
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidRenderbufferTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidRenderbufferTarget);
             return false;
     }
 
     if (width < 0 || height < 0 || samples < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidRenderbufferWidthHeight);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidRenderbufferWidthHeight);
         return false;
     }
 
@@ -1527,7 +1527,7 @@
     const TextureCaps &formatCaps = context->getTextureCaps().get(convertedInternalFormat);
     if (!formatCaps.renderbuffer)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidRenderbufferInternalFormat);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidRenderbufferInternalFormat);
         return false;
     }
 
@@ -1537,20 +1537,20 @@
     const InternalFormat &formatInfo = GetSizedInternalFormatInfo(convertedInternalFormat);
     if (formatInfo.internalFormat == GL_NONE)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidRenderbufferInternalFormat);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidRenderbufferInternalFormat);
         return false;
     }
 
     if (std::max(width, height) > context->getCaps().maxRenderbufferSize)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxRenderbufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxRenderbufferSize);
         return false;
     }
 
     RenderbufferID id = context->getState().getRenderbufferId();
     if (id.value == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidRenderbufferTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidRenderbufferTarget);
         return false;
     }
 
@@ -1577,13 +1577,13 @@
         case GL_LINEAR:
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kBlitInvalidFilter);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kBlitInvalidFilter);
             return false;
     }
 
     if ((mask & ~(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kBlitInvalidMask);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kBlitInvalidMask);
         return false;
     }
 
@@ -1591,7 +1591,7 @@
     // color buffer, leaving only nearest being unfiltered from above
     if ((mask & ~GL_COLOR_BUFFER_BIT) != 0 && filter != GL_NEAREST)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBlitOnlyNearestForNonColor);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBlitOnlyNearestForNonColor);
         return false;
     }
 
@@ -1601,8 +1601,7 @@
 
     if (!readFramebuffer || !drawFramebuffer)
     {
-        context->validationError(entryPoint, GL_INVALID_FRAMEBUFFER_OPERATION,
-                                 kBlitFramebufferMissing);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_FRAMEBUFFER_OPERATION, kBlitFramebufferMissing);
         return false;
     }
 
@@ -1620,7 +1619,7 @@
     if ((mask & GL_COLOR_BUFFER_BIT) != 0 &&
         (readFramebuffer->hasYUVAttachment() || drawFramebuffer->hasYUVAttachment()))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBlitYUVFramebuffer);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBlitYUVFramebuffer);
         return false;
     }
 
@@ -1631,7 +1630,7 @@
         ((drawFramebuffer->id() != Framebuffer::kDefaultDrawFramebufferHandle) ||
          (context->getCurrentDrawSurface() == context->getCurrentReadSurface())))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBlitFeedbackLoop);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBlitFeedbackLoop);
         return false;
     }
 
@@ -1647,7 +1646,7 @@
     if (DifferenceCanOverflow(srcX0, srcX1) || DifferenceCanOverflow(srcY0, srcY1) ||
         DifferenceCanOverflow(dstX0, dstX1) || DifferenceCanOverflow(dstY0, dstY1))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kBlitDimensionsOutOfRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kBlitDimensionsOutOfRange);
         return false;
     }
 
@@ -1693,45 +1692,43 @@
 
                         if (readFixedOrFloat != drawFixedOrFloat)
                         {
-                            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                     kBlitTypeMismatchFixedOrFloat);
+                            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                                   kBlitTypeMismatchFixedOrFloat);
                             return false;
                         }
                     }
                     else if (readFixedPoint != drawFixedPoint)
                     {
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kBlitTypeMismatchFixedPoint);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBlitTypeMismatchFixedPoint);
                         return false;
                     }
 
                     if (readComponentType == GL_UNSIGNED_INT &&
                         drawComponentType != GL_UNSIGNED_INT)
                     {
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kBlitTypeMismatchUnsignedInteger);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                               kBlitTypeMismatchUnsignedInteger);
                         return false;
                     }
 
                     if (readComponentType == GL_INT && drawComponentType != GL_INT)
                     {
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kBlitTypeMismatchSignedInteger);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                               kBlitTypeMismatchSignedInteger);
                         return false;
                     }
 
                     if (readColorBuffer->getResourceSamples() > 0 &&
                         (!Format::EquivalentForBlit(readFormat, drawFormat) || !sameBounds))
                     {
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kBlitMultisampledFormatOrBoundsMismatch);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                               kBlitMultisampledFormatOrBoundsMismatch);
                         return false;
                     }
 
                     if (context->isWebGL() && *readColorBuffer == *attachment)
                     {
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kBlitSameImageColor);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBlitSameImageColor);
                         return false;
                     }
                 }
@@ -1739,8 +1736,7 @@
 
             if (readFormat.info->isInt() && filter == GL_LINEAR)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kBlitIntegerWithLinearFilter);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBlitIntegerWithLinearFilter);
                 return false;
             }
         }
@@ -1750,7 +1746,7 @@
         // situation is an application error that would lead to a crash in ANGLE.
         else if (drawFramebuffer->hasEnabledDrawBuffer())
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kBlitMissingColor);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBlitMissingColor);
             return false;
         }
     }
@@ -1770,30 +1766,26 @@
             {
                 if (!Format::EquivalentForBlit(readBuffer->getFormat(), drawBuffer->getFormat()))
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kBlitDepthOrStencilFormatMismatch);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBlitDepthOrStencilFormatMismatch);
                     return false;
                 }
 
                 if (readBuffer->getResourceSamples() > 0 && !sameBounds)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kBlitMultisampledBoundsMismatch);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBlitMultisampledBoundsMismatch);
                     return false;
                 }
 
                 if (context->isWebGL() && *readBuffer == *drawBuffer)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kBlitSameImageDepthOrStencil);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBlitSameImageDepthOrStencil);
                     return false;
                 }
             }
             // WebGL 2.0 BlitFramebuffer when blitting from a missing attachment
             else if (drawBuffer)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kBlitMissingDepthOrStencil);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBlitMissingDepthOrStencil);
                 return false;
             }
         }
@@ -1805,12 +1797,12 @@
     // views in the current read framebuffer is more than one.
     if (readFramebuffer->readDisallowedByMultiview())
     {
-        context->validationError(entryPoint, GL_INVALID_FRAMEBUFFER_OPERATION, kBlitFromMultiview);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_FRAMEBUFFER_OPERATION, kBlitFromMultiview);
         return false;
     }
     if (drawFramebuffer->isMultiview())
     {
-        context->validationError(entryPoint, GL_INVALID_FRAMEBUFFER_OPERATION, kBlitToMultiview);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_FRAMEBUFFER_OPERATION, kBlitToMultiview);
         return false;
     }
 
@@ -1824,14 +1816,14 @@
 {
     if (!ValidFramebufferTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFramebufferTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFramebufferTarget);
         return false;
     }
 
     if (!context->getState().isBindGeneratesResourceEnabled() &&
         !context->isFramebufferGenerated(framebuffer))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kObjectNotGenerated);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kObjectNotGenerated);
         return false;
     }
 
@@ -1845,14 +1837,14 @@
 {
     if (target != GL_RENDERBUFFER)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidRenderbufferTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidRenderbufferTarget);
         return false;
     }
 
     if (!context->getState().isBindGeneratesResourceEnabled() &&
         !context->isRenderbufferGenerated(renderbuffer))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kObjectNotGenerated);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kObjectNotGenerated);
         return false;
     }
 
@@ -1867,7 +1859,7 @@
 {
     if (!ValidFramebufferTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFramebufferTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFramebufferTarget);
         return false;
     }
 
@@ -1878,7 +1870,7 @@
             GLint maxWidth = context->getCaps().maxFramebufferWidth;
             if (param < 0 || param > maxWidth)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsFramebufferWidth);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsFramebufferWidth);
                 return false;
             }
             break;
@@ -1888,7 +1880,7 @@
             GLint maxHeight = context->getCaps().maxFramebufferHeight;
             if (param < 0 || param > maxHeight)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsFramebufferHeight);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsFramebufferHeight);
                 return false;
             }
             break;
@@ -1898,7 +1890,7 @@
             GLint maxSamples = context->getCaps().maxFramebufferSamples;
             if (param < 0 || param > maxSamples)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsFramebufferSamples);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsFramebufferSamples);
                 return false;
             }
             break;
@@ -1912,14 +1904,13 @@
             if (!context->getExtensions().geometryShaderAny() &&
                 context->getClientVersion() < ES_3_2)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kGeometryShaderExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kGeometryShaderExtensionNotEnabled);
                 return false;
             }
             GLint maxLayers = context->getCaps().maxFramebufferLayers;
             if (param < 0 || param > maxLayers)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFramebufferLayer);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidFramebufferLayer);
                 return false;
             }
             break;
@@ -1928,14 +1919,14 @@
         {
             if (!context->getExtensions().framebufferFlipYMESA)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
                 return false;
             }
             break;
         }
         default:
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
             return false;
         }
     }
@@ -1944,7 +1935,7 @@
     ASSERT(framebuffer);
     if (framebuffer->isDefault())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kDefaultFramebuffer);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDefaultFramebuffer);
         return false;
     }
     return true;
@@ -1959,13 +1950,13 @@
 {
     if (!ValidFramebufferTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFramebufferTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFramebufferTarget);
         return false;
     }
 
     if (renderbuffertarget != GL_RENDERBUFFER)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidRenderbufferTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidRenderbufferTarget);
         return false;
     }
 
@@ -1974,7 +1965,7 @@
     ASSERT(framebuffer);
     if (framebuffer->isDefault())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kDefaultFramebufferTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDefaultFramebufferTarget);
         return false;
     }
 
@@ -1991,7 +1982,7 @@
     {
         if (!context->getRenderbuffer(renderbuffer))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidRenderbufferTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidRenderbufferTarget);
             return false;
         }
     }
@@ -2008,7 +1999,7 @@
 {
     if (!ValidFramebufferTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFramebufferTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFramebufferTarget);
         return false;
     }
 
@@ -2023,13 +2014,13 @@
 
         if (tex == nullptr)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kMissingTexture);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMissingTexture);
             return false;
         }
 
         if (level < 0)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
             return false;
         }
 
@@ -2045,7 +2036,7 @@
         {
             if (level >= static_cast<GLint>(tex->getImmutableLevels()))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
                 return false;
             }
         }
@@ -2056,15 +2047,14 @@
              context->getExtensions().textureBufferAny()) &&
             tex->getType() == TextureType::Buffer)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureTarget);
             return false;
         }
 
         if (tex->getState().hasProtectedContent() != context->getState().hasProtectedContent())
         {
-            context->validationError(
-                entryPoint, GL_INVALID_OPERATION,
-                "Mismatch between Texture and Context Protected Content state");
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                   "Mismatch between Texture and Context Protected Content state");
             return false;
         }
     }
@@ -2074,7 +2064,7 @@
 
     if (framebuffer->isDefault())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kDefaultFramebufferTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDefaultFramebufferTarget);
         return false;
     }
 
@@ -2087,7 +2077,7 @@
 {
     if (!ValidTextureTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
@@ -2095,7 +2085,7 @@
 
     if (texture == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureNotBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureNotBound);
         return false;
     }
 
@@ -2105,7 +2095,7 @@
     // that out-of-range base level has a non-color-renderable / non-texture-filterable format.
     if (effectiveBaseLevel >= IMPLEMENTATION_MAX_TEXTURE_LEVELS)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBaseLevelOutOfRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBaseLevelOutOfRange);
         return false;
     }
 
@@ -2116,7 +2106,7 @@
     if (format.sizedInternalFormat == GL_NONE || format.compressed || format.depthBits > 0 ||
         format.stencilBits > 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kGenerateMipmapNotAllowed);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kGenerateMipmapNotAllowed);
         return false;
     }
 
@@ -2127,7 +2117,7 @@
         format.textureAttachmentSupport(context->getClientVersion(), context->getExtensions());
     if (!formatUnsized && !formatColorRenderableAndFilterable)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kGenerateMipmapNotAllowed);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kGenerateMipmapNotAllowed);
         return false;
     }
 
@@ -2135,7 +2125,7 @@
     // generation
     if (format.colorEncoding == GL_SRGB && format.format == GL_RGB)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kGenerateMipmapNotAllowed);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kGenerateMipmapNotAllowed);
         return false;
     }
 
@@ -2143,7 +2133,7 @@
     // generateMipmap is not allowed if texture format is SRGB_EXT or SRGB_ALPHA_EXT.
     if (context->getClientVersion() < Version(3, 0) && format.colorEncoding == GL_SRGB)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kGenerateMipmapNotAllowed);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kGenerateMipmapNotAllowed);
         return false;
     }
 
@@ -2154,21 +2144,21 @@
     {
         ASSERT(target == TextureType::_2D || target == TextureType::Rectangle ||
                target == TextureType::CubeMap);
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureNotPow2);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureNotPow2);
         return false;
     }
 
     // Cube completeness check
     if (target == TextureType::CubeMap && !texture->getTextureState().isCubeComplete())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kCubemapIncomplete);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kCubemapIncomplete);
         return false;
     }
 
     if (context->isWebGL() && (texture->getWidth(baseTarget, effectiveBaseLevel) == 0 ||
                                texture->getHeight(baseTarget, effectiveBaseLevel) == 0))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kGenerateMipmapZeroSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kGenerateMipmapZeroSize);
         return false;
     }
 
@@ -2229,7 +2219,7 @@
 {
     if (bufSize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBufferSize);
         return false;
     }
 
@@ -2286,7 +2276,7 @@
     if (!context->getExtensions().occlusionQueryBooleanEXT &&
         !context->getExtensions().disjointTimerQueryEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
         return false;
     }
 
@@ -2301,7 +2291,7 @@
     if (!context->getExtensions().occlusionQueryBooleanEXT &&
         !context->getExtensions().disjointTimerQueryEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
         return false;
     }
 
@@ -2313,7 +2303,7 @@
     if (!context->getExtensions().occlusionQueryBooleanEXT &&
         !context->getExtensions().disjointTimerQueryEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
         return false;
     }
 
@@ -2327,13 +2317,13 @@
 {
     if (!ValidQueryType(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidQueryType);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidQueryType);
         return false;
     }
 
     if (id.value == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidQueryId);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidQueryId);
         return false;
     }
 
@@ -2355,14 +2345,14 @@
 
     if (context->getState().isQueryActive(target))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kOtherQueryActive);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kOtherQueryActive);
         return false;
     }
 
     // check that name was obtained with glGenQueries
     if (!context->isQueryGenerated(id))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidQueryId);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidQueryId);
         return false;
     }
 
@@ -2370,7 +2360,7 @@
     Query *queryObject = context->getQuery(id);
     if (queryObject && queryObject->getType() != target)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kQueryTargetMismatch);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kQueryTargetMismatch);
         return false;
     }
 
@@ -2386,7 +2376,7 @@
         !context->getExtensions().disjointTimerQueryEXT &&
         !context->getExtensions().syncQueryCHROMIUM)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
         return false;
     }
 
@@ -2397,7 +2387,7 @@
 {
     if (!ValidQueryType(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidQueryType);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidQueryType);
         return false;
     }
 
@@ -2405,7 +2395,7 @@
 
     if (queryObject == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kQueryInactive);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kQueryInactive);
         return false;
     }
 
@@ -2418,7 +2408,7 @@
         !context->getExtensions().disjointTimerQueryEXT &&
         !context->getExtensions().syncQueryCHROMIUM)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
         return false;
     }
 
@@ -2432,19 +2422,19 @@
 {
     if (!context->getExtensions().disjointTimerQueryEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (target != QueryType::Timestamp)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidQueryTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidQueryTarget);
         return false;
     }
 
     if (!context->isQueryGenerated(id))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidQueryId);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidQueryId);
         return false;
     }
 
@@ -2452,7 +2442,7 @@
     Query *queryObject = context->getQuery(id);
     if (queryObject && context->getState().isQueryActive(queryObject))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kQueryActive);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kQueryActive);
         return false;
     }
 
@@ -2472,7 +2462,7 @@
 
     if (!ValidQueryType(context, target) && target != QueryType::Timestamp)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidQueryType);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidQueryType);
         return false;
     }
 
@@ -2481,7 +2471,7 @@
         case GL_CURRENT_QUERY_EXT:
             if (target == QueryType::Timestamp)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidQueryTarget);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidQueryTarget);
                 return false;
             }
             break;
@@ -2489,12 +2479,12 @@
             if (!context->getExtensions().disjointTimerQueryEXT ||
                 (target != QueryType::Timestamp && target != QueryType::TimeElapsed))
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
                 return false;
             }
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
             return false;
     }
 
@@ -2517,7 +2507,7 @@
         !context->getExtensions().disjointTimerQueryEXT &&
         !context->getExtensions().syncQueryCHROMIUM)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2567,7 +2557,7 @@
 
     if (context->isContextLost())
     {
-        context->validationError(entryPoint, GL_CONTEXT_LOST, kContextLost);
+        ANGLE_VALIDATION_ERROR(GL_CONTEXT_LOST, kContextLost);
 
         if (pname == GL_QUERY_RESULT_AVAILABLE_EXT)
         {
@@ -2585,13 +2575,13 @@
 
     if (!queryObject)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidQueryId);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidQueryId);
         return false;
     }
 
     if (context->getState().isQueryActive(queryObject))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kQueryActive);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kQueryActive);
         return false;
     }
 
@@ -2602,7 +2592,7 @@
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
 
@@ -2617,7 +2607,7 @@
 {
     if (!context->getExtensions().disjointTimerQueryEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     return ValidateGetQueryObjectValueBase(context, entryPoint, id, pname, nullptr);
@@ -2633,7 +2623,7 @@
 {
     if (!context->getExtensions().disjointTimerQueryEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2669,7 +2659,7 @@
         !context->getExtensions().occlusionQueryBooleanEXT &&
         !context->getExtensions().syncQueryCHROMIUM)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     return ValidateGetQueryObjectValueBase(context, entryPoint, id, pname, nullptr);
@@ -2687,7 +2677,7 @@
         !context->getExtensions().occlusionQueryBooleanEXT &&
         !context->getExtensions().syncQueryCHROMIUM)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2721,7 +2711,7 @@
 {
     if (!context->getExtensions().disjointTimerQueryEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     return ValidateGetQueryObjectValueBase(context, entryPoint, id, pname, nullptr);
@@ -2737,7 +2727,7 @@
 {
     if (!context->getExtensions().disjointTimerQueryEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2771,7 +2761,7 @@
 {
     if (!context->getExtensions().disjointTimerQueryEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     return ValidateGetQueryObjectValueBase(context, entryPoint, id, pname, nullptr);
@@ -2787,7 +2777,7 @@
 {
     if (!context->getExtensions().disjointTimerQueryEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2823,19 +2813,19 @@
     // TODO(Jiajia): Add image uniform check in future.
     if (count < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeCount);
         return false;
     }
 
     if (!program)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidProgramName);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidProgramName);
         return false;
     }
 
     if (!program->isLinked())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotLinked);
         return false;
     }
 
@@ -2849,7 +2839,7 @@
     size_t castedLocation        = static_cast<size_t>(location.value);
     if (castedLocation >= uniformLocations.size())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidUniformLocation);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidUniformLocation);
         return false;
     }
 
@@ -2862,7 +2852,7 @@
 
     if (!uniformLocation.used())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidUniformLocation);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidUniformLocation);
         return false;
     }
 
@@ -2871,7 +2861,7 @@
     // attempting to write an array to a non-array uniform is an INVALID_OPERATION
     if (count > 1 && !uniform.isArray())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidUniformCount);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidUniformCount);
         return false;
     }
 
@@ -2901,15 +2891,14 @@
         {
             if (value[i] < 0 || value[i] >= max)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kSamplerUniformValueOutOfRange);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kSamplerUniformValueOutOfRange);
                 return false;
             }
         }
         return true;
     }
 
-    context->validationError(entryPoint, GL_INVALID_OPERATION, kUniformTypeMismatch);
+    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kUniformTypeMismatch);
     return false;
 }
 
@@ -2924,7 +2913,7 @@
         return true;
     }
 
-    context->validationError(entryPoint, GL_INVALID_OPERATION, kUniformTypeMismatch);
+    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kUniformTypeMismatch);
     return false;
 }
 
@@ -2963,7 +2952,7 @@
 {
     if (ConvertToBool(transpose) && context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kES3Required);
         return false;
     }
 
@@ -2982,7 +2971,7 @@
 {
     if (!context->getQueryParameterInfo(pname, nativeType, numParams))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
         return false;
     }
 
@@ -2994,7 +2983,7 @@
 
         if (colorAttachment >= caps.maxDrawBuffers)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kIndexExceedsMaxDrawBuffer);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kIndexExceedsMaxDrawBuffer);
             return false;
         }
     }
@@ -3010,15 +2999,14 @@
         case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
             if (!context->getExtensions().textureStorageMultisample2dArrayOES)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kMultisampleArrayExtensionRequired);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kMultisampleArrayExtensionRequired);
                 return false;
             }
             break;
         case GL_TEXTURE_BINDING_RECTANGLE_ANGLE:
             if (!context->getExtensions().textureRectangleANGLE)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -3026,7 +3014,7 @@
             if (!context->getExtensions().EGLStreamConsumerExternalNV &&
                 !context->getExtensions().EGLImageExternalOES)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -3037,8 +3025,7 @@
             if (context->getClientVersion() < Version(3, 2) &&
                 !context->getExtensions().textureBufferAny())
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kTextureBufferExtensionNotAvailable);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kTextureBufferExtensionNotAvailable);
                 return false;
             }
             break;
@@ -3057,14 +3044,14 @@
 
             if (readFramebuffer->getReadBufferState() == GL_NONE)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kReadBufferNone);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kReadBufferNone);
                 return false;
             }
 
             const FramebufferAttachment *attachment = readFramebuffer->getReadColorAttachment();
             if (!attachment)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kReadBufferNotAttached);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kReadBufferNotAttached);
                 return false;
             }
         }
@@ -3073,7 +3060,7 @@
         case GL_PRIMITIVE_BOUNDING_BOX:
             if (!context->getExtensions().primitiveBoundingBoxAny())
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
                 return false;
             }
             break;
@@ -3081,7 +3068,7 @@
         case GL_SHADING_RATE_QCOM:
             if (!context->getExtensions().shadingRateQCOM)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
                 return false;
             }
             break;
@@ -3226,7 +3213,7 @@
             RenderbufferID renderbuffer = PackParam<RenderbufferID>(name);
             if (!context->isRenderbuffer(renderbuffer))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidRenderbufferName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidRenderbufferName);
                 return false;
             }
             break;
@@ -3240,20 +3227,20 @@
             TextureID texture = PackParam<TextureID>(name);
             if (!context->isTexture(texture))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidTextureName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureName);
                 return false;
             }
 
             Texture *textureObject = context->getTexture(texture);
             if (textureObject && textureObject->getType() != PackParam<TextureType>(target))
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, err::kTextureTypeMismatch);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, err::kTextureTypeMismatch);
                 return false;
             }
             break;
         }
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTarget);
             return false;
     }
 
@@ -3271,7 +3258,7 @@
         {
             if (level != 0)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
                 return false;
             }
             break;
@@ -3284,13 +3271,13 @@
         {
             if (!ValidMipLevel(context, PackParam<TextureType>(target), level))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
                 return false;
             }
             break;
         }
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTarget);
             return false;
     }
 
@@ -3313,7 +3300,7 @@
     // of the corresponding image object.
     if (offsetX < 0 || offsetY < 0 || offsetZ < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeOffset);
         return false;
     }
 
@@ -3324,7 +3311,7 @@
         Renderbuffer *buffer = context->getRenderbuffer(PackParam<RenderbufferID>(name));
         if ((buffer->getWidth() - offsetX < width) || (buffer->getHeight() - offsetY < height))
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kSourceTextureTooSmall);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kSourceTextureTooSmall);
             return false;
         }
     }
@@ -3338,7 +3325,7 @@
         // compleness rules.
         if (!texture->isSamplerCompleteForCopyImage(context, nullptr))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kNotTextureComplete);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNotTextureComplete);
             return false;
         }
 
@@ -3358,7 +3345,7 @@
         // boundaries of the corresponding image object
         if ((textureWidth - offsetX < width) || (textureHeight - offsetY < height))
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kSourceTextureTooSmall);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kSourceTextureTooSmall);
             return false;
         }
 
@@ -3382,7 +3369,7 @@
     if ((width % formatInfo.compressedBlockWidth != 0) ||
         (height % formatInfo.compressedBlockHeight != 0))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidCompressedRegionSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidCompressedRegionSize);
         return false;
     }
 
@@ -3422,7 +3409,7 @@
             return *texture->getFormat(PackParam<TextureTarget>(textureTargetToUse), level).info;
         }
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTarget);
             return defaultInternalFormat;
     }
 }
@@ -3709,7 +3696,7 @@
     // of the corresponding image object
     if ((srcWidth < 0) || (srcHeight < 0) || (srcDepth < 0))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeSize);
         return false;
     }
 
@@ -3742,7 +3729,7 @@
 
     if (srcFormatInfo.internalFormat == GL_NONE || dstFormatInfo.internalFormat == GL_NONE)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidTextureLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureLevel);
         return false;
     }
 
@@ -3808,14 +3795,14 @@
     // size of compressed image is not equal to the texel size of the compressed image.
     if (!ValidateCopyFormatCompatible(srcFormatInfo, dstFormatInfo))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kIncompatibleTextures);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kIncompatibleTextures);
         return false;
     }
 
     // INVALID_OPERATION is generated if the source and destination number of samples do not match
     if (srcSamples != dstSamples)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kSamplesOutOfRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kSamplesOutOfRange);
         return false;
     }
 
@@ -3842,39 +3829,39 @@
 
     if (xoffset < 0 || yoffset < 0 || zoffset < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeOffset);
         return false;
     }
 
     if (width < 0 || height < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeSize);
         return false;
     }
 
     if (std::numeric_limits<GLsizei>::max() - xoffset < width ||
         std::numeric_limits<GLsizei>::max() - yoffset < height)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kOffsetOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kOffsetOverflow);
         return false;
     }
 
     if (std::numeric_limits<GLint>::max() - width < x ||
         std::numeric_limits<GLint>::max() - height < y)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kIntegerOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIntegerOverflow);
         return false;
     }
 
     if (border != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidBorder);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidBorder);
         return false;
     }
 
     if (!ValidMipLevel(context, texType, level))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
         return false;
     }
 
@@ -3895,7 +3882,7 @@
 
     if (readFramebuffer->getReadBufferState() == GL_NONE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kReadBufferNone);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kReadBufferNone);
         return false;
     }
 
@@ -3906,13 +3893,13 @@
     const FramebufferAttachment *source = readFramebuffer->getReadColorAttachment();
     if (source == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kMissingReadAttachment);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMissingReadAttachment);
         return false;
     }
 
     if (source->isYUV())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kCopyFromYUVFramebuffer);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kCopyFromYUVFramebuffer);
         return false;
     }
 
@@ -3923,8 +3910,7 @@
     // is greater than 1.
     if (readFramebuffer->readDisallowedByMultiview())
     {
-        context->validationError(entryPoint, GL_INVALID_FRAMEBUFFER_OPERATION,
-                                 kMultiviewReadFramebuffer);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_FRAMEBUFFER_OPERATION, kMultiviewReadFramebuffer);
         return false;
     }
 
@@ -3955,20 +3941,20 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
             return false;
     }
 
     Texture *texture = state.getTargetTexture(texType);
     if (!texture)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureNotBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureNotBound);
         return false;
     }
 
     if (texture->getImmutableFormat() && !isSubImage)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureIsImmutable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureIsImmutable);
         return false;
     }
 
@@ -3978,7 +3964,7 @@
 
     if (formatInfo.depthBits > 0 || formatInfo.compressed)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormat);
         return false;
     }
 
@@ -3988,7 +3974,7 @@
             static_cast<size_t>(yoffset + height) > texture->getHeight(target, level) ||
             static_cast<size_t>(zoffset) >= texture->getDepth(target, level))
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kOffsetOverflow);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kOffsetOverflow);
             return false;
         }
     }
@@ -3997,14 +3983,13 @@
         if ((texType == TextureType::CubeMap || texType == TextureType::CubeMapArray) &&
             width != height)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kCubemapIncomplete);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kCubemapIncomplete);
             return false;
         }
 
         if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions()))
         {
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                      internalformat);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, internalformat);
             return false;
         }
 
@@ -4012,7 +3997,7 @@
         if (static_cast<int>(width) > maxLevelDimension ||
             static_cast<int>(height) > maxLevelDimension)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
             return false;
         }
     }
@@ -4028,7 +4013,7 @@
     {
         if (readFramebuffer->formsCopyingFeedbackLoopWith(texture->id(), level, zoffset))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kFeedbackLoop);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kFeedbackLoop);
             return false;
         }
     }
@@ -4428,8 +4413,7 @@
         if (!ValidateTransformFeedbackPrimitiveMode(context, entryPoint,
                                                     curTransformFeedback->getPrimitiveMode(), mode))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kInvalidDrawModeTransformFeedback);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidDrawModeTransformFeedback);
             return;
         }
     }
@@ -4453,8 +4437,7 @@
         case PrimitiveMode::TriangleStripAdjacency:
             if (!extensions.geometryShaderAny() && context->getClientVersion() < ES_3_2)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kGeometryShaderExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kGeometryShaderExtensionNotEnabled);
                 return;
             }
             break;
@@ -4462,14 +4445,13 @@
         case PrimitiveMode::Patches:
             if (!extensions.tessellationShaderEXT && context->getClientVersion() < ES_3_2)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kTessellationShaderExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kTessellationShaderExtensionNotEnabled);
                 return;
             }
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDrawMode);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidDrawMode);
             return;
     }
 
@@ -4485,23 +4467,23 @@
             if (!IsCompatibleDrawModeWithGeometryShader(
                     mode, executable->getGeometryShaderInputPrimitiveType()))
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kIncompatibleDrawModeAgainstGeometryShader);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                       kIncompatibleDrawModeAgainstGeometryShader);
                 return;
             }
         }
 
         if (executable->hasLinkedTessellationShader() && mode != PrimitiveMode::Patches)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kIncompatibleDrawModeWithTessellationShader);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                   kIncompatibleDrawModeWithTessellationShader);
             return;
         }
 
         if (!executable->hasLinkedTessellationShader() && mode == PrimitiveMode::Patches)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kIncompatibleDrawModeWithoutTessellationShader);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                   kIncompatibleDrawModeWithoutTessellationShader);
             return;
         }
     }
@@ -4519,7 +4501,7 @@
 {
     if (!context->getExtensions().instancedArraysANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -4540,7 +4522,7 @@
 {
     if (!context->getExtensions().instancedArraysEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -4609,7 +4591,7 @@
 {
     if (!context->getExtensions().instancedArraysANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -4632,7 +4614,7 @@
 {
     if (!context->getExtensions().instancedArraysEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -4652,7 +4634,7 @@
 {
     if (program.value == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kProgramDoesNotExist);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kProgramDoesNotExist);
         return false;
     }
 
@@ -4664,13 +4646,13 @@
 
     if (!programObject || !programObject->isLinked())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotLinked);
         return false;
     }
 
     if (!programObject->isValidUniformLocation(location))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidUniformLocation);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidUniformLocation);
         return false;
     }
 
@@ -4696,7 +4678,7 @@
 
     if (bufSize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kNegativeBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNegativeBufferSize);
         return false;
     }
 
@@ -4708,7 +4690,7 @@
     size_t requiredBytes         = VariableExternalSize(uniform.type);
     if (static_cast<size_t>(bufSize) < requiredBytes)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInsufficientBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInsufficientBufferSize);
         return false;
     }
 
@@ -4842,7 +4824,7 @@
 
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4868,7 +4850,7 @@
 {
     if (numAttachments < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeAttachments);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeAttachments);
         return false;
     }
 
@@ -4878,16 +4860,14 @@
         {
             if (defaultFramebuffer)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kDefaultFramebufferInvalidAttachment);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kDefaultFramebufferInvalidAttachment);
                 return false;
             }
 
             if (attachments[i] >=
                 GL_COLOR_ATTACHMENT0 + static_cast<GLuint>(context->getCaps().maxColorAttachments))
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kExceedsMaxColorAttachments);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExceedsMaxColorAttachments);
                 return false;
             }
         }
@@ -4900,8 +4880,8 @@
                 case GL_DEPTH_STENCIL_ATTACHMENT:
                     if (defaultFramebuffer)
                     {
-                        context->validationError(entryPoint, GL_INVALID_ENUM,
-                                                 kDefaultFramebufferInvalidAttachment);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM,
+                                               kDefaultFramebufferInvalidAttachment);
                         return false;
                     }
                     break;
@@ -4910,13 +4890,13 @@
                 case GL_STENCIL:
                     if (!defaultFramebuffer)
                     {
-                        context->validationError(entryPoint, GL_INVALID_ENUM,
-                                                 kDefaultFramebufferAttachmentOnUserFBO);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM,
+                                               kDefaultFramebufferAttachmentOnUserFBO);
                         return false;
                     }
                     break;
                 default:
-                    context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidAttachment);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidAttachment);
                     return false;
             }
         }
@@ -4934,7 +4914,7 @@
     {
         // The debug marker calls should not set error state
         // However, it seems reasonable to set an error state if the extension is not enabled
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -4961,7 +4941,7 @@
     {
         // The debug marker calls should not set error state
         // However, it seems reasonable to set an error state if the extension is not enabled
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -4987,22 +4967,20 @@
     ASSERT(context->getDisplay());
     if (!context->getDisplay()->isValidImage(imageID))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidEGLImage);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidEGLImage);
         return false;
     }
 
     egl::Image *imageObject = context->getDisplay()->getImage(imageID);
     if (imageObject->getSamples() > 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kEGLImageCannotCreate2DMultisampled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kEGLImageCannotCreate2DMultisampled);
         return false;
     }
 
     if (!imageObject->isTexturable(context))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kEGLImageTextureFormatNotSupported);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kEGLImageTextureFormatNotSupported);
         return false;
     }
 
@@ -5010,42 +4988,42 @@
     size_t depth = static_cast<size_t>(imageObject->getExtents().depth);
     if (imageObject->isYUV() && type != TextureType::External)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 "Image is YUV, target must be TEXTURE_EXTERNAL_OES");
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                               "Image is YUV, target must be TEXTURE_EXTERNAL_OES");
         return false;
     }
 
     if (depth > 1 && type != TextureType::_2DArray && type != TextureType::CubeMap &&
         type != TextureType::CubeMapArray && type != TextureType::_3D)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kEGLImageTextureTargetMismatch);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kEGLImageTextureTargetMismatch);
         return false;
     }
 
     if (imageObject->isCubeMap() && type != TextureType::CubeMapArray &&
         (type != TextureType::CubeMap || depth > gl::kCubeFaceCount))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kEGLImageTextureTargetMismatch);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kEGLImageTextureTargetMismatch);
         return false;
     }
 
     if (imageObject->getLevelCount() > 1 && type == TextureType::External)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kEGLImageTextureTargetMismatch);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kEGLImageTextureTargetMismatch);
         return false;
     }
 
     // 3d EGLImages are currently not supported
     if (type == TextureType::_3D)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kEGLImageTextureTargetMismatch);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kEGLImageTextureTargetMismatch);
         return false;
     }
 
     if (imageObject->hasProtectedContent() && !context->getState().hasProtectedContent())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 "Mismatch between Image and Context Protected Content state");
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                               "Mismatch between Image and Context Protected Content state");
         return false;
     }
 
@@ -5059,7 +5037,7 @@
 {
     if (!context->getExtensions().EGLImageOES && !context->getExtensions().EGLImageExternalOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -5068,29 +5046,26 @@
         case TextureType::_2D:
             if (!context->getExtensions().EGLImageOES)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                          ToGLenum(type));
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, ToGLenum(type));
             }
             break;
 
         case TextureType::_2DArray:
             if (!context->getExtensions().EGLImageArrayEXT)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                          ToGLenum(type));
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, ToGLenum(type));
             }
             break;
 
         case TextureType::External:
             if (!context->getExtensions().EGLImageExternalOES)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                          ToGLenum(type));
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, ToGLenum(type));
             }
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
             return false;
     }
 
@@ -5104,7 +5079,7 @@
 {
     if (!context->getExtensions().EGLImageOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -5114,29 +5089,28 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidRenderbufferTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidRenderbufferTarget);
             return false;
     }
 
     ASSERT(context->getDisplay());
     if (!context->getDisplay()->isValidImage(image))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidEGLImage);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidEGLImage);
         return false;
     }
 
     egl::Image *imageObject = context->getDisplay()->getImage(image);
     if (!imageObject->isRenderable(context))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kEGLImageRenderbufferFormatNotSupported);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kEGLImageRenderbufferFormatNotSupported);
         return false;
     }
 
     if (imageObject->hasProtectedContent() != context->getState().hasProtectedContent())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 "Mismatch between Image and Context Protected Content state");
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                               "Mismatch between Image and Context Protected Content state");
         return false;
     }
 
@@ -5160,14 +5134,14 @@
     if (std::find(programBinaryFormats.begin(), programBinaryFormats.end(), binaryFormat) ==
         programBinaryFormats.end())
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProgramBinaryFormat);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidProgramBinaryFormat);
         return false;
     }
 
     if (context->hasActiveTransformFeedback(program))
     {
         // ES 3.0.4 section 2.15 page 91
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kTransformFeedbackProgramBinary);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTransformFeedbackProgramBinary);
         return false;
     }
 
@@ -5190,13 +5164,13 @@
 
     if (!programObject->isLinked())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotLinked);
         return false;
     }
 
     if (context->getCaps().programBinaryFormats.empty())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kNoProgramBinaryFormats);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNoProgramBinaryFormats);
         return false;
     }
 
@@ -5211,12 +5185,12 @@
     // INVALID_VALUE is generated if n is negative or greater than value of MAX_DRAW_BUFFERS
     if (n < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeCount);
         return false;
     }
     if (n > context->getCaps().maxDrawBuffers)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
         return false;
     }
 
@@ -5240,12 +5214,12 @@
             // was changed to GL_INVALID_ENUM in 3.1, which dEQP also expects.
             // 3.1 is still a bit ambiguous about the error, but future specs are
             // expected to clarify that GL_INVALID_ENUM is the correct error.
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDrawBuffer);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidDrawBuffer);
             return false;
         }
         else if (bufs[colorAttachment] >= maxColorAttachment)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kExceedsMaxColorAttachments);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExceedsMaxColorAttachments);
             return false;
         }
         else if (bufs[colorAttachment] != GL_NONE && bufs[colorAttachment] != attachment &&
@@ -5253,7 +5227,7 @@
         {
             // INVALID_OPERATION-GL is bound to buffer and ith argument
             // is not COLOR_ATTACHMENTi or NONE
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidDrawBufferValue);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidDrawBufferValue);
             return false;
         }
     }
@@ -5264,15 +5238,13 @@
     {
         if (n != 1)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kInvalidDrawBufferCountForDefault);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidDrawBufferCountForDefault);
             return false;
         }
 
         if (bufs[0] != GL_NONE && bufs[0] != GL_BACK)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kDefaultFramebufferInvalidDrawBuffer);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDefaultFramebufferInvalidDrawBuffer);
             return false;
         }
     }
@@ -5294,7 +5266,7 @@
 
     if (!context->isValidBufferBinding(target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBufferTypes);
         return false;
     }
 
@@ -5304,7 +5276,7 @@
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
 
@@ -5313,7 +5285,7 @@
     // GLES 3.1 section 6.6 explicitly specifies this error.
     if (context->getState().getTargetBuffer(target) == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferPointerNotAvailable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferPointerNotAvailable);
         return false;
     }
 
@@ -5331,7 +5303,7 @@
 {
     if (!context->isValidBufferBinding(target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBufferTypes);
         return false;
     }
 
@@ -5339,7 +5311,7 @@
 
     if (buffer == nullptr || !buffer->isMapped())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotMapped);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferNotMapped);
         return false;
     }
 
@@ -5355,19 +5327,19 @@
 {
     if (!context->isValidBufferBinding(target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBufferTypes);
         return false;
     }
 
     if (offset < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeOffset);
         return false;
     }
 
     if (length < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeLength);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeLength);
         return false;
     }
 
@@ -5375,7 +5347,7 @@
 
     if (!buffer)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotMappable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferNotMappable);
         return false;
     }
 
@@ -5385,7 +5357,7 @@
 
     if (!checkedSize.IsValid() || checkedSize.ValueOrDie() > static_cast<size_t>(buffer->getSize()))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kMapOutOfRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kMapOutOfRange);
         return false;
     }
 
@@ -5402,7 +5374,7 @@
 
         if ((access & ~kBufferStorageAccessBits) != 0)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidAccessBits);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidAccessBits);
             return false;
         }
 
@@ -5414,32 +5386,32 @@
         GLbitfield accessFlags = access & kBufferStorageMatchedAccessBits;
         if ((accessFlags & buffer->getStorageExtUsageFlags()) != accessFlags)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidAccessBits);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidAccessBits);
             return false;
         }
     }
     else if ((access & ~kAllAccessBits) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidAccessBits);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidAccessBits);
         return false;
     }
 
     if (length == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kLengthZero);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kLengthZero);
         return false;
     }
 
     if (buffer->isMapped())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferAlreadyMapped);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferAlreadyMapped);
         return false;
     }
 
     // Check for invalid bit combinations
     if ((access & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidAccessBitsReadWrite);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidAccessBitsReadWrite);
         return false;
     }
 
@@ -5448,13 +5420,13 @@
 
     if ((access & GL_MAP_READ_BIT) != 0 && (access & writeOnlyBits) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidAccessBitsRead);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidAccessBitsRead);
         return false;
     }
 
     if ((access & GL_MAP_WRITE_BIT) == 0 && (access & GL_MAP_FLUSH_EXPLICIT_BIT) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidAccessBitsFlush);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidAccessBitsFlush);
         return false;
     }
 
@@ -5469,19 +5441,19 @@
 {
     if (offset < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeOffset);
         return false;
     }
 
     if (length < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeLength);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeLength);
         return false;
     }
 
     if (!context->isValidBufferBinding(target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBufferTypes);
         return false;
     }
 
@@ -5489,13 +5461,13 @@
 
     if (buffer == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFlushZero);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFlushZero);
         return false;
     }
 
     if (!buffer->isMapped() || (buffer->getAccessFlags() & GL_MAP_FLUSH_EXPLICIT_BIT) == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFlushTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFlushTarget);
         return false;
     }
 
@@ -5506,7 +5478,7 @@
     if (!checkedSize.IsValid() ||
         checkedSize.ValueOrDie() > static_cast<size_t>(buffer->getMapLength()))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFlushOutOfRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidFlushOutOfRange);
         return false;
     }
 
@@ -5517,7 +5489,7 @@
 {
     if (n < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeCount);
         return false;
     }
     return true;
@@ -5527,13 +5499,13 @@
 {
     if (!context->getExtensions().robustClientMemoryANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (bufSize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBufferSize);
         return false;
     }
 
@@ -5547,7 +5519,7 @@
 {
     if (bufSize < numParams)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInsufficientParams);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInsufficientParams);
         return false;
     }
 
@@ -5563,7 +5535,7 @@
 {
     if (!ValidFramebufferTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFramebufferTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFramebufferTarget);
         return false;
     }
 
@@ -5582,7 +5554,7 @@
             if (clientVersion < 3 ||
                 !(context->getExtensions().multiviewOVR || context->getExtensions().multiview2OVR))
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -5590,7 +5562,7 @@
         case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT:
             if (!context->getExtensions().multisampledRenderToTextureEXT)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -5598,7 +5570,7 @@
         case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
             if (clientVersion < 3 && !context->getExtensions().sRGBEXT)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -5608,7 +5580,7 @@
                 !context->getExtensions().colorBufferFloatRgbCHROMIUM &&
                 !context->getExtensions().colorBufferFloatRgbaCHROMIUM)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -5622,7 +5594,7 @@
         case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
             if (clientVersion < 3)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kES3Required);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kES3Required);
                 return false;
             }
             break;
@@ -5631,14 +5603,13 @@
             if (!context->getExtensions().geometryShaderAny() &&
                 context->getClientVersion() < ES_3_2)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kGeometryShaderExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kGeometryShaderExtensionNotEnabled);
                 return false;
             }
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
             return false;
     }
 
@@ -5650,7 +5621,7 @@
         case GL_STENCIL:
             if (clientVersion < 3)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidAttachment);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidAttachment);
                 return false;
             }
             break;
@@ -5658,7 +5629,7 @@
         case GL_DEPTH_STENCIL_ATTACHMENT:
             if (clientVersion < 3 && !context->isWebGL1())
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidAttachment);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidAttachment);
                 return false;
             }
             break;
@@ -5674,7 +5645,7 @@
                 (attachment - GL_COLOR_ATTACHMENT0_EXT) >=
                     static_cast<GLuint>(context->getCaps().maxColorAttachments))
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidAttachment);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidAttachment);
                 return false;
             }
             break;
@@ -5687,7 +5658,7 @@
     {
         if (clientVersion < 3)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kDefaultFramebufferTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDefaultFramebufferTarget);
             return false;
         }
 
@@ -5699,7 +5670,7 @@
                 break;
 
             default:
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidAttachment);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidAttachment);
                 return false;
         }
     }
@@ -5720,14 +5691,13 @@
                 case GL_DEPTH_STENCIL_ATTACHMENT:
                     if (!framebuffer->hasValidDepthStencil() && !context->isWebGL1())
                     {
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kInvalidAttachment);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidAttachment);
                         return false;
                     }
                     break;
 
                 default:
-                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidAttachment);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidAttachment);
                     return false;
             }
         }
@@ -5746,8 +5716,7 @@
                 if (attachmentObject->type() != GL_RENDERBUFFER &&
                     attachmentObject->type() != GL_TEXTURE)
                 {
-                    context->validationError(entryPoint, GL_INVALID_ENUM,
-                                             kFramebufferIncompleteAttachment);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kFramebufferIncompleteAttachment);
                     return false;
                 }
                 break;
@@ -5755,8 +5724,7 @@
             case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
                 if (attachmentObject->type() != GL_TEXTURE)
                 {
-                    context->validationError(entryPoint, GL_INVALID_ENUM,
-                                             kFramebufferIncompleteAttachment);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kFramebufferIncompleteAttachment);
                     return false;
                 }
                 break;
@@ -5764,8 +5732,7 @@
             case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
                 if (attachmentObject->type() != GL_TEXTURE)
                 {
-                    context->validationError(entryPoint, GL_INVALID_ENUM,
-                                             kFramebufferIncompleteAttachment);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kFramebufferIncompleteAttachment);
                     return false;
                 }
                 break;
@@ -5773,7 +5740,7 @@
             case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
                 if (attachment == GL_DEPTH_STENCIL_ATTACHMENT)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidAttachment);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidAttachment);
                     return false;
                 }
                 break;
@@ -5781,8 +5748,7 @@
             case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
                 if (attachmentObject->type() != GL_TEXTURE)
                 {
-                    context->validationError(entryPoint, GL_INVALID_ENUM,
-                                             kFramebufferIncompleteAttachment);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kFramebufferIncompleteAttachment);
                     return false;
                 }
                 break;
@@ -5808,8 +5774,7 @@
             case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
                 if (clientVersion < 3)
                 {
-                    context->validationError(entryPoint, GL_INVALID_ENUM,
-                                             kInvalidFramebufferAttachmentParameter);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFramebufferAttachmentParameter);
                     return false;
                 }
                 break;
@@ -5817,14 +5782,13 @@
             default:
                 if (clientVersion < 3)
                 {
-                    context->validationError(entryPoint, GL_INVALID_ENUM,
-                                             kInvalidFramebufferAttachmentParameter);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFramebufferAttachmentParameter);
                     return false;
                 }
                 else
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kInvalidFramebufferAttachmentParameter);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                           kInvalidFramebufferAttachmentParameter);
                     return false;
                 }
         }
@@ -5846,7 +5810,7 @@
 {
     if (!ValidFramebufferTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFramebufferTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFramebufferTarget);
         return false;
     }
 
@@ -5861,20 +5825,19 @@
             if (!context->getExtensions().geometryShaderAny() &&
                 context->getClientVersion() < ES_3_2)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kGeometryShaderExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kGeometryShaderExtensionNotEnabled);
                 return false;
             }
             break;
         case GL_FRAMEBUFFER_FLIP_Y_MESA:
             if (!context->getExtensions().framebufferFlipYMESA)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
                 return false;
             }
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
             return false;
     }
 
@@ -5883,7 +5846,7 @@
 
     if (framebuffer->isDefault())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kDefaultFramebuffer);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDefaultFramebuffer);
         return false;
     }
     return true;
@@ -5993,7 +5956,7 @@
 
     if (context->isContextLost())
     {
-        context->validationError(entryPoint, GL_CONTEXT_LOST, kContextLost);
+        ANGLE_VALIDATION_ERROR(GL_CONTEXT_LOST, kContextLost);
 
         if (context->getExtensions().parallelShaderCompileKHR && pname == GL_COMPLETION_STATUS_KHR)
         {
@@ -6033,7 +5996,7 @@
             if (context->getClientMajorVersion() < 3 &&
                 !context->getExtensions().getProgramBinaryOES)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -6046,7 +6009,7 @@
         case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
             if (context->getClientMajorVersion() < 3)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES30);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumRequiresGLES30);
                 return false;
             }
             break;
@@ -6055,7 +6018,7 @@
         case GL_ACTIVE_ATOMIC_COUNTER_BUFFERS:
             if (context->getClientVersion() < Version(3, 1))
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumRequiresGLES31);
                 return false;
             }
             break;
@@ -6063,7 +6026,7 @@
         case GL_COMPUTE_WORK_GROUP_SIZE:
             if (context->getClientVersion() < Version(3, 1))
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumRequiresGLES31);
                 return false;
             }
 
@@ -6073,13 +6036,12 @@
             // form a compute shader.
             if (!programObject->isLinked())
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotLinked);
                 return false;
             }
             if (!programObject->getExecutable().hasLinkedShaderStage(ShaderType::Compute))
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kNoActiveComputeShaderStage);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNoActiveComputeShaderStage);
                 return false;
             }
             break;
@@ -6091,8 +6053,7 @@
             if (!context->getExtensions().geometryShaderAny() &&
                 context->getClientVersion() < ES_3_2)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kGeometryShaderExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kGeometryShaderExtensionNotEnabled);
                 return false;
             }
 
@@ -6103,13 +6064,12 @@
             // successfully, or which does not contain objects to form a geometry shader.
             if (!programObject->isLinked())
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotLinked);
                 return false;
             }
             if (!programObject->getExecutable().hasLinkedShaderStage(ShaderType::Geometry))
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kNoActiveGeometryShaderStage);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNoActiveGeometryShaderStage);
                 return false;
             }
             break;
@@ -6117,7 +6077,7 @@
         case GL_COMPLETION_STATUS_KHR:
             if (!context->getExtensions().parallelShaderCompileKHR)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
                 return false;
             }
             break;
@@ -6129,18 +6089,17 @@
             if (!context->getExtensions().tessellationShaderEXT &&
                 context->getClientVersion() < ES_3_2)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kTessellationShaderExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kTessellationShaderExtensionNotEnabled);
                 return false;
             }
             if (!programObject->isLinked())
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotLinked);
                 return false;
             }
             break;
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
 
@@ -6736,7 +6695,7 @@
         const GLenum *end    = validComponentTypes + validComponentTypeCount;
         if (std::find(validComponentTypes, end, componentType) == end)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kNoDefinedClearConversion);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNoDefinedClearConversion);
             return false;
         }
     }
@@ -6759,7 +6718,7 @@
     {
         if (dataSize < imageSize)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kCompressedDataSizeTooSmall);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kCompressedDataSizeTooSmall);
         }
     }
     return true;
@@ -6779,7 +6738,7 @@
 
     if (!context->isValidBufferBinding(target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBufferTypes);
         return false;
     }
 
@@ -6787,7 +6746,7 @@
     if (!buffer)
     {
         // A null buffer means that "0" is bound to the requested buffer target
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferNotBound);
         return false;
     }
 
@@ -6802,7 +6761,7 @@
         case GL_BUFFER_ACCESS_OES:
             if (!extensions.mapbufferOES)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -6812,7 +6771,7 @@
             if (context->getClientMajorVersion() < 3 && !extensions.mapbufferOES &&
                 !extensions.mapBufferRangeEXT)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -6820,7 +6779,7 @@
         case GL_BUFFER_MAP_POINTER:
             if (!pointerVersion)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidMapPointerQuery);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidMapPointerQuery);
                 return false;
             }
             break;
@@ -6830,7 +6789,7 @@
         case GL_BUFFER_MAP_LENGTH:
             if (context->getClientMajorVersion() < 3 && !extensions.mapBufferRangeEXT)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -6838,7 +6797,7 @@
         case GL_MEMORY_SIZE_ANGLE:
             if (!context->getExtensions().memorySizeANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
                 return false;
             }
             break;
@@ -6846,14 +6805,14 @@
         case GL_RESOURCE_INITIALIZED_ANGLE:
             if (!context->getExtensions().robustResourceInitializationANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kRobustResourceInitializationExtensionRequired);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM,
+                                       kRobustResourceInitializationExtensionRequired);
                 return false;
             }
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
 
@@ -6879,14 +6838,14 @@
 
     if (target != GL_RENDERBUFFER)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidRenderbufferTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidRenderbufferTarget);
         return false;
     }
 
     Renderbuffer *renderbuffer = context->getState().getCurrentRenderbuffer();
     if (renderbuffer == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kRenderbufferNotBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kRenderbufferNotBound);
         return false;
     }
 
@@ -6907,7 +6866,7 @@
             if (context->getClientMajorVersion() < 3 &&
                 !context->getExtensions().framebufferMultisampleANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
                 return false;
             }
             break;
@@ -6915,7 +6874,7 @@
         case GL_MEMORY_SIZE_ANGLE:
             if (!context->getExtensions().memorySizeANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
                 return false;
             }
             break;
@@ -6924,7 +6883,7 @@
         case GL_IMPLEMENTATION_COLOR_READ_TYPE:
             if (!context->getExtensions().getImageANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kGetImageExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kGetImageExtensionNotEnabled);
                 return false;
             }
             break;
@@ -6932,14 +6891,14 @@
         case GL_RESOURCE_INITIALIZED_ANGLE:
             if (!context->getExtensions().robustResourceInitializationANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kRobustResourceInitializationExtensionRequired);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM,
+                                       kRobustResourceInitializationExtensionRequired);
                 return false;
             }
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
 
@@ -6963,7 +6922,7 @@
 
     if (context->isContextLost())
     {
-        context->validationError(entryPoint, GL_CONTEXT_LOST, kContextLost);
+        ANGLE_VALIDATION_ERROR(GL_CONTEXT_LOST, kContextLost);
 
         if (context->getExtensions().parallelShaderCompileKHR && pname == GL_COMPLETION_STATUS_KHR)
         {
@@ -6994,7 +6953,7 @@
         case GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE:
             if (!context->getExtensions().translatedShaderSourceANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
                 return false;
             }
             break;
@@ -7002,13 +6961,13 @@
         case GL_COMPLETION_STATUS_KHR:
             if (!context->getExtensions().parallelShaderCompileKHR)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
                 return false;
             }
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
 
@@ -7033,20 +6992,20 @@
     if ((!ValidTextureTarget(context, target) && !ValidTextureExternalTarget(context, target)) ||
         target == TextureType::Buffer)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
     if (context->getTextureByType(target) == nullptr)
     {
         // Should only be possible for external textures
-        context->validationError(entryPoint, GL_INVALID_ENUM, kTextureNotBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kTextureNotBound);
         return false;
     }
 
     if (context->getClientMajorVersion() == 1 && !IsValidGLES1TextureParameter(pname))
     {
-        context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+        ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
         return false;
     }
 
@@ -7061,7 +7020,7 @@
         case GL_TEXTURE_USAGE_ANGLE:
             if (!context->getExtensions().textureUsageANGLE)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -7076,7 +7035,7 @@
         case GL_TEXTURE_IMMUTABLE_FORMAT:
             if (context->getClientMajorVersion() < 3 && !context->getExtensions().textureStorageEXT)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -7093,7 +7052,7 @@
         case GL_TEXTURE_MAX_LOD:
             if (context->getClientMajorVersion() < 3)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES30);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumRequiresGLES30);
                 return false;
             }
             break;
@@ -7102,7 +7061,7 @@
         case GL_TEXTURE_COMPARE_FUNC:
             if (context->getClientMajorVersion() < 3 && !context->getExtensions().shadowSamplersEXT)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -7110,7 +7069,7 @@
         case GL_TEXTURE_SRGB_DECODE_EXT:
             if (!context->getExtensions().textureSRGBDecodeEXT)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -7119,7 +7078,7 @@
             if (context->getClientVersion() < ES_3_1 &&
                 !context->getExtensions().stencilTexturingANGLE)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -7127,7 +7086,7 @@
         case GL_IMAGE_FORMAT_COMPATIBILITY_TYPE:
             if (context->getClientVersion() < ES_3_1)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumRequiresGLES31);
                 return false;
             }
             break;
@@ -7138,7 +7097,7 @@
             // after GL_OES_draw_texture functionality implemented
             if (context->getClientMajorVersion() > 1)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kGLES1Only);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kGLES1Only);
                 return false;
             }
             break;
@@ -7146,7 +7105,7 @@
         case GL_MEMORY_SIZE_ANGLE:
             if (!context->getExtensions().memorySizeANGLE)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -7155,7 +7114,7 @@
             if (!context->getExtensions().textureBorderClampAny() &&
                 context->getClientVersion() < ES_3_2)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
                 return false;
             }
             break;
@@ -7163,7 +7122,7 @@
         case GL_TEXTURE_NATIVE_ID_ANGLE:
             if (!context->getExtensions().textureExternalUpdateANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
                 return false;
             }
             break;
@@ -7172,7 +7131,7 @@
         case GL_IMPLEMENTATION_COLOR_READ_TYPE:
             if (!context->getExtensions().getImageANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kGetImageExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kGetImageExtensionNotEnabled);
                 return false;
             }
             break;
@@ -7180,8 +7139,8 @@
         case GL_RESOURCE_INITIALIZED_ANGLE:
             if (!context->getExtensions().robustResourceInitializationANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kRobustResourceInitializationExtensionRequired);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM,
+                                       kRobustResourceInitializationExtensionRequired);
                 return false;
             }
             break;
@@ -7189,8 +7148,7 @@
         case GL_TEXTURE_PROTECTED_EXT:
             if (!context->getExtensions().protectedTexturesEXT)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kProtectedTexturesExtensionRequired);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kProtectedTexturesExtensionRequired);
                 return false;
             }
             break;
@@ -7199,7 +7157,7 @@
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
 
@@ -7225,13 +7183,13 @@
 
     if (pureIntegerEntryPoint && context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (index >= static_cast<GLuint>(context->getCaps().maxVertexAttributes))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxVertexAttribute);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxVertexAttribute);
         return false;
     }
 
@@ -7239,7 +7197,7 @@
     {
         if (pname != GL_VERTEX_ATTRIB_ARRAY_POINTER)
         {
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
         }
     }
@@ -7263,8 +7221,7 @@
                 if (context->getClientMajorVersion() < 3 &&
                     !context->getExtensions().instancedArraysAny())
                 {
-                    context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                              pname);
+                    ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                     return false;
                 }
                 break;
@@ -7272,8 +7229,7 @@
             case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
                 if (context->getClientMajorVersion() < 3)
                 {
-                    context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                              pname);
+                    ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                     return false;
                 }
                 break;
@@ -7282,13 +7238,13 @@
             case GL_VERTEX_ATTRIB_RELATIVE_OFFSET:
                 if (context->getClientVersion() < ES_3_1)
                 {
-                    context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumRequiresGLES31);
                     return false;
                 }
                 break;
 
             default:
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
         }
     }
@@ -7325,14 +7281,13 @@
     if (pixelPackBuffer != nullptr && pixelPackBuffer->isMapped())
     {
         // ...the buffer object's data store is currently mapped.
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferMapped);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferMapped);
         return false;
     }
     if (pixelPackBuffer != nullptr &&
         pixelPackBuffer->hasWebGLXFBBindingConflict(context->isWebGL()))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kPixelPackBufferBoundForTransformFeedback);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPixelPackBufferBoundForTransformFeedback);
         return false;
     }
 
@@ -7345,7 +7300,7 @@
     GLuint endByte = 0;
     if (!formatInfo.computePackUnpackEndByte(type, size, pack, false, &endByte))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kIntegerOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kIntegerOverflow);
         return false;
     }
 
@@ -7353,7 +7308,7 @@
     {
         if (pixelPackBuffer == nullptr && static_cast<size_t>(bufSize) < endByte)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInsufficientBufferSize);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInsufficientBufferSize);
             return false;
         }
     }
@@ -7367,7 +7322,7 @@
         if (checkedEndByte.ValueOrDie() > static_cast<size_t>(pixelPackBuffer->getSize()))
         {
             // Overflow past the end of the buffer
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kParamOverflow);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kParamOverflow);
             return false;
         }
     }
@@ -7376,7 +7331,7 @@
     {
         if (endByte > static_cast<size_t>(std::numeric_limits<GLsizei>::max()))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kIntegerOverflow);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kIntegerOverflow);
             return false;
         }
 
@@ -7394,8 +7349,7 @@
         GLint dataStoreWidth = pack.rowLength ? pack.rowLength : width;
         if (pack.skipPixels + width > dataStoreWidth)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kInvalidPackParametersForWebGL);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidPackParametersForWebGL);
             return false;
         }
     }
@@ -7432,7 +7386,7 @@
 
     if (width < 0 || height < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeSize);
         return false;
     }
 
@@ -7454,7 +7408,7 @@
 
     if (readFramebuffer->getReadBufferState() == GL_NONE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kReadBufferNone);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kReadBufferNone);
         return false;
     }
 
@@ -7478,8 +7432,7 @@
     // the number of views in the current read framebuffer is more than one.
     if (readFramebuffer->readDisallowedByMultiview())
     {
-        context->validationError(entryPoint, GL_INVALID_FRAMEBUFFER_OPERATION,
-                                 kMultiviewReadFramebuffer);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_FRAMEBUFFER_OPERATION, kMultiviewReadFramebuffer);
         return false;
     }
 
@@ -7494,13 +7447,13 @@
         // dEQP/WebGL.
         if (!ValidReadPixelsFormatEnum(context, format))
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFormat);
             return false;
         }
 
         if (!ValidReadPixelsTypeEnum(context, type))
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidType);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidType);
             return false;
         }
     }
@@ -7511,7 +7464,7 @@
     // situation is an application error that would lead to a crash in ANGLE.
     if (readBuffer == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kMissingReadAttachment);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMissingReadAttachment);
         return false;
     }
 
@@ -7536,7 +7489,7 @@
 
     if (!(currentFormat == format && currentType == type) && !validFormatTypeCombination)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
         return false;
     }
 
@@ -7579,14 +7532,14 @@
     GLsizei writtenColumns = 0;
     if (!getClippedExtent(x, width, readBuffer->getSize().width, &writtenColumns))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kIntegerOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kIntegerOverflow);
         return false;
     }
 
     GLsizei writtenRows = 0;
     if (!getClippedExtent(y, height, readBuffer->getSize().height, &writtenRows))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kIntegerOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kIntegerOverflow);
         return false;
     }
 
@@ -7615,27 +7568,27 @@
     if ((!ValidTextureTarget(context, target) && !ValidTextureExternalTarget(context, target)) ||
         target == TextureType::Buffer)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
     if (context->getTextureByType(target) == nullptr)
     {
         // Should only be possible for external textures
-        context->validationError(entryPoint, GL_INVALID_ENUM, kTextureNotBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kTextureNotBound);
         return false;
     }
 
     const GLsizei minBufSize = GetTexParameterCount(pname);
     if (bufSize >= 0 && bufSize < minBufSize)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInsufficientBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInsufficientBufferSize);
         return false;
     }
 
     if (context->getClientMajorVersion() == 1 && !IsValidGLES1TextureParameter(pname))
     {
-        context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+        ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
         return false;
     }
 
@@ -7655,18 +7608,18 @@
             if (context->getClientMajorVersion() < 3 &&
                 !(pname == GL_TEXTURE_WRAP_R && context->getExtensions().texture3DOES))
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kES3Required);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kES3Required);
                 return false;
             }
             if (target == TextureType::External &&
                 !context->getExtensions().EGLImageExternalEssl3OES)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             if (target == TextureType::VideoImage && !context->getExtensions().videoTextureWEBGL)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             }
             break;
 
@@ -7674,7 +7627,7 @@
         case GL_TEXTURE_CROP_RECT_OES:
             if (context->getClientMajorVersion() > 1)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kGLES1Only);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kGLES1Only);
                 return false;
             }
             break;
@@ -7697,7 +7650,7 @@
             case GL_TEXTURE_COMPARE_MODE:
             case GL_TEXTURE_COMPARE_FUNC:
             case GL_TEXTURE_BORDER_COLOR:
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
                 return false;
         }
     }
@@ -7739,7 +7692,7 @@
         case GL_TEXTURE_USAGE_ANGLE:
             if (!context->getExtensions().textureUsageANGLE)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
 
@@ -7750,8 +7703,7 @@
                     break;
 
                 default:
-                    context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                              pname);
+                    ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                     return false;
             }
             break;
@@ -7801,8 +7753,7 @@
                     break;
 
                 default:
-                    context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                              pname);
+                    ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                     return false;
             }
             break;
@@ -7810,24 +7761,24 @@
         case GL_TEXTURE_BASE_LEVEL:
             if (ConvertToGLint(params[0]) < 0)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kBaseLevelNegative);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kBaseLevelNegative);
                 return false;
             }
             if (target == TextureType::External && static_cast<GLuint>(params[0]) != 0)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kBaseLevelNonZero);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBaseLevelNonZero);
                 return false;
             }
             if ((target == TextureType::_2DMultisample ||
                  target == TextureType::_2DMultisampleArray) &&
                 static_cast<GLuint>(params[0]) != 0)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kBaseLevelNonZero);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBaseLevelNonZero);
                 return false;
             }
             if (target == TextureType::Rectangle && static_cast<GLuint>(params[0]) != 0)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kBaseLevelNonZero);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBaseLevelNonZero);
                 return false;
             }
             break;
@@ -7835,7 +7786,7 @@
         case GL_TEXTURE_MAX_LEVEL:
             if (ConvertToGLint(params[0]) < 0)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
                 return false;
             }
             break;
@@ -7844,7 +7795,7 @@
             if (context->getClientVersion() < ES_3_1 &&
                 !context->getExtensions().stencilTexturingANGLE)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             switch (ConvertToGLenum(params[0]))
@@ -7854,8 +7805,7 @@
                     break;
 
                 default:
-                    context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                              pname);
+                    ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                     return false;
             }
             break;
@@ -7877,7 +7827,7 @@
         case GL_GENERATE_MIPMAP:
             if (context->getClientMajorVersion() > 1)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kGLES1Only);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kGLES1Only);
                 return false;
             }
             break;
@@ -7885,12 +7835,12 @@
         case GL_TEXTURE_CROP_RECT_OES:
             if (context->getClientMajorVersion() > 1)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kGLES1Only);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kGLES1Only);
                 return false;
             }
             if (!vectorParams)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kInsufficientBufferSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInsufficientBufferSize);
                 return false;
             }
             break;
@@ -7899,12 +7849,12 @@
             if (!context->getExtensions().textureBorderClampAny() &&
                 context->getClientVersion() < ES_3_2)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
                 return false;
             }
             if (!vectorParams)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInsufficientBufferSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInsufficientBufferSize);
                 return false;
             }
             break;
@@ -7912,8 +7862,8 @@
         case GL_RESOURCE_INITIALIZED_ANGLE:
             if (!context->getExtensions().robustResourceInitializationANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kRobustResourceInitializationExtensionRequired);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM,
+                                       kRobustResourceInitializationExtensionRequired);
                 return false;
             }
             break;
@@ -7921,14 +7871,13 @@
         case GL_TEXTURE_PROTECTED_EXT:
             if (!context->getExtensions().protectedTexturesEXT)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kProtectedTexturesExtensionRequired);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kProtectedTexturesExtensionRequired);
                 return false;
             }
             if (ConvertToBool(params[0]) != context->getState().hasProtectedContent())
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         "Protected Texture must match Protected Context");
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                       "Protected Texture must match Protected Context");
                 return false;
             }
             break;
@@ -7936,13 +7885,13 @@
         case GL_RENDERABILITY_VALIDATION_ANGLE:
             if (!context->getExtensions().renderabilityValidationANGLE)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
 
@@ -7985,7 +7934,7 @@
 
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -7997,8 +7946,7 @@
 
     if (uniformBlockIndex.value >= programObject->getActiveUniformBlockCount())
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE,
-                                 kIndexExceedsActiveUniformBlockCount);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsActiveUniformBlockCount);
         return false;
     }
 
@@ -8014,7 +7962,7 @@
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
 
@@ -8046,20 +7994,20 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (!context->isSampler(sampler))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidSampler);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidSampler);
         return false;
     }
 
     const GLsizei minBufSize = GetSamplerParameterCount(pname);
     if (bufSize >= 0 && bufSize < minBufSize)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInsufficientBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInsufficientBufferSize);
         return false;
     }
 
@@ -8128,18 +8076,18 @@
             if (!context->getExtensions().textureBorderClampAny() &&
                 context->getClientVersion() < ES_3_2)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
                 return false;
             }
             if (!vectorParams)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInsufficientBufferSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInsufficientBufferSize);
                 return false;
             }
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
 
@@ -8181,13 +8129,13 @@
 
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (!context->isSampler(sampler))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidSampler);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidSampler);
         return false;
     }
 
@@ -8214,7 +8162,7 @@
         case GL_TEXTURE_SRGB_DECODE_EXT:
             if (!context->getExtensions().textureSRGBDecodeEXT)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -8223,13 +8171,13 @@
             if (!context->getExtensions().textureBorderClampAny() &&
                 context->getClientVersion() < ES_3_2)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
                 return false;
             }
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
 
@@ -8255,14 +8203,14 @@
 
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     const TextureCaps &formatCaps = context->getTextureCaps().get(internalformat);
     if (!formatCaps.renderbuffer)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kFormatNotRenderable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kFormatNotRenderable);
         return false;
     }
 
@@ -8275,27 +8223,25 @@
             if (context->getClientVersion() < ES_3_1 &&
                 !context->getExtensions().textureMultisampleANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kMultisampleTextureExtensionOrES31Required);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kMultisampleTextureExtensionOrES31Required);
                 return false;
             }
             break;
         case GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES:
             if (!context->getExtensions().textureStorageMultisample2dArrayOES)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kMultisampleArrayExtensionRequired);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kMultisampleArrayExtensionRequired);
                 return false;
             }
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTarget);
             return false;
     }
 
     if (bufSize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInsufficientBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInsufficientBufferSize);
         return false;
     }
 
@@ -8311,7 +8257,7 @@
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
 
@@ -8334,8 +8280,7 @@
                       : framebuffer->getSamples(context);
     if (samples != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kInvalidMultisampledFramebufferOperation);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidMultisampledFramebufferOperation);
         return false;
     }
     return true;
@@ -8345,7 +8290,7 @@
 {
     if (texture < GL_TEXTURE0 || texture >= GL_TEXTURE0 + context->getCaps().maxMultitextureUnits)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidMultitextureUnit);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidMultitextureUnit);
         return false;
     }
     return true;
@@ -8362,20 +8307,20 @@
     const Caps &caps = context->getCaps();
     if (width > caps.max2DTextureSize || height > caps.max2DTextureSize)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureWidthOrHeightOutOfRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kTextureWidthOrHeightOutOfRange);
         return false;
     }
 
     if (samples == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kSamplesZero);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kSamplesZero);
         return false;
     }
 
     const TextureCaps &formatCaps = context->getTextureCaps().get(internalFormat);
     if (!formatCaps.textureAttachment)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kRenderableInternalFormat);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kRenderableInternalFormat);
         return false;
     }
 
@@ -8384,26 +8329,26 @@
     const InternalFormat &formatInfo = GetSizedInternalFormatInfo(internalFormat);
     if (formatInfo.internalFormat == GL_NONE)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kUnsizedInternalFormatUnsupported);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kUnsizedInternalFormatUnsupported);
         return false;
     }
 
     if (static_cast<GLuint>(samples) > formatCaps.getMaxSamples())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kSamplesOutOfRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kSamplesOutOfRange);
         return false;
     }
 
     Texture *texture = context->getTextureByType(target);
     if (!texture || texture->id().value == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kZeroBoundToTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kZeroBoundToTarget);
         return false;
     }
 
     if (texture->getImmutableFormat())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kImmutableTextureBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kImmutableTextureBound);
         return false;
     }
     return true;
@@ -8419,13 +8364,13 @@
 {
     if (target != TextureType::_2DMultisample)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTarget);
         return false;
     }
 
     if (width < 1 || height < 1)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureSizeTooSmall);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kTextureSizeTooSmall);
         return false;
     }
 
@@ -8450,19 +8395,19 @@
 
     if (!ValidTexLevelDestinationTarget(context, type))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
     if (context->getTextureByType(type) == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kTextureNotBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kTextureNotBound);
         return false;
     }
 
     if (!ValidMipLevel(context, type, level))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
         return false;
     }
 
@@ -8492,8 +8437,8 @@
         case GL_RESOURCE_INITIALIZED_ANGLE:
             if (!context->getExtensions().robustResourceInitializationANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kRobustResourceInitializationExtensionRequired);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM,
+                                       kRobustResourceInitializationExtensionRequired);
                 return false;
             }
             break;
@@ -8504,14 +8449,13 @@
             if (context->getClientVersion() < Version(3, 2) &&
                 !context->getExtensions().textureBufferAny())
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kTextureBufferExtensionNotAvailable);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kTextureBufferExtensionNotAvailable);
                 return false;
             }
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
             return false;
     }
 
@@ -8530,7 +8474,7 @@
 {
     if (pname != GL_SAMPLE_POSITION)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
         return false;
     }
 
@@ -8539,7 +8483,7 @@
 
     if (index >= static_cast<GLuint>(samples))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsSamples);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsSamples);
         return false;
     }
 
@@ -8553,7 +8497,7 @@
 {
     if (maskNumber >= static_cast<GLuint>(context->getCaps().maxSampleMaskWords))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSampleMaskNumber);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidSampleMaskNumber);
         return false;
     }
 
@@ -8568,13 +8512,13 @@
         context->getStateCache().getInstancedVertexElementLimit() ==
             VertexAttribute::kIntegerOverflow)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kIntegerOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kIntegerOverflow);
     }
     else
     {
         // [OpenGL ES 3.0.2] section 2.9.4 page 40:
         // We can return INVALID_OPERATION if our buffer does not have enough backing data.
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInsufficientVertexBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInsufficientVertexBufferSize);
     }
 }
 
@@ -8585,7 +8529,7 @@
 {
     if (!context->getExtensions().loseContextCHROMIUM)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -8597,7 +8541,7 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidResetStatus);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidResetStatus);
     }
 
     switch (other)
@@ -8608,7 +8552,7 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidResetStatus);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidResetStatus);
     }
 
     return true;
@@ -8628,14 +8572,14 @@
 {
     if (!context->getExtensions().textureExternalUpdateANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (!ValidTexture2DDestinationTarget(context, target) &&
         !ValidTextureExternalTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
@@ -8667,13 +8611,13 @@
 {
     if (!context->getExtensions().textureExternalUpdateANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (!ValidTextureTarget(context, target) && !ValidTextureExternalTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
@@ -8722,7 +8666,7 @@
         case LogicalOperation::Xor:
             return true;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidLogicOp);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidLogicOp);
             return false;
     }
 }

src/libANGLE/validationES.h

diff --git a/src/libANGLE/validationES.h b/src/libANGLE/validationES.h
index dbed063..7609d23 100644
--- a/src/libANGLE/validationES.h
+++ b/src/libANGLE/validationES.h
@@ -36,6 +36,11 @@
 class Program;
 class Shader;
 
+#define ANGLE_VALIDATION_ERROR(errorCode, message) \
+    context->getMutableErrorSetForValidation()->validationError(entryPoint, errorCode, message)
+#define ANGLE_VALIDATION_ERRORF(errorCode, ...) \
+    context->getMutableErrorSetForValidation()->validationErrorF(entryPoint, errorCode, __VA_ARGS__)
+
 void SetRobustLengthParam(const GLsizei *length, GLsizei value);
 bool ValidTextureTarget(const Context *context, TextureType type);
 bool ValidTexture2DTarget(const Context *context, TextureType type);
@@ -334,7 +339,7 @@
     // Do the cheaper test first, for a little extra speed.
     if (valueType != uniformType && VariableBoolVectorType(valueType) != uniformType)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, err::kUniformSizeMismatch);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kUniformSizeMismatch);
         return false;
     }
     return true;
@@ -438,7 +443,7 @@
     {
         const char *errorMessage = reinterpret_cast<const char *>(drawStatesError);
         GLenum errorCode         = context->getStateCache().getBasicDrawElementsErrorCode();
-        context->validationError(entryPoint, errorCode, errorMessage);
+        ANGLE_VALIDATION_ERROR(errorCode, errorMessage);
         return false;
     }
 
@@ -707,36 +712,33 @@
     const Caps &caps = context->getCaps();
     if (index >= static_cast<GLuint>(caps.maxVertexAttributes))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE,
-                                 err::kIndexExceedsMaxVertexAttribute);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, err::kIndexExceedsMaxVertexAttribute);
         return false;
     }
 
     switch (validation)
     {
         case VertexAttribTypeCase::Invalid:
-            context->validationError(entryPoint, GL_INVALID_ENUM, err::kInvalidType);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, err::kInvalidType);
             return false;
         case VertexAttribTypeCase::Valid:
             if (size < 1 || size > 4)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, err::kInvalidVertexAttrSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, err::kInvalidVertexAttrSize);
                 return false;
             }
             break;
         case VertexAttribTypeCase::ValidSize4Only:
             if (size != 4)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         err::kInvalidVertexAttribSize2101010);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kInvalidVertexAttribSize2101010);
                 return false;
             }
             break;
         case VertexAttribTypeCase::ValidSize3or4:
             if (size != 3 && size != 4)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         err::kInvalidVertexAttribSize1010102);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kInvalidVertexAttribSize1010102);
                 return false;
             }
             break;
@@ -937,7 +939,7 @@
     if (!framebufferStatus.isComplete())
     {
         ASSERT(framebufferStatus.reason != nullptr);
-        context->validationError(entryPoint, ErrorCode, framebufferStatus.reason);
+        ANGLE_VALIDATION_ERROR(ErrorCode, framebufferStatus.reason);
         return false;
     }
 
@@ -985,7 +987,7 @@
     int64_t maxVertex = static_cast<int64_t>(first) + static_cast<int64_t>(count) - 1;
     if (maxVertex > static_cast<int64_t>(std::numeric_limits<GLint>::max()))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, err::kIntegerOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kIntegerOverflow);
         return false;
     }
 
@@ -1019,7 +1021,7 @@
 {
     if (first < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, err::kNegativeStart);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, err::kNegativeStart);
         return false;
     }
 
@@ -1027,7 +1029,7 @@
     {
         if (count < 0)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, err::kNegativeCount);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, err::kNegativeCount);
             return false;
         }
 
@@ -1039,7 +1041,7 @@
     {
         if (primcount < 0)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, err::kNegativeCount);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, err::kNegativeCount);
             return false;
         }
         // Early exit.
@@ -1058,8 +1060,7 @@
         TransformFeedback *curTransformFeedback = state.getCurrentTransformFeedback();
         if (!curTransformFeedback->checkBufferSpaceForDraw(count, primcount))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     err::kTransformFeedbackBufferTooSmall);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kTransformFeedbackBufferTooSmall);
             return false;
         }
     }
@@ -1076,12 +1077,12 @@
     {
         if (type == DrawElementsType::UnsignedInt)
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, err::kTypeNotUnsignedShortByte);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, err::kTypeNotUnsignedShortByte);
             return false;
         }
 
         ASSERT(type == DrawElementsType::InvalidEnum);
-        context->validationErrorF(entryPoint, GL_INVALID_ENUM, err::kEnumInvalid);
+        ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, err::kEnumInvalid);
         return false;
     }
 
@@ -1090,7 +1091,7 @@
     {
         // All errors from ValidateDrawElementsStates return INVALID_OPERATION.
         const char *errorMessage = reinterpret_cast<const char *>(drawElementsError);
-        context->validationError(entryPoint, GL_INVALID_OPERATION, errorMessage);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, errorMessage);
         return false;
     }
 
@@ -1122,8 +1123,7 @@
             // [WebGL 1.0] Section 6.4 Buffer Offset and Stride Requirements
             // The offset arguments to drawElements and [...], must be a multiple of the size of the
             // data type passed to the call, or an INVALID_OPERATION error is generated.
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     err::kOffsetMustBeMultipleOfType);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kOffsetMustBeMultipleOfType);
             return false;
         }
 
@@ -1132,7 +1132,7 @@
         // error is generated.
         if (reinterpret_cast<intptr_t>(indices) < 0)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, err::kNegativeOffset);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, err::kNegativeOffset);
             return false;
         }
     }
@@ -1141,7 +1141,7 @@
     {
         if (count < 0)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, err::kNegativeCount);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, err::kNegativeCount);
             return false;
         }
 
@@ -1164,8 +1164,7 @@
         {
             // This is an application error that would normally result in a crash, but we catch
             // it and return an error
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     err::kElementArrayNoBufferOrPointer);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kElementArrayNoBufferOrPointer);
             return false;
         }
     }
@@ -1190,7 +1189,7 @@
         uint64_t elementDataSizeWithOffset = elementDataSizeNoOffset + offset;
         if (elementDataSizeWithOffset < elementDataSizeNoOffset)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, err::kIntegerOverflow);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kIntegerOverflow);
             return false;
         }
 
@@ -1198,8 +1197,7 @@
         if ((elementDataSizeWithOffset > static_cast<uint64_t>(elementArrayBuffer->getSize())) &&
             (primcount > 0))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     err::kInsufficientBufferSize);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kInsufficientBufferSize);
             return false;
         }
     }
@@ -1215,7 +1213,7 @@
         // always return an error if possible here.
         if (static_cast<GLint64>(indexRange.end) >= context->getCaps().maxElementIndex)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, err::kExceedsMaxElement);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kExceedsMaxElement);
             return false;
         }
 
@@ -1239,7 +1237,7 @@
     {
         // The default VAO should always exist
         ASSERT(array.value != 0);
-        context->validationError(entryPoint, GL_INVALID_OPERATION, err::kInvalidVertexArray);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kInvalidVertexArray);
         return false;
     }
 
@@ -1252,8 +1250,7 @@
 {
     if (index >= static_cast<GLuint>(context->getCaps().maxVertexAttributes))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE,
-                                 err::kIndexExceedsMaxVertexAttribute);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, err::kIndexExceedsMaxVertexAttribute);
         return false;
     }
 

src/libANGLE/validationES1.cpp

diff --git a/src/libANGLE/validationES1.cpp b/src/libANGLE/validationES1.cpp
index f872689..d308f41 100644
--- a/src/libANGLE/validationES1.cpp
+++ b/src/libANGLE/validationES1.cpp
@@ -21,7 +21,7 @@
     {                                                                                           \
         if (context->getClientType() != EGL_OPENGL_API && context->getClientMajorVersion() > 1) \
         {                                                                                       \
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kGLES1Only);             \
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kGLES1Only);                           \
             return false;                                                                       \
         }                                                                                       \
     } while (0)
@@ -46,7 +46,7 @@
         case AlphaTestFunc::NotEqual:
             return true;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kEnumInvalid);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumInvalid);
             return false;
     }
 }
@@ -66,13 +66,12 @@
         case ClientVertexArrayType::PointSize:
             if (!context->getExtensions().pointSizeArrayOES)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kPointSizeArrayExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kPointSizeArrayExtensionNotEnabled);
                 return false;
             }
             return true;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidClientState);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidClientState);
             return false;
     }
 }
@@ -89,7 +88,7 @@
 
     if (stride < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidVertexPointerStride);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidVertexPointerStride);
         return false;
     }
 
@@ -114,8 +113,7 @@
         case ClientVertexArrayType::PointSize:
             if (!context->getExtensions().pointSizeArrayOES)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kPointSizeArrayExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kPointSizeArrayExtensionNotEnabled);
                 return false;
             }
 
@@ -129,7 +127,7 @@
 
     if (size < minSize || size > maxSize)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidVertexPointerSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidVertexPointerSize);
         return false;
     }
 
@@ -138,7 +136,7 @@
         case VertexAttribType::Byte:
             if (arrayType == ClientVertexArrayType::PointSize)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidVertexPointerType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidVertexPointerType);
                 return false;
             }
             break;
@@ -146,7 +144,7 @@
             if (arrayType == ClientVertexArrayType::PointSize ||
                 arrayType == ClientVertexArrayType::Color)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidVertexPointerType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidVertexPointerType);
                 return false;
             }
             break;
@@ -156,12 +154,12 @@
         case VertexAttribType::UnsignedByte:
             if (arrayType != ClientVertexArrayType::Color)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidVertexPointerType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidVertexPointerType);
                 return false;
             }
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidVertexPointerType);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidVertexPointerType);
             return false;
     }
 
@@ -172,7 +170,7 @@
 {
     if (light < GL_LIGHT0 || light >= GL_LIGHT0 + context->getCaps().maxLights)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidLight);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidLight);
         return false;
     }
 
@@ -204,7 +202,7 @@
         case LightParameter::SpotExponent:
             if (params[0] < 0.0f || params[0] > 128.0f)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kLightParameterOutOfRange);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kLightParameterOutOfRange);
                 return false;
             }
             return true;
@@ -215,7 +213,7 @@
             }
             if (params[0] < 0.0f || params[0] > 90.0f)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kLightParameterOutOfRange);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kLightParameterOutOfRange);
                 return false;
             }
             return true;
@@ -224,12 +222,12 @@
         case LightParameter::QuadraticAttenuation:
             if (params[0] < 0.0f)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kLightParameterOutOfRange);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kLightParameterOutOfRange);
                 return false;
             }
             return true;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidLightParameter);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidLightParameter);
             return false;
     }
 }
@@ -247,7 +245,7 @@
 
     if (GetLightParameterCount(pname) > 1)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidLightParameter);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidLightParameter);
         return false;
     }
 
@@ -271,13 +269,12 @@
         case MaterialParameter::Shininess:
             if (params[0] < 0.0f || params[0] > 128.0f)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kMaterialParameterOutOfRange);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kMaterialParameterOutOfRange);
                 return false;
             }
             return true;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidMaterialParameter);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidMaterialParameter);
             return false;
     }
 }
@@ -292,7 +289,7 @@
 
     if (face != GL_FRONT_AND_BACK)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidMaterialFace);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidMaterialFace);
         return false;
     }
 
@@ -308,7 +305,7 @@
 
     if (face != GL_FRONT && face != GL_BACK)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidMaterialFace);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidMaterialFace);
         return false;
     }
 
@@ -330,7 +327,7 @@
 
     if (GetMaterialParameterCount(pname) > 1)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidMaterialParameter);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidMaterialParameter);
         return false;
     }
 
@@ -346,7 +343,7 @@
         case GL_LIGHT_MODEL_TWO_SIDE:
             return true;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidLightModelParameter);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidLightModelParameter);
             return false;
     }
 }
@@ -365,7 +362,7 @@
         case GL_LIGHT_MODEL_TWO_SIDE:
             return true;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidLightModelParameter);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidLightModelParameter);
             return false;
     }
 }
@@ -376,7 +373,7 @@
 
     if (plane < GL_CLIP_PLANE0 || plane >= GL_CLIP_PLANE0 + context->getCaps().maxClipPlanes)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidClipPlane);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidClipPlane);
         return false;
     }
 
@@ -402,7 +399,7 @@
                 case GL_LINEAR:
                     return true;
                 default:
-                    context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFogMode);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidFogMode);
                     return false;
             }
         }
@@ -413,12 +410,12 @@
         case GL_FOG_DENSITY:
             if (params[0] < 0.0f)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFogDensity);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidFogDensity);
                 return false;
             }
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFogParameter);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFogParameter);
             return false;
     }
     return true;
@@ -450,8 +447,7 @@
                         case TextureEnvMode::Replace:
                             break;
                         default:
-                            context->validationError(entryPoint, GL_INVALID_VALUE,
-                                                     kInvalidTextureEnvMode);
+                            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureEnvMode);
                             return false;
                     }
                     break;
@@ -473,14 +469,12 @@
                         case TextureCombine::Dot3Rgba:
                             if (pname == TextureEnvParameter::CombineAlpha)
                             {
-                                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                                         kInvalidTextureCombine);
+                                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureCombine);
                                 return false;
                             }
                             break;
                         default:
-                            context->validationError(entryPoint, GL_INVALID_VALUE,
-                                                     kInvalidTextureCombine);
+                            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureCombine);
                             return false;
                     }
                     break;
@@ -501,8 +495,7 @@
                         case TextureSrc::Texture:
                             break;
                         default:
-                            context->validationError(entryPoint, GL_INVALID_VALUE,
-                                                     kInvalidTextureCombineSrc);
+                            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureCombineSrc);
                             return false;
                     }
                     break;
@@ -526,14 +519,12 @@
                                 pname == TextureEnvParameter::Op1Alpha ||
                                 pname == TextureEnvParameter::Op2Alpha)
                             {
-                                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                                         kInvalidTextureCombine);
+                                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureCombine);
                                 return false;
                             }
                             break;
                         default:
-                            context->validationError(entryPoint, GL_INVALID_VALUE,
-                                                     kInvalidTextureCombineOp);
+                            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureCombineOp);
                             return false;
                     }
                     break;
@@ -542,23 +533,21 @@
                 case TextureEnvParameter::AlphaScale:
                     if (params[0] != 1.0f && params[0] != 2.0f && params[0] != 4.0f)
                     {
-                        context->validationError(entryPoint, GL_INVALID_VALUE,
-                                                 kInvalidTextureEnvScale);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureEnvScale);
                         return false;
                     }
                     break;
                 case TextureEnvParameter::Color:
                     break;
                 default:
-                    context->validationError(entryPoint, GL_INVALID_ENUM,
-                                             kInvalidTextureEnvParameter);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureEnvParameter);
                     return false;
             }
             break;
         case TextureEnvTarget::PointSprite:
             if (!context->getExtensions().pointSpriteOES)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureEnvTarget);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureEnvTarget);
                 return false;
             }
             switch (pname)
@@ -566,13 +555,12 @@
                 case TextureEnvParameter::PointCoordReplace:
                     break;
                 default:
-                    context->validationError(entryPoint, GL_INVALID_ENUM,
-                                             kInvalidTextureEnvParameter);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureEnvParameter);
                     return false;
             }
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureEnvTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureEnvTarget);
             return false;
     }
     return true;
@@ -638,14 +626,13 @@
             {
                 if (params[i] < 0.0f)
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE,
-                                             kInvalidPointParameterValue);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidPointParameterValue);
                     return false;
                 }
             }
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPointParameter);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPointParameter);
             return false;
     }
 
@@ -658,7 +645,7 @@
 
     if (size <= 0.0f)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidPointSizeValue);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidPointSizeValue);
         return false;
     }
 
@@ -674,7 +661,7 @@
 
     if (width <= 0.0f || height <= 0.0f)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNonPositiveDrawTextureDimension);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNonPositiveDrawTextureDimension);
         return false;
     }
 
@@ -800,7 +787,7 @@
     ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
     if (context->isWebGL() && n > f)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidDepthRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidDepthRange);
         return false;
     }
 
@@ -878,7 +865,7 @@
     ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
     if (l == r || b == t || n == f || n <= 0.0f || f <= 0.0f)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProjectionMatrix);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidProjectionMatrix);
         return false;
     }
     return true;
@@ -896,7 +883,7 @@
     ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
     if (l == r || b == t || n == f || n <= 0 || f <= 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProjectionMatrix);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidProjectionMatrix);
         return false;
     }
     return true;
@@ -1100,7 +1087,7 @@
     ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
     if (width <= 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidWidth);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidWidth);
         return false;
     }
 
@@ -1185,7 +1172,7 @@
         case MatrixType::Texture:
             return true;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidMatrixMode);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidMatrixMode);
             return false;
     }
 }
@@ -1271,7 +1258,7 @@
     // error INVALID VALUE results.
     if (l == r || b == t || n == f)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProjectionMatrix);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidProjectionMatrix);
         return false;
     }
     return true;
@@ -1289,7 +1276,7 @@
     ANGLE_VALIDATE_IS_GLES1(context, entryPoint);
     if (l == r || b == t || n == f)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProjectionMatrix);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidProjectionMatrix);
         return false;
     }
     return true;
@@ -1303,7 +1290,7 @@
     unsigned int paramCount = GetPointParameterCount(pname);
     if (paramCount != 1)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPointParameter);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPointParameter);
         return false;
     }
 
@@ -1326,7 +1313,7 @@
     unsigned int paramCount = GetPointParameterCount(pname);
     if (paramCount != 1)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPointParameter);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPointParameter);
         return false;
     }
 
@@ -1372,7 +1359,7 @@
     const auto &stack = context->getState().gles1().currentMatrixStack();
     if (stack.size() == 1)
     {
-        context->validationError(entryPoint, GL_STACK_UNDERFLOW, kMatrixStackUnderflow);
+        ANGLE_VALIDATION_ERROR(GL_STACK_UNDERFLOW, kMatrixStackUnderflow);
         return false;
     }
     return true;
@@ -1384,7 +1371,7 @@
     const auto &stack = context->getState().gles1().currentMatrixStack();
     if (stack.size() == stack.max_size())
     {
-        context->validationError(entryPoint, GL_STACK_OVERFLOW, kMatrixStackOverflow);
+        ANGLE_VALIDATION_ERROR(GL_STACK_OVERFLOW, kMatrixStackOverflow);
         return false;
     }
     return true;
@@ -1450,7 +1437,7 @@
         case ShadingModel::Smooth:
             return true;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShadingModel);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidShadingModel);
             return false;
     }
 }
@@ -1747,7 +1734,7 @@
 {
     if (!context->getExtensions().framebufferObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1761,7 +1748,7 @@
 {
     if (!context->getExtensions().framebufferObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1775,7 +1762,7 @@
 {
     if (!context->getExtensions().framebufferObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1789,7 +1776,7 @@
 {
     if (!context->getExtensions().framebufferObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1803,7 +1790,7 @@
 {
     if (!context->getExtensions().framebufferObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1817,7 +1804,7 @@
 {
     if (!context->getExtensions().framebufferObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1830,13 +1817,13 @@
 {
     if (!context->getExtensions().framebufferObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (!ValidFramebufferTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFramebufferTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFramebufferTarget);
         return false;
     }
 
@@ -1852,7 +1839,7 @@
 {
     if (!context->getExtensions().framebufferObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1870,13 +1857,13 @@
 {
     if (!context->getExtensions().framebufferObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (level != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFramebufferTextureLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidFramebufferTextureLevel);
         return false;
     }
 
@@ -1898,13 +1885,12 @@
             {
                 if (level > log2(caps.max2DTextureSize))
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
                     return false;
                 }
                 if (tex->getType() != TextureType::_2D)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kInvalidTextureTarget);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureTarget);
                     return false;
                 }
             }
@@ -1919,26 +1905,25 @@
             {
                 if (!context->getExtensions().textureCubeMapOES)
                 {
-                    context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
                     return false;
                 }
 
                 if (level > log2(caps.maxCubeMapTextureSize))
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
                     return false;
                 }
                 if (tex->getType() != TextureType::CubeMap)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kTextureTargetMismatch);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureTargetMismatch);
                     return false;
                 }
             }
             break;
 
             default:
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
                 return false;
         }
     }
@@ -1952,7 +1937,7 @@
 {
     if (!context->getExtensions().framebufferObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1968,7 +1953,7 @@
 {
     if (!context->getExtensions().framebufferObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1984,7 +1969,7 @@
 {
     if (!context->getExtensions().framebufferObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1997,7 +1982,7 @@
 {
     if (!context->getExtensions().framebufferObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2010,7 +1995,7 @@
 {
     if (!context->getExtensions().framebufferObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2026,7 +2011,7 @@
 {
     if (!context->getExtensions().framebufferObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 

src/libANGLE/validationES2.cpp

diff --git a/src/libANGLE/validationES2.cpp b/src/libANGLE/validationES2.cpp
index f399114..6f4c28e 100644
--- a/src/libANGLE/validationES2.cpp
+++ b/src/libANGLE/validationES2.cpp
@@ -154,22 +154,20 @@
 {
     if (!IsValidCopyTextureDestinationInternalFormatEnum(internalFormat))
     {
-        context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat,
-                                  internalFormat);
+        ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kInvalidInternalFormat, internalFormat);
         return false;
     }
 
     if (!ValidES3FormatCombination(GetUnsizedFormat(internalFormat), type, internalFormat))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
         return false;
     }
 
     const InternalFormat &internalFormatInfo = GetInternalFormatInfo(internalFormat, type);
     if (!internalFormatInfo.textureSupport(context->getClientVersion(), context->getExtensions()))
     {
-        context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat,
-                                  internalFormat);
+        ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kInvalidInternalFormat, internalFormat);
         return false;
     }
 
@@ -368,7 +366,7 @@
 {
     if (!ValidTexture2DDestinationTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
@@ -414,7 +412,7 @@
                     colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_BGR5_A1_ANGLEX &&
                     !Valid4ComponentFloatColorBufferFormat(context, colorbufferFormat))
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormat);
                     return false;
                 }
                 break;
@@ -427,7 +425,7 @@
                     colorbufferFormat != GL_BGRX8_ANGLEX && colorbufferFormat != GL_RGBX8_ANGLE &&
                     !Valid1to4ComponentFloatColorBufferFormat(context, colorbufferFormat))
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormat);
                     return false;
                 }
                 break;
@@ -442,7 +440,7 @@
                     colorbufferFormat != GL_BGRX8_ANGLEX && colorbufferFormat != GL_RGBX8_ANGLE &&
                     !Valid1to4ComponentFloatColorBufferFormat(context, colorbufferFormat))
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormat);
                     return false;
                 }
                 break;
@@ -456,7 +454,7 @@
                     colorbufferFormat != GL_BGRX8_ANGLEX && colorbufferFormat != GL_RGBX8_ANGLE &&
                     !Valid2to4ComponentFloatColorBufferFormat(context, colorbufferFormat))
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormat);
                     return false;
                 }
                 break;
@@ -469,7 +467,7 @@
                     colorbufferFormat != GL_BGRX8_ANGLEX && colorbufferFormat != GL_RGBX8_ANGLE &&
                     !Valid3to4ComponentFloatColorBufferFormat(context, colorbufferFormat))
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormat);
                     return false;
                 }
                 break;
@@ -480,18 +478,18 @@
                     colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_BGR5_A1_ANGLEX &&
                     !Valid4ComponentFloatColorBufferFormat(context, colorbufferFormat))
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormat);
                     return false;
                 }
                 break;
             default:
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormat);
                 return false;
         }
 
         if (formatInfo.type == GL_FLOAT && !context->getExtensions().textureFloatOES)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormat);
             return false;
         }
     }
@@ -505,7 +503,7 @@
                     colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGR5_A1_ANGLEX &&
                     !Valid4ComponentFloatColorBufferFormat(context, colorbufferFormat))
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormat);
                     return false;
                 }
                 break;
@@ -519,7 +517,7 @@
                     colorbufferFormat != GL_BGRX8_ANGLEX && colorbufferFormat != GL_RGBX8_ANGLE &&
                     !Valid1to4ComponentFloatColorBufferFormat(context, colorbufferFormat))
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormat);
                     return false;
                 }
                 break;
@@ -531,7 +529,7 @@
                     colorbufferFormat != GL_BGRX8_ANGLEX && colorbufferFormat != GL_RGBX8_ANGLE &&
                     !Valid2to4ComponentFloatColorBufferFormat(context, colorbufferFormat))
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormat);
                     return false;
                 }
                 break;
@@ -543,7 +541,7 @@
                     colorbufferFormat != GL_BGRX8_ANGLEX && colorbufferFormat != GL_RGBX8_ANGLE &&
                     !Valid3to4ComponentFloatColorBufferFormat(context, colorbufferFormat))
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormat);
                     return false;
                 }
                 break;
@@ -554,13 +552,12 @@
                     colorbufferFormat != GL_BGR5_A1_ANGLEX && colorbufferFormat != GL_RGBA16F &&
                     !Valid4ComponentFloatColorBufferFormat(context, colorbufferFormat))
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormat);
                     return false;
                 }
                 break;
             default:
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                          internalformat);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, internalformat);
                 return false;
         }
     }
@@ -783,8 +780,7 @@
     // Identifiers starting with "webgl_" and "_webgl_" are reserved for use by WebGL.
     if (strncmp(name, "webgl_", 6) == 0 || strncmp(name, "_webgl_", 7) == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kWebglBindAttribLocationReservedPrefix);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kWebglBindAttribLocationReservedPrefix);
         return false;
     }
 
@@ -800,7 +796,7 @@
         // WebGL 1.0 [Section 6.21] Maxmimum Uniform and Attribute Location Lengths
         // WebGL imposes a limit of 256 characters on the lengths of uniform and attribute
         // locations.
-        context->validationError(entryPoint, GL_INVALID_VALUE, kWebglNameLengthLimitExceeded);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kWebglNameLengthLimitExceeded);
 
         return false;
     }
@@ -808,7 +804,7 @@
     {
         // WebGL 2.0 [Section 4.3.2] WebGL 2.0 imposes a limit of 1024 characters on the lengths of
         // uniform and attribute locations.
-        context->validationError(entryPoint, GL_INVALID_VALUE, kWebgl2NameLengthLimitExceeded);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kWebgl2NameLengthLimitExceeded);
         return false;
     }
 
@@ -852,14 +848,13 @@
                 // <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).
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kPLSSecondaryBlendNotSupported);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSSecondaryBlendNotSupported);
                 return false;
             }
             return true;
     }
 
-    context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBlendFunction);
+    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBlendFunction);
     return false;
 }
 
@@ -870,7 +865,7 @@
         // Unextended ES2 does not allow GL_SRC_ALPHA_SATURATE as a dst blend func.
         if (context->getClientMajorVersion() < 3 && !context->getExtensions().blendFuncExtendedEXT)
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBlendFunction);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBlendFunction);
             return false;
         }
     }
@@ -897,7 +892,7 @@
 {
     if (!ValidTexture2DDestinationTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
@@ -937,7 +932,7 @@
     if ((xoffset < 0 || std::numeric_limits<GLsizei>::max() - xoffset < width) ||
         (yoffset < 0 || std::numeric_limits<GLsizei>::max() - yoffset < height))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
         return false;
     }
 
@@ -951,7 +946,7 @@
             if (width > (caps.max2DTextureSize >> level) ||
                 height > (caps.max2DTextureSize >> level))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
             break;
@@ -960,12 +955,12 @@
             ASSERT(level == 0);
             if (width > caps.maxRectangleTextureSize || height > caps.maxRectangleTextureSize)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
             if (isCompressed)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kRectangleTextureCompressed);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kRectangleTextureCompressed);
                 return false;
             }
             break;
@@ -973,35 +968,34 @@
         case TextureType::CubeMap:
             if (!isSubImage && width != height)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kCubemapFacesEqualDimensions);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kCubemapFacesEqualDimensions);
                 return false;
             }
 
             if (width > (caps.maxCubeMapTextureSize >> level) ||
                 height > (caps.maxCubeMapTextureSize >> level))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
             return false;
     }
 
     Texture *texture = context->getTextureByType(texType);
     if (!texture)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferNotBound);
         return false;
     }
 
     // Verify zero border
     if (border != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidBorder);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidBorder);
         return false;
     }
 
@@ -1017,16 +1011,14 @@
 
         if (!internalFormatInfo.compressed && !internalFormatInfo.paletted)
         {
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kInvalidInternalFormat,
-                                      internalformat);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kInvalidInternalFormat, internalformat);
             return false;
         }
 
         if (!internalFormatInfo.textureSupport(context->getClientVersion(),
                                                context->getExtensions()))
         {
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kInvalidInternalFormat,
-                                      internalformat);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kInvalidInternalFormat, internalformat);
             return false;
         }
 
@@ -1040,8 +1032,8 @@
             // arguments in table 3.11 will generate an INVALID OPERATION error.
             if (internalFormatInfo.paletted)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat,
-                                          internalformat);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kInvalidInternalFormat,
+                                        internalformat);
                 return false;
             }
 
@@ -1055,8 +1047,8 @@
             if (IsETC1Format(actualInternalFormat) &&
                 !context->getExtensions().compressedETC1RGB8SubTextureEXT)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat,
-                                          internalformat);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kInvalidInternalFormat,
+                                        internalformat);
                 return false;
             }
 
@@ -1065,14 +1057,13 @@
                                              texture->getHeight(target, level),
                                              texture->getDepth(target, level)))
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kInvalidCompressedImageSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidCompressedImageSize);
                 return false;
             }
 
             if (format != actualInternalFormat)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormat);
                 return false;
             }
         }
@@ -1080,8 +1071,7 @@
         {
             if (!ValidCompressedImageSize(context, actualInternalFormat, level, width, height, 1))
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kInvalidCompressedImageSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidCompressedImageSize);
                 return false;
             }
         }
@@ -1104,12 +1094,12 @@
             case GL_UNSIGNED_INT_2_10_10_10_REV_EXT:
                 if (!context->getExtensions().textureType2101010REVEXT)
                 {
-                    context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, type);
+                    ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, type);
                     return false;
                 }
                 break;
             default:
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidType);
                 return false;
         }
 
@@ -1128,8 +1118,7 @@
                     case GL_HALF_FLOAT_OES:
                         break;
                     default:
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kMismatchedTypeAndFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
                         return false;
                 }
                 break;
@@ -1137,8 +1126,7 @@
             case GL_RG:
                 if (!context->getExtensions().textureRgEXT)
                 {
-                    context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                              format);
+                    ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, format);
                     return false;
                 }
                 switch (type)
@@ -1148,8 +1136,7 @@
                     case GL_FLOAT:
                         if (!context->getExtensions().textureFloatOES)
                         {
-                            context->validationErrorF(entryPoint, GL_INVALID_ENUM,
-                                                      kEnumNotSupported, type);
+                            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, type);
                             return false;
                         }
                         break;
@@ -1157,8 +1144,7 @@
                         if (!context->getExtensions().textureFloatOES &&
                             !context->getExtensions().textureHalfFloatOES)
                         {
-                            context->validationErrorF(entryPoint, GL_INVALID_ENUM,
-                                                      kEnumNotSupported, type);
+                            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, type);
                             return false;
                         }
                         break;
@@ -1166,14 +1152,12 @@
                     case GL_UNSIGNED_SHORT:
                         if (!context->getExtensions().textureNorm16EXT)
                         {
-                            context->validationErrorF(entryPoint, GL_INVALID_ENUM,
-                                                      kEnumNotSupported, type);
+                            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, type);
                             return false;
                         }
                         break;
                     default:
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kMismatchedTypeAndFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
                         return false;
                 }
                 break;
@@ -1190,14 +1174,12 @@
                     case GL_UNSIGNED_SHORT:
                         if (!context->getExtensions().textureNorm16EXT)
                         {
-                            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                     kMismatchedTypeAndFormat);
+                            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
                             return false;
                         }
                         break;
                     default:
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kMismatchedTypeAndFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
                         return false;
                 }
                 break;
@@ -1215,22 +1197,19 @@
                     case GL_UNSIGNED_SHORT:
                         if (!context->getExtensions().textureNorm16EXT)
                         {
-                            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                     kMismatchedTypeAndFormat);
+                            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
                             return false;
                         }
                         break;
                     default:
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kMismatchedTypeAndFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
                         return false;
                 }
                 break;
             case GL_BGRA_EXT:
                 if (!context->getExtensions().textureFormatBGRA8888EXT)
                 {
-                    context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                              format);
+                    ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, format);
                     return false;
                 }
                 switch (type)
@@ -1238,8 +1217,7 @@
                     case GL_UNSIGNED_BYTE:
                         break;
                     default:
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kMismatchedTypeAndFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
                         return false;
                 }
                 break;
@@ -1247,8 +1225,7 @@
             case GL_SRGB_ALPHA_EXT:
                 if (!context->getExtensions().sRGBEXT)
                 {
-                    context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                              format);
+                    ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, format);
                     return false;
                 }
                 switch (type)
@@ -1256,8 +1233,7 @@
                     case GL_UNSIGNED_BYTE:
                         break;
                     default:
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kMismatchedTypeAndFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
                         return false;
                 }
                 break;
@@ -1270,14 +1246,12 @@
                     case GL_FLOAT:
                         if (!context->getExtensions().depthBufferFloat2NV)
                         {
-                            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                     kMismatchedTypeAndFormat);
+                            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
                             return false;
                         }
                         break;
                     default:
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kMismatchedTypeAndFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
                         return false;
                 }
                 break;
@@ -1287,13 +1261,12 @@
                     case GL_UNSIGNED_INT_24_8_OES:
                         break;
                     default:
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kMismatchedTypeAndFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
                         return false;
                 }
                 break;
             default:
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, format);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, format);
                 return false;
         }
 
@@ -1306,8 +1279,7 @@
                        context->getExtensions().depthTextureCubeMapOES) &&
                       context->getExtensions().depthTextureOES))
                 {
-                    context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                              format);
+                    ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, format);
                     return false;
                 }
 
@@ -1323,14 +1295,13 @@
                     case TextureTarget::CubeMapPositiveZ:
                         if (!context->getExtensions().depthTextureCubeMapOES)
                         {
-                            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                     kMismatchedTargetAndFormat);
+                            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                                   kMismatchedTargetAndFormat);
                             return false;
                         }
                         break;
                     default:
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kMismatchedTargetAndFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTargetAndFormat);
                         return false;
                 }
 
@@ -1340,13 +1311,12 @@
                 {
                     if (pixels != nullptr)
                     {
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kPixelDataNotNull);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPixelDataNotNull);
                         return false;
                     }
                     if (level != 0)
                     {
-                        context->validationError(entryPoint, GL_INVALID_OPERATION, kLevelNotZero);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kLevelNotZero);
                         return false;
                     }
                 }
@@ -1370,7 +1340,7 @@
                 case GL_RGBA32F:
                     if (!context->getExtensions().colorBufferFloatRgbaCHROMIUM)
                     {
-                        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFormat);
                         return false;
                     }
 
@@ -1378,14 +1348,12 @@
 
                     if (type != GL_FLOAT)
                     {
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kMismatchedTypeAndFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
                         return false;
                     }
                     if (format != GL_RGBA)
                     {
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kMismatchedTypeAndFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
                         return false;
                     }
                     break;
@@ -1393,7 +1361,7 @@
                 case GL_RGB32F:
                     if (!context->getExtensions().colorBufferFloatRgbCHROMIUM)
                     {
-                        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFormat);
                         return false;
                     }
 
@@ -1401,14 +1369,12 @@
 
                     if (type != GL_FLOAT)
                     {
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kMismatchedTypeAndFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
                         return false;
                     }
                     if (format != GL_RGB)
                     {
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kMismatchedTypeAndFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
                         return false;
                     }
                     break;
@@ -1416,7 +1382,7 @@
                 case GL_BGRA_EXT:
                     if (!context->getExtensions().textureFormatBGRA8888EXT)
                     {
-                        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFormat);
                         return false;
                     }
                     break;
@@ -1424,7 +1390,7 @@
                 case GL_DEPTH_COMPONENT:
                     if (!(context->getExtensions().depthTextureAny()))
                     {
-                        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFormat);
                         return false;
                     }
                     break;
@@ -1434,7 +1400,7 @@
                           context->getExtensions().packedDepthStencilOES ||
                           context->getExtensions().depthTextureCubeMapOES))
                     {
-                        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFormat);
                         return false;
                     }
                     break;
@@ -1443,7 +1409,7 @@
                 case GL_RG:
                     if (!context->getExtensions().textureRgEXT)
                     {
-                        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFormat);
                         return false;
                     }
                     break;
@@ -1452,8 +1418,7 @@
                 case GL_SRGB_ALPHA_EXT:
                     if (!context->getExtensions().sRGBEXT)
                     {
-                        context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                                  internalformat);
+                        ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, internalformat);
                         return false;
                     }
                     break;
@@ -1461,15 +1426,13 @@
                 case GL_RGB10_A2_EXT:
                     if (!context->getExtensions().textureType2101010REVEXT)
                     {
-                        context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                                  internalformat);
+                        ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, internalformat);
                         return false;
                     }
 
                     if (type != GL_UNSIGNED_INT_2_10_10_10_REV_EXT || format != GL_RGBA)
                     {
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kMismatchedTypeAndFormat);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
                         return false;
                     }
 
@@ -1505,15 +1468,14 @@
                 case GL_RGBA16_SNORM_EXT:
                     if (!context->getExtensions().textureNorm16EXT)
                     {
-                        context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                                  internalformat);
+                        ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, internalformat);
                         return false;
                     }
                     break;
                 default:
                     // Compressed formats are not valid internal formats for glTexImage*D
-                    context->validationErrorF(entryPoint, GL_INVALID_VALUE, kInvalidInternalFormat,
-                                              internalformat);
+                    ANGLE_VALIDATION_ERRORF(GL_INVALID_VALUE, kInvalidInternalFormat,
+                                            internalformat);
                     return false;
             }
         }
@@ -1522,7 +1484,7 @@
         {
             if (!context->getExtensions().textureFloatOES)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, type);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, type);
                 return false;
             }
         }
@@ -1530,7 +1492,7 @@
         {
             if (!context->getExtensions().textureHalfFloatOES)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, type);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, type);
                 return false;
             }
         }
@@ -1541,13 +1503,13 @@
         const InternalFormat &textureInternalFormat = *texture->getFormat(target, level).info;
         if (textureInternalFormat.internalFormat == GL_NONE)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureLevel);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureLevel);
             return false;
         }
 
         if (format != textureInternalFormat.format)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, err::kTextureFormatMismatch);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kTextureFormatMismatch);
             return false;
         }
 
@@ -1556,7 +1518,7 @@
             if (GetInternalFormatInfo(format, type).sizedInternalFormat !=
                 textureInternalFormat.sizedInternalFormat)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureTypeMismatch);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureTypeMismatch);
                 return false;
             }
         }
@@ -1564,14 +1526,14 @@
         if (static_cast<size_t>(xoffset + width) > texture->getWidth(target, level) ||
             static_cast<size_t>(yoffset + height) > texture->getHeight(target, level))
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kOffsetOverflow);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kOffsetOverflow);
             return false;
         }
 
         if (width > 0 && height > 0 && pixels == nullptr &&
             context->getState().getTargetBuffer(BufferBinding::PixelUnpack) == nullptr)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kPixelDataNull);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kPixelDataNull);
             return false;
         }
     }
@@ -1579,7 +1541,7 @@
     {
         if (texture->getImmutableFormat())
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureIsImmutable);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureIsImmutable);
             return false;
         }
     }
@@ -1591,7 +1553,7 @@
     // case.
     if (!isSubImage && !isCompressed && internalformat != format && !nonEqualFormatsAllowed)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormatCombination);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormatCombination);
         return false;
     }
 
@@ -1611,32 +1573,32 @@
     if (target != TextureType::_2D && target != TextureType::CubeMap &&
         target != TextureType::Rectangle)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
     if (width < 1 || height < 1 || levels < 1)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureSizeTooSmall);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kTextureSizeTooSmall);
         return false;
     }
 
     if (target == TextureType::CubeMap && width != height)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kCubemapFacesEqualDimensions);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kCubemapFacesEqualDimensions);
         return false;
     }
 
     if (levels != 1 && levels != log2(std::max(width, height)) + 1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidMipLevels);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidMipLevels);
         return false;
     }
 
     const InternalFormat &formatInfo = GetSizedInternalFormatInfo(internalformat);
     if (formatInfo.format == GL_NONE || formatInfo.type == GL_NONE)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFormat);
         return false;
     }
 
@@ -1647,41 +1609,40 @@
         case TextureType::_2D:
             if (width > caps.max2DTextureSize || height > caps.max2DTextureSize)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
             break;
         case TextureType::Rectangle:
             if (levels != 1)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
                 return false;
             }
 
             if (width > caps.maxRectangleTextureSize || height > caps.maxRectangleTextureSize)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
             if (formatInfo.compressed)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kRectangleTextureCompressed);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kRectangleTextureCompressed);
                 return false;
             }
             break;
         case TextureType::CubeMap:
             if (width > caps.maxCubeMapTextureSize || height > caps.maxCubeMapTextureSize)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
             break;
         case TextureType::InvalidEnum:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kEnumInvalid);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumInvalid);
             return false;
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                      ToGLenum(target));
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, ToGLenum(target));
             return false;
     }
 
@@ -1689,14 +1650,14 @@
     {
         if (!isPow2(width) || !isPow2(height))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kDimensionsMustBePow2);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDimensionsMustBePow2);
             return false;
         }
     }
 
     if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions()))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFormat);
         return false;
     }
 
@@ -1705,7 +1666,7 @@
     {
         if (!ValidCompressedImageSize(context, formatInfo.internalFormat, 0, width, height, 1))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidCompressedImageSize);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidCompressedImageSize);
             return false;
         }
     }
@@ -1721,14 +1682,12 @@
                 case TextureType::CubeMap:
                     if (!context->getExtensions().depthTextureCubeMapOES)
                     {
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kInvalidTextureTarget);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureTarget);
                         return false;
                     }
                     break;
                 default:
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kInvalidTextureTarget);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureTarget);
                     return false;
             }
 
@@ -1737,7 +1696,7 @@
             {
                 if (levels != 1)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidMipLevels);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidMipLevels);
                     return false;
                 }
             }
@@ -1750,14 +1709,12 @@
                 case TextureType::CubeMap:
                     if (!context->getExtensions().depthTextureCubeMapOES)
                     {
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kInvalidTextureTarget);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureTarget);
                         return false;
                     }
                     break;
                 default:
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kInvalidTextureTarget);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureTarget);
                     return false;
             }
 
@@ -1767,7 +1724,7 @@
                 // ANGLE_depth_texture only supports 1-level textures
                 if (levels != 1)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidMipLevels);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidMipLevels);
                     return false;
                 }
             }
@@ -1780,13 +1737,13 @@
     Texture *texture = context->getTextureByType(target);
     if (!texture || texture->id().value == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kMissingTexture);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMissingTexture);
         return false;
     }
 
     if (texture->getImmutableFormat())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureIsImmutable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureIsImmutable);
         return false;
     }
 
@@ -1801,7 +1758,7 @@
 {
     if (!context->getExtensions().discardFramebufferEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1814,7 +1771,7 @@
                 (context->getState().getTargetFramebuffer(GL_FRAMEBUFFER)->isDefault());
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFramebufferTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFramebufferTarget);
             return false;
     }
 
@@ -1828,7 +1785,7 @@
 {
     if (!context->getExtensions().vertexArrayObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1842,7 +1799,7 @@
 {
     if (!context->getExtensions().vertexArrayObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1856,7 +1813,7 @@
 {
     if (!context->getExtensions().vertexArrayObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1869,7 +1826,7 @@
 {
     if (!context->getExtensions().vertexArrayObjectOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1885,7 +1842,7 @@
 {
     if (!context->getExtensions().getProgramBinaryOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1902,7 +1859,7 @@
 {
     if (!context->getExtensions().getProgramBinaryOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1976,25 +1933,25 @@
 {
     if (!context->getExtensions().debugKHR)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (!ValidDebugSource(source, false) && source != GL_DONT_CARE)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDebugSource);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidDebugSource);
         return false;
     }
 
     if (!ValidDebugType(type) && type != GL_DONT_CARE)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDebugType);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidDebugType);
         return false;
     }
 
     if (!ValidDebugSeverity(severity) && severity != GL_DONT_CARE)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDebugSeverity);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidDebugSeverity);
         return false;
     }
 
@@ -2002,13 +1959,13 @@
     {
         if (source == GL_DONT_CARE || type == GL_DONT_CARE)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidDebugSourceType);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidDebugSourceType);
             return false;
         }
 
         if (severity != GL_DONT_CARE)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidDebugSeverity);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidDebugSeverity);
             return false;
         }
     }
@@ -2027,7 +1984,7 @@
 {
     if (!context->getExtensions().debugKHR)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2040,26 +1997,26 @@
 
     if (!ValidDebugSeverity(severity))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDebugSource);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidDebugSource);
         return false;
     }
 
     if (!ValidDebugType(type))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDebugType);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidDebugType);
         return false;
     }
 
     if (!ValidDebugSource(source, true))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDebugSource);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidDebugSource);
         return false;
     }
 
     size_t messageLength = (length < 0) ? strlen(buf) : length;
     if (messageLength > context->getCaps().maxDebugMessageLength)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDebugMessageLength);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxDebugMessageLength);
         return false;
     }
 
@@ -2073,7 +2030,7 @@
 {
     if (!context->getExtensions().debugKHR)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2093,13 +2050,13 @@
 {
     if (!context->getExtensions().debugKHR)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (bufSize < 0 && messageLog != nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBufferSize);
         return false;
     }
 
@@ -2115,21 +2072,21 @@
 {
     if (!ValidDebugSource(source, true))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDebugSource);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidDebugSource);
         return false;
     }
 
     size_t messageLength = (length < 0) ? strlen(message) : length;
     if (messageLength > context->getCaps().maxDebugMessageLength)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDebugMessageLength);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxDebugMessageLength);
         return false;
     }
 
     size_t currentStackSize = context->getState().getDebug().getGroupStackDepth();
     if (currentStackSize >= context->getCaps().maxDebugGroupStackDepth)
     {
-        context->validationError(entryPoint, GL_STACK_OVERFLOW, kExceedsMaxDebugGroupStackDepth);
+        ANGLE_VALIDATION_ERROR(GL_STACK_OVERFLOW, kExceedsMaxDebugGroupStackDepth);
         return false;
     }
 
@@ -2141,7 +2098,7 @@
     size_t currentStackSize = context->getState().getDebug().getGroupStackDepth();
     if (currentStackSize <= 1)
     {
-        context->validationError(entryPoint, GL_STACK_UNDERFLOW, kCannotPopDefaultDebugGroup);
+        ANGLE_VALIDATION_ERROR(GL_STACK_UNDERFLOW, kCannotPopDefaultDebugGroup);
         return false;
     }
 
@@ -2157,7 +2114,7 @@
 {
     if (!context->getExtensions().debugKHR)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2168,7 +2125,7 @@
 {
     if (!context->getExtensions().debugKHR)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2185,7 +2142,7 @@
         case GL_BUFFER:
             if (context->getBuffer({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidBufferName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidBufferName);
                 return false;
             }
             return true;
@@ -2193,7 +2150,7 @@
         case GL_SHADER:
             if (context->getShader({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidShaderName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidShaderName);
                 return false;
             }
             return true;
@@ -2201,7 +2158,7 @@
         case GL_PROGRAM:
             if (context->getProgramNoResolveLink({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProgramName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidProgramName);
                 return false;
             }
             return true;
@@ -2209,7 +2166,7 @@
         case GL_VERTEX_ARRAY:
             if (context->getVertexArray({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidVertexArrayName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidVertexArrayName);
                 return false;
             }
             return true;
@@ -2217,7 +2174,7 @@
         case GL_QUERY:
             if (context->getQuery({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidQueryName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidQueryName);
                 return false;
             }
             return true;
@@ -2225,8 +2182,7 @@
         case GL_TRANSFORM_FEEDBACK:
             if (context->getTransformFeedback({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kInvalidTransformFeedbackName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTransformFeedbackName);
                 return false;
             }
             return true;
@@ -2234,7 +2190,7 @@
         case GL_SAMPLER:
             if (context->getSampler({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSamplerName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidSamplerName);
                 return false;
             }
             return true;
@@ -2242,7 +2198,7 @@
         case GL_TEXTURE:
             if (context->getTexture({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidTextureName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureName);
                 return false;
             }
             return true;
@@ -2250,7 +2206,7 @@
         case GL_RENDERBUFFER:
             if (!context->isRenderbuffer({name}))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidRenderbufferName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidRenderbufferName);
                 return false;
             }
             return true;
@@ -2258,7 +2214,7 @@
         case GL_FRAMEBUFFER:
             if (context->getFramebuffer({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFramebufferName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidFramebufferName);
                 return false;
             }
             return true;
@@ -2266,13 +2222,13 @@
         case GL_PROGRAM_PIPELINE:
             if (context->getProgramPipeline({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProgramPipelineName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidProgramPipelineName);
                 return false;
             }
             return true;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidIndentifier);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidIndentifier);
             return false;
     }
 }
@@ -2298,7 +2254,7 @@
 
     if (labelLength > context->getCaps().maxLabelLength)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxLabelLength);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxLabelLength);
         return false;
     }
 
@@ -2314,7 +2270,7 @@
 {
     if (!context->getExtensions().debugKHR)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2341,13 +2297,13 @@
 {
     if (!context->getExtensions().debugKHR)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (bufSize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBufferSize);
         return false;
     }
 
@@ -2365,7 +2321,7 @@
 {
     if (!context->getSync({unsafe_pointer_to_int_cast<uint32_t>(ptr)}))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSyncPointer);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidSyncPointer);
         return false;
     }
 
@@ -2380,7 +2336,7 @@
 {
     if (!context->getExtensions().debugKHR)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2406,13 +2362,13 @@
 {
     if (!context->getExtensions().debugKHR)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (bufSize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBufferSize);
         return false;
     }
 
@@ -2431,7 +2387,7 @@
 {
     if (!context->getExtensions().debugKHR)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2443,7 +2399,7 @@
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
 
@@ -2476,20 +2432,20 @@
 {
     if (!context->getExtensions().framebufferBlitANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBlitExtensionNotAvailable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBlitExtensionNotAvailable);
         return false;
     }
 
     if (srcX1 - srcX0 != dstX1 - dstX0 || srcY1 - srcY0 != dstY1 - dstY0)
     {
         // TODO(jmadill): Determine if this should be available on other implementations.
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBlitExtensionScaleOrFlip);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBlitExtensionScaleOrFlip);
         return false;
     }
 
     if (filter == GL_LINEAR)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kBlitExtensionLinear);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kBlitExtensionLinear);
         return false;
     }
 
@@ -2512,8 +2468,8 @@
                 readColorAttachment->type() != GL_RENDERBUFFER &&
                 readColorAttachment->type() != GL_FRAMEBUFFER_DEFAULT)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kBlitExtensionFromInvalidAttachmentType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                       kBlitExtensionFromInvalidAttachmentType);
                 return false;
             }
 
@@ -2531,8 +2487,8 @@
                         attachment->type() != GL_RENDERBUFFER &&
                         attachment->type() != GL_FRAMEBUFFER_DEFAULT)
                     {
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kBlitExtensionToInvalidAttachmentType);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                               kBlitExtensionToInvalidAttachmentType);
                         return false;
                     }
 
@@ -2540,8 +2496,8 @@
                     if (!Format::EquivalentForBlit(attachment->getFormat(),
                                                    readColorAttachment->getFormat()))
                     {
-                        context->validationErrorF(
-                            entryPoint, GL_INVALID_OPERATION, kBlitExtensionFormatMismatch,
+                        ANGLE_VALIDATION_ERRORF(
+                            GL_INVALID_OPERATION, kBlitExtensionFormatMismatch,
                             readColorAttachment->getFormat().info->sizedInternalFormat,
                             attachment->getFormat().info->sizedInternalFormat);
                         return false;
@@ -2554,8 +2510,8 @@
                 IsPartialBlit(context, readColorAttachment, drawColorAttachment, srcX0, srcY0,
                               srcX1, srcY1, dstX0, dstY0, dstX1, dstY1))
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kBlitExtensionMultisampledWholeBufferBlit);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                       kBlitExtensionMultisampledWholeBufferBlit);
                 return false;
             }
         }
@@ -2578,15 +2534,15 @@
                                   dstX0, dstY0, dstX1, dstY1))
                 {
                     // only whole-buffer copies are permitted
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kBlitExtensionDepthStencilWholeBufferBlit);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                           kBlitExtensionDepthStencilWholeBufferBlit);
                     return false;
                 }
 
                 if (readBuffer->getResourceSamples() != 0 || drawBuffer->getResourceSamples() != 0)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kBlitExtensionMultisampledDepthOrStencil);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                           kBlitExtensionMultisampledDepthOrStencil);
                     return false;
                 }
             }
@@ -2612,7 +2568,7 @@
 {
     if (!context->getExtensions().framebufferBlitANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBlitExtensionNotAvailable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBlitExtensionNotAvailable);
         return false;
     }
 
@@ -2632,7 +2588,7 @@
 
     if ((mask & ~(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidClearMask);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidClearMask);
         return false;
     }
 
@@ -2659,7 +2615,7 @@
         Framebuffer *framebuffer = state.getDrawFramebuffer();
         if (framebuffer->getNumViews() > 1 && state.isQueryActive(QueryType::TimeElapsed))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kMultiviewTimerQuery);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMultiviewTimerQuery);
             return false;
         }
     }
@@ -2674,7 +2630,7 @@
 {
     if (!context->getExtensions().drawBuffersEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2848,20 +2804,19 @@
     GLuint expectedImageSize = 0;
     if (!formatInfo.computeCompressedImageSize(Extents(width, height, 1), &expectedImageSize))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kIntegerOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kIntegerOverflow);
         return false;
     }
 
     if (imageSize < 0 || static_cast<GLuint>(imageSize) != expectedImageSize)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE,
-                                 kCompressedTextureDimensionsMustMatchData);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kCompressedTextureDimensionsMustMatchData);
         return false;
     }
 
     if (target == TextureTarget::Rectangle)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kRectangleTextureCompressed);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kRectangleTextureCompressed);
         return false;
     }
 
@@ -2963,13 +2918,13 @@
     GLuint blockSize                 = 0;
     if (!formatInfo.computeCompressedImageSize(Extents(width, height, 1), &blockSize))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kIntegerOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kIntegerOverflow);
         return false;
     }
 
     if (imageSize < 0 || static_cast<GLuint>(imageSize) != blockSize)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidCompressedImageSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidCompressedImageSize);
         return false;
     }
 
@@ -3002,7 +2957,7 @@
 {
     if (!context->getExtensions().mapbufferOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3016,13 +2971,13 @@
 {
     if (!context->getExtensions().mapbufferOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (!context->isValidBufferBinding(target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBufferTypes);
         return false;
     }
 
@@ -3030,13 +2985,13 @@
 
     if (buffer == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotMappable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferNotMappable);
         return false;
     }
 
     if (access != GL_WRITE_ONLY_OES)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidAccessBits);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidAccessBits);
         return false;
     }
 
@@ -3045,13 +3000,13 @@
     // is compatible with the buffer's usage flags specified during glBufferStorageEXT
     if (buffer->isImmutable() && (buffer->getStorageExtUsageFlags() & GL_MAP_WRITE_BIT) == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotMappable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferNotMappable);
         return false;
     }
 
     if (buffer->isMapped())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferAlreadyMapped);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferAlreadyMapped);
         return false;
     }
 
@@ -3064,7 +3019,7 @@
 {
     if (!context->getExtensions().mapbufferOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3080,7 +3035,7 @@
 {
     if (!context->getExtensions().mapBufferRangeEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3103,8 +3058,7 @@
             const auto &transformFeedbackBuffer = transformFeedback->getIndexedBuffer(i);
             if (transformFeedbackBuffer.get() == buffer)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kBufferBoundForTransformFeedback);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferBoundForTransformFeedback);
                 return false;
             }
         }
@@ -3112,8 +3066,7 @@
 
     if (buffer->hasWebGLXFBBindingConflict(context->isWebGL()))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kBufferBoundForTransformFeedback);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferBoundForTransformFeedback);
         return false;
     }
 
@@ -3128,7 +3081,7 @@
 {
     if (!context->getExtensions().mapBufferRangeEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3143,7 +3096,7 @@
 {
     if (!context->getExtensions().bindUniformLocationCHROMIUM)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3155,7 +3108,7 @@
 
     if (location.value < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeLocation);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeLocation);
         return false;
     }
 
@@ -3163,7 +3116,7 @@
     if (static_cast<long>(location.value) >=
         (caps.maxVertexUniformVectors + caps.maxFragmentUniformVectors) * 4)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidBindUniformLocation);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidBindUniformLocation);
         return false;
     }
 
@@ -3171,13 +3124,13 @@
     // shader-related entry points
     if (context->isWebGL() && !IsValidESSLString(name, strlen(name)))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidNameCharacters);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidNameCharacters);
         return false;
     }
 
     if (strncmp(name, "gl_", 3) == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNameBeginsWithGL);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNameBeginsWithGL);
         return false;
     }
 
@@ -3190,7 +3143,7 @@
 {
     if (!context->getExtensions().framebufferMixedSamplesCHROMIUM)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     switch (components)
@@ -3201,7 +3154,7 @@
         case GL_NONE:
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidCoverageComponents);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidCoverageComponents);
             return false;
     }
 
@@ -3223,21 +3176,20 @@
 {
     if (!context->getExtensions().copyTextureCHROMIUM)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     const Texture *source = context->getTexture(sourceId);
     if (source == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTexture);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidSourceTexture);
         return false;
     }
 
     if (!IsValidCopyTextureSourceTarget(context, source->getType()))
     {
-        context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat,
-                                  internalFormat);
+        ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kInvalidInternalFormat, internalFormat);
         return false;
     }
 
@@ -3247,7 +3199,7 @@
 
     if (!IsValidCopyTextureSourceLevel(context, sourceType, sourceLevel))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTextureLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidSourceTextureLevel);
         return false;
     }
 
@@ -3255,29 +3207,27 @@
     GLsizei sourceHeight = static_cast<GLsizei>(source->getHeight(sourceTarget, sourceLevel));
     if (sourceWidth == 0 || sourceHeight == 0)
     {
-        context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat,
-                                  internalFormat);
+        ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kInvalidInternalFormat, internalFormat);
         return false;
     }
 
     const InternalFormat &sourceFormat = *source->getFormat(sourceTarget, sourceLevel).info;
     if (!IsValidCopyTextureSourceInternalFormatEnum(sourceFormat.internalFormat))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kInvalidSourceTextureInternalFormat);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidSourceTextureInternalFormat);
         return false;
     }
 
     if (!IsValidCopyTextureDestinationTargetEnum(context, destTarget))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
     const Texture *dest = context->getTexture(destId);
     if (dest == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDestinationTexture);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidDestinationTexture);
         return false;
     }
 
@@ -3285,21 +3235,20 @@
     if (sourceType == TextureType::External && destInternalFormatInfo.isInt() &&
         !context->getExtensions().EGLImageExternalEssl3OES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kANGLECopyTextureMissingRequiredExtension);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kANGLECopyTextureMissingRequiredExtension);
         return false;
     }
 
     if (!IsValidCopyTextureDestinationTarget(context, dest->getType(), destTarget))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDestinationTextureType);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidDestinationTextureType);
         return false;
     }
 
     if (!IsValidCopyTextureDestinationLevel(context, entryPoint, dest->getType(), destLevel,
                                             sourceWidth, sourceHeight, false))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
         return false;
     }
 
@@ -3310,13 +3259,13 @@
 
     if (dest->getType() == TextureType::CubeMap && sourceWidth != sourceHeight)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kCubemapFacesEqualDimensions);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kCubemapFacesEqualDimensions);
         return false;
     }
 
     if (dest->getImmutableFormat())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kDestinationImmutable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDestinationImmutable);
         return false;
     }
 
@@ -3342,20 +3291,20 @@
 {
     if (!context->getExtensions().copyTextureCHROMIUM)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     const Texture *source = context->getTexture(sourceId);
     if (source == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTexture);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidSourceTexture);
         return false;
     }
 
     if (!IsValidCopyTextureSourceTarget(context, source->getType()))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTextureType);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidSourceTextureType);
         return false;
     }
 
@@ -3365,101 +3314,100 @@
 
     if (!IsValidCopyTextureSourceLevel(context, sourceType, sourceLevel))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
         return false;
     }
 
     if (source->getWidth(sourceTarget, sourceLevel) == 0 ||
         source->getHeight(sourceTarget, sourceLevel) == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTextureLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidSourceTextureLevel);
         return false;
     }
 
     if (x < 0 || y < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeOffset);
         return false;
     }
 
     if (width < 0 || height < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeSize);
         return false;
     }
 
     if (static_cast<size_t>(x + width) > source->getWidth(sourceTarget, sourceLevel) ||
         static_cast<size_t>(y + height) > source->getHeight(sourceTarget, sourceLevel))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kSourceTextureTooSmall);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kSourceTextureTooSmall);
         return false;
     }
 
     const Format &sourceFormat = source->getFormat(sourceTarget, sourceLevel);
     if (!IsValidCopySubTextureSourceInternalFormat(sourceFormat.info->internalFormat))
     {
-        context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat,
-                                  sourceFormat.info->internalFormat);
+        ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kInvalidInternalFormat,
+                                sourceFormat.info->internalFormat);
         return false;
     }
 
     if (!IsValidCopyTextureDestinationTargetEnum(context, destTarget))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
     const Texture *dest = context->getTexture(destId);
     if (dest == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDestinationTexture);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidDestinationTexture);
         return false;
     }
 
     if (!IsValidCopyTextureDestinationTarget(context, dest->getType(), destTarget))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDestinationTextureType);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidDestinationTextureType);
         return false;
     }
 
     if (!IsValidCopyTextureDestinationLevel(context, entryPoint, dest->getType(), destLevel, width,
                                             height, true))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
         return false;
     }
 
     if (dest->getWidth(destTarget, destLevel) == 0 || dest->getHeight(destTarget, destLevel) == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kDestinationLevelNotDefined);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDestinationLevelNotDefined);
         return false;
     }
 
     const InternalFormat &destFormat = *dest->getFormat(destTarget, destLevel).info;
     if (!IsValidCopySubTextureDestionationInternalFormat(destFormat.internalFormat))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormatCombination);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormatCombination);
         return false;
     }
 
     if (sourceType == TextureType::External && destFormat.isInt() &&
         !context->getExtensions().EGLImageExternalEssl3OES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kANGLECopyTextureMissingRequiredExtension);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kANGLECopyTextureMissingRequiredExtension);
         return false;
     }
 
     if (xoffset < 0 || yoffset < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeOffset);
         return false;
     }
 
     if (static_cast<size_t>(xoffset + width) > dest->getWidth(destTarget, destLevel) ||
         static_cast<size_t>(yoffset + height) > dest->getHeight(destTarget, destLevel))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kOffsetOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kOffsetOverflow);
         return false;
     }
 
@@ -3473,53 +3421,53 @@
 {
     if (!context->getExtensions().copyCompressedTextureCHROMIUM)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     const Texture *source = context->getTexture(sourceId);
     if (source == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTexture);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidSourceTexture);
         return false;
     }
 
     if (source->getType() != TextureType::_2D)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTextureType);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidSourceTextureType);
         return false;
     }
 
     if (source->getWidth(TextureTarget::_2D, 0) == 0 ||
         source->getHeight(TextureTarget::_2D, 0) == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kSourceTextureLevelZeroDefined);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kSourceTextureLevelZeroDefined);
         return false;
     }
 
     const Format &sourceFormat = source->getFormat(TextureTarget::_2D, 0);
     if (!sourceFormat.info->compressed)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kSourceTextureMustBeCompressed);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kSourceTextureMustBeCompressed);
         return false;
     }
 
     const Texture *dest = context->getTexture(destId);
     if (dest == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDestinationTexture);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidDestinationTexture);
         return false;
     }
 
     if (dest->getType() != TextureType::_2D)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDestinationTextureType);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidDestinationTextureType);
         return false;
     }
 
     if (dest->getImmutableFormat())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kDestinationImmutable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDestinationImmutable);
         return false;
     }
 
@@ -3537,7 +3485,7 @@
         case ShaderType::Compute:
             if (context->getClientVersion() < ES_3_1)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kES31Required);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kES31Required);
                 return false;
             }
             break;
@@ -3546,7 +3494,7 @@
             if (!context->getExtensions().geometryShaderAny() &&
                 context->getClientVersion() < ES_3_2)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidShaderType);
                 return false;
             }
             break;
@@ -3555,7 +3503,7 @@
             if (!context->getExtensions().tessellationShaderEXT &&
                 context->getClientVersion() < ES_3_2)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidShaderType);
                 return false;
             }
             break;
@@ -3564,13 +3512,13 @@
             if (!context->getExtensions().tessellationShaderEXT &&
                 context->getClientVersion() < ES_3_2)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidShaderType);
                 return false;
             }
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderType);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidShaderType);
             return false;
     }
 
@@ -3586,7 +3534,7 @@
 {
     if (size < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeSize);
         return false;
     }
 
@@ -3605,19 +3553,19 @@
         case BufferUsage::DynamicCopy:
             if (context->getClientMajorVersion() < 3)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferUsage);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBufferUsage);
                 return false;
             }
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferUsage);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBufferUsage);
             return false;
     }
 
     if (!context->isValidBufferBinding(target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBufferTypes);
         return false;
     }
 
@@ -3625,20 +3573,19 @@
 
     if (!buffer)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferNotBound);
         return false;
     }
 
     if (buffer->hasWebGLXFBBindingConflict(context->isWebGL()))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kBufferBoundForTransformFeedback);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferBoundForTransformFeedback);
         return false;
     }
 
     if (buffer->isImmutable())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferImmutable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferImmutable);
         return false;
     }
 
@@ -3654,19 +3601,19 @@
 {
     if (size < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeSize);
         return false;
     }
 
     if (offset < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeOffset);
         return false;
     }
 
     if (!context->isValidBufferBinding(target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBufferTypes);
         return false;
     }
 
@@ -3674,7 +3621,7 @@
 
     if (!buffer)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferNotBound);
         return false;
     }
 
@@ -3684,21 +3631,20 @@
     // Verify that buffer is not currently mapped unless persistent
     if (buffer->isMapped() && !isPersistent)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferMapped);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferMapped);
         return false;
     }
 
     if (buffer->hasWebGLXFBBindingConflict(context->isWebGL()))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kBufferBoundForTransformFeedback);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferBoundForTransformFeedback);
         return false;
     }
 
     if (buffer->isImmutable() &&
         (buffer->getStorageExtUsageFlags() & GL_DYNAMIC_STORAGE_BIT_EXT) == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotUpdatable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferNotUpdatable);
         return false;
     }
 
@@ -3707,13 +3653,13 @@
     checkedSize += offset;
     if (!checkedSize.IsValid())
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kParamOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kParamOverflow);
         return false;
     }
 
     if (size + offset > buffer->getSize())
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInsufficientBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInsufficientBufferSize);
         return false;
     }
 
@@ -3726,13 +3672,13 @@
 {
     if (!context->getExtensions().requestExtensionANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (!context->isExtensionRequestable(name))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotRequestable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotRequestable);
         return false;
     }
 
@@ -3745,13 +3691,13 @@
 {
     if (!context->getExtensions().requestExtensionANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (!context->isExtensionDisablable(name))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotDisablable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotDisablable);
         return false;
     }
 
@@ -3769,7 +3715,7 @@
         texture >
             GL_TEXTURE0 + static_cast<GLuint>(context->getCaps().maxCombinedTextureImageUnits) - 1)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidCombinedImageUnit);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidCombinedImageUnit);
         return false;
     }
 
@@ -3795,7 +3741,7 @@
 
     if (programObject->getAttachedShader(shaderObject->getType()))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kShaderAttachmentHasShader);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kShaderAttachmentHasShader);
         return false;
     }
 
@@ -3810,13 +3756,13 @@
 {
     if (index >= static_cast<GLuint>(context->getCaps().maxVertexAttributes))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxVertexAttribute);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxVertexAttribute);
         return false;
     }
 
     if (strncmp(name, "gl_", 3) == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kNameBeginsWithGL);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNameBeginsWithGL);
         return false;
     }
 
@@ -3828,7 +3774,7 @@
         {
             // The WebGL spec (section 6.20) disallows strings containing invalid ESSL characters
             // for shader-related entry points
-            context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidNameCharacters);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidNameCharacters);
             return false;
         }
 
@@ -3926,14 +3872,13 @@
         {
             // INVALID_OPERATION is generated by BlendEquationi*() if <mode> is one of the advanced
             // blend equations defined in KHR_blend_equation_advanced.
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kPLSAdvancedBlendNotSupported);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSAdvancedBlendNotSupported);
             return false;
         }
         return true;
     }
 
-    context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBlendEquation);
+    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBlendEquation);
     return false;
 }
 
@@ -3944,13 +3889,13 @@
 {
     if (!ValidBlendEquationMode(context, modeRGB))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBlendEquation);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBlendEquation);
         return false;
     }
 
     if (!ValidBlendEquationMode(context, modeAlpha))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBlendEquation);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBlendEquation);
         return false;
     }
 
@@ -3995,13 +3940,12 @@
         {
             if (context->isWebGL())
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidConstantColor);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidConstantColor);
                 return false;
             }
 
             WARN() << kConstantColorAlphaLimitation;
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kConstantColorAlphaLimitation);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kConstantColorAlphaLimitation);
             return false;
         }
     }
@@ -4023,7 +3967,7 @@
         case GL_REQUESTABLE_EXTENSIONS_ANGLE:
             if (!context->getExtensions().requestExtensionANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidName);
                 return false;
             }
             break;
@@ -4031,13 +3975,13 @@
         case GL_SERIALIZED_CONTEXT_STRING_ANGLE:
             if (!context->getExtensions().getSerializedContextStringANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidName);
                 return false;
             }
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidName);
             return false;
     }
 
@@ -4048,7 +3992,7 @@
 {
     if (width <= 0.0f || isNaN(width))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidWidth);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidWidth);
         return false;
     }
 
@@ -4062,7 +4006,7 @@
 {
     if (context->isWebGL() && zNear > zFar)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidDepthRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidDepthRange);
         return false;
     }
 
@@ -4090,7 +4034,7 @@
 {
     if (!context->getExtensions().framebufferMultisampleANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -4099,7 +4043,7 @@
     // generated.
     if (samples > context->getCaps().maxSamples)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kSamplesOutOfRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kSamplesOutOfRange);
         return false;
     }
 
@@ -4112,7 +4056,7 @@
         const TextureCaps &formatCaps = context->getTextureCaps().get(internalformat);
         if (static_cast<GLuint>(samples) > formatCaps.getMaxSamples())
         {
-            context->validationError(entryPoint, GL_OUT_OF_MEMORY, kSamplesOutOfRange);
+            ANGLE_VALIDATION_ERROR(GL_OUT_OF_MEMORY, kSamplesOutOfRange);
             return false;
         }
     }
@@ -4127,7 +4071,7 @@
 {
     if (!ValidFramebufferTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFramebufferTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFramebufferTarget);
         return false;
     }
 
@@ -4186,7 +4130,7 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidCullMode);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidCullMode);
             return false;
     }
 
@@ -4206,12 +4150,12 @@
     {
         if (context->getShader(program))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kExpectedProgramName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExpectedProgramName);
             return false;
         }
         else
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProgramName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidProgramName);
             return false;
         }
     }
@@ -4232,12 +4176,12 @@
     {
         if (context->getProgramResolveLink(shader))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidShaderName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidShaderName);
             return false;
         }
         else
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kExpectedShaderName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExpectedShaderName);
             return false;
         }
     }
@@ -4260,7 +4204,7 @@
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, func);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, func);
             return false;
     }
 
@@ -4292,7 +4236,7 @@
     const Shader *attachedShader = programObject->getAttachedShader(shaderObject->getType());
     if (attachedShader != shaderObject)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kShaderToDetachMustBeAttached);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kShaderToDetachMustBeAttached);
         return false;
     }
 
@@ -4305,7 +4249,7 @@
 {
     if (index >= static_cast<GLuint>(context->getCaps().maxVertexAttributes))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxVertexAttribute);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxVertexAttribute);
         return false;
     }
 
@@ -4318,7 +4262,7 @@
 {
     if (index >= static_cast<GLuint>(context->getCaps().maxVertexAttributes))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxVertexAttribute);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxVertexAttribute);
         return false;
     }
 
@@ -4343,7 +4287,7 @@
         case GL_CCW:
             break;
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, mode);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, mode);
             return false;
     }
 
@@ -4362,7 +4306,7 @@
 {
     if (bufsize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBufferSize);
         return false;
     }
 
@@ -4375,7 +4319,7 @@
 
     if (index >= static_cast<GLuint>(programObject->getActiveAttributeCount()))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxActiveUniform);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxActiveUniform);
         return false;
     }
 
@@ -4394,7 +4338,7 @@
 {
     if (bufsize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBufferSize);
         return false;
     }
 
@@ -4407,7 +4351,7 @@
 
     if (index >= static_cast<GLuint>(programObject->getActiveUniformCount()))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxActiveUniform);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxActiveUniform);
         return false;
     }
 
@@ -4423,7 +4367,7 @@
 {
     if (maxcount < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeMaxCount);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeMaxCount);
         return false;
     }
 
@@ -4455,7 +4399,7 @@
         {
             // The WebGL spec (section 6.20) disallows strings containing invalid ESSL characters
             // for shader-related entry points
-            context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidNameCharacters);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidNameCharacters);
             return false;
         }
 
@@ -4470,13 +4414,13 @@
 
     if (!programObject)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotBound);
         return false;
     }
 
     if (!programObject->isLinked())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotLinked);
         return false;
     }
 
@@ -4527,7 +4471,7 @@
 {
     if (bufsize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBufferSize);
         return false;
     }
 
@@ -4549,7 +4493,7 @@
 {
     if (bufsize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBufferSize);
         return false;
     }
 
@@ -4575,11 +4519,10 @@
         case GL_FRAGMENT_SHADER:
             break;
         case GL_COMPUTE_SHADER:
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kUnimplementedComputeShaderPrecision);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kUnimplementedComputeShaderPrecision);
             return false;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderType);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidShaderType);
             return false;
     }
 
@@ -4594,7 +4537,7 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPrecision);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPrecision);
             return false;
     }
 
@@ -4610,7 +4553,7 @@
 {
     if (bufsize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBufferSize);
         return false;
     }
 
@@ -4637,7 +4580,7 @@
     // shader-related entry points
     if (context->isWebGL() && !IsValidESSLString(name, strlen(name)))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidNameCharacters);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidNameCharacters);
         return false;
     }
 
@@ -4650,7 +4593,7 @@
 
     if (!programObject->isLinked())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotLinked);
         return false;
     }
 
@@ -4667,7 +4610,7 @@
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, mode);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, mode);
             return false;
     }
 
@@ -4679,7 +4622,7 @@
         case GL_TEXTURE_FILTERING_HINT_CHROMIUM:
             if (!context->getExtensions().textureFilteringHintCHROMIUM)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, target);
                 return false;
             }
             break;
@@ -4688,7 +4631,7 @@
             if (context->getClientVersion() < ES_3_0 &&
                 !context->getExtensions().standardDerivativesOES)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, target);
                 return false;
             }
             break;
@@ -4699,13 +4642,13 @@
         case GL_FOG_HINT:
             if (context->getClientMajorVersion() >= 2)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, target);
                 return false;
             }
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, target);
             return false;
     }
 
@@ -4759,7 +4702,7 @@
         {
             case GL_UNPACK_IMAGE_HEIGHT:
             case GL_UNPACK_SKIP_IMAGES:
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
                 return false;
 
             case GL_UNPACK_ROW_LENGTH:
@@ -4767,7 +4710,7 @@
             case GL_UNPACK_SKIP_PIXELS:
                 if (!context->getExtensions().unpackSubimageEXT)
                 {
-                    context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
                     return false;
                 }
                 break;
@@ -4777,7 +4720,7 @@
             case GL_PACK_SKIP_PIXELS:
                 if (!context->getExtensions().packSubimageNV)
                 {
-                    context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
                     return false;
                 }
                 break;
@@ -4786,7 +4729,7 @@
 
     if (param < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeParam);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeParam);
         return false;
     }
 
@@ -4795,7 +4738,7 @@
         case GL_UNPACK_ALIGNMENT:
             if (param != 1 && param != 2 && param != 4 && param != 8)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidUnpackAlignment);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidUnpackAlignment);
                 return false;
             }
             break;
@@ -4803,7 +4746,7 @@
         case GL_PACK_ALIGNMENT:
             if (param != 1 && param != 2 && param != 4 && param != 8)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidUnpackAlignment);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidUnpackAlignment);
                 return false;
             }
             break;
@@ -4811,7 +4754,7 @@
         case GL_PACK_REVERSE_ROW_ORDER_ANGLE:
             if (!context->getExtensions().packReverseRowOrderANGLE)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             }
             break;
 
@@ -4826,7 +4769,7 @@
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
 
@@ -4863,7 +4806,7 @@
 {
     if (width < 0 || height < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeSize);
         return false;
     }
 
@@ -4882,7 +4825,7 @@
     if (std::find(shaderBinaryFormats.begin(), shaderBinaryFormats.end(), binaryformat) ==
         shaderBinaryFormats.end())
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderBinaryFormat);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidShaderBinaryFormat);
         return false;
     }
 
@@ -4890,20 +4833,20 @@
 
     if (n <= 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidShaderCount);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidShaderCount);
         return false;
     }
 
     if (length < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeLength);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeLength);
         return false;
     }
 
     // GL_SHADER_BINARY_ANGLE shader binaries contain a single shader.
     if (n > 1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidShaderCount);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidShaderCount);
         return false;
     }
 
@@ -4920,7 +4863,7 @@
     if (memcmp(versionString.data(), angle::GetANGLEShaderProgramVersion(), versionString.size()) !=
         0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidShaderBinary);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidShaderBinary);
         return false;
     }
 
@@ -4929,7 +4872,7 @@
     stream.readEnum(&shaderType);
     if (shaderObject->getType() != shaderType)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedShaderBinaryType);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedShaderBinaryType);
         return false;
     }
 
@@ -4945,7 +4888,7 @@
 {
     if (count < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeCount);
         return false;
     }
 
@@ -4966,7 +4909,7 @@
 {
     if (!IsValidStencilFunc(func))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidStencil);
         return false;
     }
 
@@ -4982,13 +4925,13 @@
 {
     if (!IsValidStencilFace(face))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidStencil);
         return false;
     }
 
     if (!IsValidStencilFunc(func))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidStencil);
         return false;
     }
 
@@ -5007,7 +4950,7 @@
 {
     if (!IsValidStencilFace(face))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidStencil);
         return false;
     }
 
@@ -5022,19 +4965,19 @@
 {
     if (!IsValidStencilOp(fail))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidStencil);
         return false;
     }
 
     if (!IsValidStencilOp(zfail))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidStencil);
         return false;
     }
 
     if (!IsValidStencilOp(zpass))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidStencil);
         return false;
     }
 
@@ -5050,7 +4993,7 @@
 {
     if (!IsValidStencilFace(face))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidStencil);
         return false;
     }
 
@@ -5310,7 +5253,7 @@
 {
     if (width < 0 || height < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kViewportNegativeSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kViewportNegativeSize);
         return false;
     }
 
@@ -5432,7 +5375,7 @@
 {
     if (!ValidCap(context, cap, false))
     {
-        context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, cap);
+        ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, cap);
         return false;
     }
 
@@ -5440,7 +5383,7 @@
     {
         if (IsCapBannedWithActivePLS(cap))
         {
-            context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kPLSCapNotAllowed, cap);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kPLSCapNotAllowed, cap);
             return false;
         }
     }
@@ -5452,15 +5395,14 @@
 {
     if (!ValidCap(context, cap, false))
     {
-        context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, cap);
+        ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, cap);
         return false;
     }
 
     if (context->getLimitations().noSampleAlphaToCoverageSupport &&
         cap == GL_SAMPLE_ALPHA_TO_COVERAGE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kNoSampleAlphaToCoveragesLimitation);
+        ANGLE_VALIDATION_ERROR(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.
@@ -5472,7 +5414,7 @@
     {
         if (IsCapBannedWithActivePLS(cap))
         {
-            context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kPLSCapNotAllowed, cap);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kPLSCapNotAllowed, cap);
             return false;
         }
     }
@@ -5504,7 +5446,7 @@
     if (context->getClientMajorVersion() < 3 && !context->getExtensions().fboRenderMipmapOES &&
         level != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFramebufferTextureLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidFramebufferTextureLevel);
         return false;
     }
 
@@ -5526,13 +5468,12 @@
             {
                 if (level > log2(caps.max2DTextureSize))
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
                     return false;
                 }
                 if (tex->getType() != TextureType::_2D)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kInvalidTextureTarget);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureTarget);
                     return false;
                 }
             }
@@ -5542,13 +5483,12 @@
             {
                 if (level != 0)
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
                     return false;
                 }
                 if (tex->getType() != TextureType::Rectangle)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kTextureTargetMismatch);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureTargetMismatch);
                     return false;
                 }
             }
@@ -5563,13 +5503,12 @@
             {
                 if (level > log2(caps.maxCubeMapTextureSize))
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
                     return false;
                 }
                 if (tex->getType() != TextureType::CubeMap)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kTextureTargetMismatch);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureTargetMismatch);
                     return false;
                 }
             }
@@ -5580,20 +5519,19 @@
                 if (context->getClientVersion() < ES_3_1 &&
                     !context->getExtensions().textureMultisampleANGLE)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kMultisampleTextureExtensionOrES31Required);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                           kMultisampleTextureExtensionOrES31Required);
                     return false;
                 }
 
                 if (level != 0)
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE, kLevelNotZero);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kLevelNotZero);
                     return false;
                 }
                 if (tex->getType() != TextureType::_2DMultisample)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kTextureTargetMismatch);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureTargetMismatch);
                     return false;
                 }
             }
@@ -5603,28 +5541,26 @@
             {
                 if (!context->getExtensions().YUVTargetEXT)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kYUVTargetExtensionRequired);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kYUVTargetExtensionRequired);
                     return false;
                 }
 
                 if (attachment != GL_COLOR_ATTACHMENT0)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidAttachment);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidAttachment);
                     return false;
                 }
 
                 if (tex->getType() != TextureType::External)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kTextureTargetMismatch);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureTargetMismatch);
                     return false;
                 }
             }
             break;
 
             default:
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
                 return false;
         }
     }
@@ -5646,7 +5582,7 @@
     // FramebufferTextureLayer in ES 3.x, which has broader support.
     if (!context->getExtensions().texture3DOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -5655,7 +5591,7 @@
     if (context->getClientMajorVersion() < 3 && !context->getExtensions().fboRenderMipmapOES &&
         level != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFramebufferTextureLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidFramebufferTextureLevel);
         return false;
     }
 
@@ -5677,24 +5613,24 @@
             {
                 if (level > log2(caps.max3DTextureSize))
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
                     return false;
                 }
                 if (zoffset >= caps.max3DTextureSize)
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidZOffset);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidZOffset);
                     return false;
                 }
                 if (tex->getType() != TextureType::_3D)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureType);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureType);
                     return false;
                 }
             }
             break;
 
             default:
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureTarget);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureTarget);
                 return false;
         }
     }
@@ -5794,7 +5730,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateGetTexParameterBase(context, entryPoint, target, pname, nullptr);
@@ -5808,7 +5744,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateGetTexParameterBase(context, entryPoint, target, pname, nullptr);
@@ -5863,7 +5799,7 @@
 {
     if (!ValidCap(context, cap, true))
     {
-        context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, cap);
+        ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, cap);
         return false;
     }
 
@@ -5877,8 +5813,7 @@
     if (context->hasActiveTransformFeedback(program))
     {
         // ES 3.0.4 section 2.15 page 91
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kTransformFeedbackActiveDuringLink);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTransformFeedbackActiveDuringLink);
         return false;
     }
 
@@ -5949,7 +5884,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateTexParameterBase(context, entryPoint, target, pname, -1, true, params);
@@ -5963,7 +5898,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateTexParameterBase(context, entryPoint, target, pname, -1, true, params);
@@ -5981,25 +5916,25 @@
             // ES 3.1.0 section 7.3 page 72
             if (context->getShader(program))
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kExpectedProgramName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExpectedProgramName);
                 return false;
             }
             else
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProgramName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidProgramName);
                 return false;
             }
         }
         if (!programObject->isLinked())
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotLinked);
             return false;
         }
     }
     if (context->getState().isTransformFeedbackActiveUnpaused())
     {
         // ES 3.0.4 section 2.15 page 91
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kTransformFeedbackUseProgram);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTransformFeedbackUseProgram);
         return false;
     }
 
@@ -6013,13 +5948,13 @@
 {
     if (!context->getExtensions().fenceNV)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kNVFenceNotSupported);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNVFenceNotSupported);
         return false;
     }
 
     if (n < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeCount);
         return false;
     }
 
@@ -6030,7 +5965,7 @@
 {
     if (!context->getExtensions().fenceNV)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kNVFenceNotSupported);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNVFenceNotSupported);
         return false;
     }
 
@@ -6038,13 +5973,13 @@
 
     if (fenceObject == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFence);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFence);
         return false;
     }
 
     if (!fenceObject->isSet())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFenceState);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFenceState);
         return false;
     }
 
@@ -6058,13 +5993,13 @@
 {
     if (!context->getExtensions().fenceNV)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kNVFenceNotSupported);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNVFenceNotSupported);
         return false;
     }
 
     if (n < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeCount);
         return false;
     }
 
@@ -6079,7 +6014,7 @@
 {
     if (!context->getExtensions().fenceNV)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kNVFenceNotSupported);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNVFenceNotSupported);
         return false;
     }
 
@@ -6087,13 +6022,13 @@
 
     if (fenceObject == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFence);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFence);
         return false;
     }
 
     if (!fenceObject->isSet())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFenceState);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFenceState);
         return false;
     }
 
@@ -6104,7 +6039,7 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
             return false;
     }
 
@@ -6115,7 +6050,7 @@
 {
     if (!context->getExtensions().robustnessEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -6131,13 +6066,13 @@
 {
     if (!context->getExtensions().translatedShaderSourceANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (bufsize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBufferSize);
         return false;
     }
 
@@ -6145,7 +6080,7 @@
 
     if (!shaderObject)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidShaderName);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidShaderName);
         return false;
     }
 
@@ -6156,7 +6091,7 @@
 {
     if (!context->getExtensions().fenceNV)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kNVFenceNotSupported);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNVFenceNotSupported);
         return false;
     }
 
@@ -6170,13 +6105,13 @@
 {
     if (!context->getExtensions().fenceNV)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kNVFenceNotSupported);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNVFenceNotSupported);
         return false;
     }
 
     if (condition != GL_ALL_COMPLETED_NV)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFenceCondition);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFenceCondition);
         return false;
     }
 
@@ -6184,7 +6119,7 @@
 
     if (fenceObject == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFence);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFence);
         return false;
     }
 
@@ -6195,7 +6130,7 @@
 {
     if (!context->getExtensions().fenceNV)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kNVFenceNotSupported);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNVFenceNotSupported);
         return false;
     }
 
@@ -6203,13 +6138,13 @@
 
     if (fenceObject == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFence);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFence);
         return false;
     }
 
     if (fenceObject->isSet() != GL_TRUE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFenceState);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFenceState);
         return false;
     }
 
@@ -6226,7 +6161,7 @@
 {
     if (!context->getExtensions().textureStorageEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -6248,13 +6183,13 @@
 {
     if (!context->getExtensions().instancedArraysANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (index >= static_cast<GLuint>(context->getCaps().maxVertexAttributes))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxVertexAttribute);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxVertexAttribute);
         return false;
     }
 
@@ -6262,8 +6197,7 @@
     {
         if (index == 0 && divisor != 0)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kAttributeZeroRequiresDivisorLimitation);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kAttributeZeroRequiresDivisorLimitation);
 
             // We also output an error message to the debugger window if tracing is active, so
             // that developers can see the error message.
@@ -6282,13 +6216,13 @@
 {
     if (!context->getExtensions().instancedArraysEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (index >= static_cast<GLuint>(context->getCaps().maxVertexAttributes))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxVertexAttribute);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxVertexAttribute);
         return false;
     }
 
@@ -6318,7 +6252,7 @@
     {
         // The debug marker calls should not set error state
         // However, it seems reasonable to set an error state if the extension is not enabled
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -6333,7 +6267,7 @@
                              GLsizei width)
 {
     UNIMPLEMENTED();
-    context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
     return false;
 }
 
@@ -6348,13 +6282,13 @@
 {
     if (!context->getExtensions().textureStorageEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -6368,7 +6302,7 @@
 {
     if (!context->getExtensions().parallelShaderCompileKHR)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     return true;
@@ -6383,7 +6317,7 @@
 {
     if (!context->getExtensions().multiDrawANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     for (GLsizei drawID = 0; drawID < drawcount; ++drawID)
@@ -6406,7 +6340,7 @@
 {
     if (!context->getExtensions().multiDrawANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     for (GLsizei drawID = 0; drawID < drawcount; ++drawID)
@@ -6430,7 +6364,7 @@
 {
     if (!context->getExtensions().multisampledRenderToTextureEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -6444,7 +6378,7 @@
     // otherwise GL_INVALID_VALUE is generated.
     if (samples > context->getCaps().maxSamples)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kSamplesOutOfRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kSamplesOutOfRange);
         return false;
     }
 
@@ -6463,7 +6397,7 @@
         const TextureCaps &formatCaps = context->getTextureCaps().get(sizedInternalFormat);
         if (static_cast<GLuint>(samples) > formatCaps.getMaxSamples())
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kSamplesOutOfRange);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kSamplesOutOfRange);
             return false;
         }
     }
@@ -6472,13 +6406,13 @@
     if (!context->getExtensions().multisampledRenderToTexture2EXT &&
         attachment != GL_COLOR_ATTACHMENT0)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidAttachment);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidAttachment);
         return false;
     }
 
     if (!ValidTexture2DDestinationTarget(context, textarget))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
@@ -6495,7 +6429,7 @@
 {
     if (!context->getExtensions().multisampledRenderToTextureEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     if (!ValidateRenderbufferStorageParametersBase(context, entryPoint, target, samples,
@@ -6509,7 +6443,7 @@
     // otherwise GL_INVALID_VALUE is generated.
     if (samples > context->getCaps().maxSamples)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kSamplesOutOfRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kSamplesOutOfRange);
         return false;
     }
 
@@ -6522,7 +6456,7 @@
         const TextureCaps &formatCaps = context->getTextureCaps().get(internalformat);
         if (static_cast<GLuint>(samples) > formatCaps.getMaxSamples())
         {
-            context->validationError(entryPoint, GL_OUT_OF_MEMORY, kSamplesOutOfRange);
+            ANGLE_VALIDATION_ERROR(GL_OUT_OF_MEMORY, kSamplesOutOfRange);
             return false;
         }
     }
@@ -6540,47 +6474,45 @@
     {
         case TextureType::Rectangle:
             ASSERT(!context->getExtensions().textureRectangleANGLE);
-            context->validationError(entryPoint, GL_INVALID_ENUM, kTextureRectangleNotSupported);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kTextureRectangleNotSupported);
             break;
 
         case TextureType::_3D:
         case TextureType::_2DArray:
             ASSERT(context->getClientMajorVersion() < 3);
-            context->validationError(entryPoint, GL_INVALID_ENUM, kES3Required);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kES3Required);
             break;
 
         case TextureType::_2DMultisample:
             ASSERT(context->getClientVersion() < Version(3, 1) &&
                    !context->getExtensions().textureMultisampleANGLE);
-            context->validationError(entryPoint, GL_INVALID_ENUM,
-                                     kMultisampleTextureExtensionOrES31Required);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kMultisampleTextureExtensionOrES31Required);
             break;
 
         case TextureType::_2DMultisampleArray:
             ASSERT(!context->getExtensions().textureStorageMultisample2dArrayOES);
-            context->validationError(entryPoint, GL_INVALID_ENUM,
-                                     kMultisampleArrayExtensionRequired);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kMultisampleArrayExtensionRequired);
             break;
 
         case TextureType::External:
             ASSERT(!context->getExtensions().EGLImageExternalOES &&
                    !context->getExtensions().EGLStreamConsumerExternalNV);
-            context->validationError(entryPoint, GL_INVALID_ENUM, kExternalTextureNotSupported);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExternalTextureNotSupported);
             break;
 
         case TextureType::VideoImage:
             ASSERT(!context->getExtensions().videoTextureWEBGL);
-            context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
             break;
 
         case TextureType::Buffer:
             ASSERT(!context->getExtensions().textureBufferOES &&
                    !context->getExtensions().textureBufferEXT);
-            context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kExtensionNotEnabled);
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
     }
 }
 

src/libANGLE/validationES2.h

diff --git a/src/libANGLE/validationES2.h b/src/libANGLE/validationES2.h
index 199e8cb..5980350 100644
--- a/src/libANGLE/validationES2.h
+++ b/src/libANGLE/validationES2.h
@@ -40,14 +40,14 @@
 {
     if (!context->isValidBufferBinding(target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, err::kInvalidBufferTypes);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, err::kInvalidBufferTypes);
         return false;
     }
 
     if (!context->getState().isBindGeneratesResourceEnabled() &&
         !context->isBufferGenerated(buffer))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, err::kObjectNotGenerated);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kObjectNotGenerated);
         return false;
     }
 
@@ -80,7 +80,7 @@
 
     if (stride < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, err::kNegativeStride);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, err::kNegativeStride);
         return false;
     }
 
@@ -89,15 +89,13 @@
         const Caps &caps = context->getCaps();
         if (stride > caps.maxVertexAttribStride)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE,
-                                     err::kExceedsMaxVertexAttribStride);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, err::kExceedsMaxVertexAttribStride);
             return false;
         }
 
         if (index >= static_cast<GLuint>(caps.maxVertexAttribBindings))
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE,
-                                     err::kExceedsMaxVertexAttribBindings);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, err::kExceedsMaxVertexAttribBindings);
             return false;
         }
     }
@@ -111,7 +109,7 @@
     if (!nullBufferAllowed && context->getState().getTargetBuffer(BufferBinding::Array) == 0 &&
         ptr != nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, err::kClientDataInVertexArray);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kClientDataInVertexArray);
         return false;
     }
 
@@ -121,7 +119,7 @@
         // The WebGL API does not support the GL_FIXED data type.
         if (type == VertexAttribType::Fixed)
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, err::kFixedNotInWebGL);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, err::kFixedNotInWebGL);
             return false;
         }
 
@@ -158,17 +156,17 @@
     Texture *textureObject = context->getTexture(texture);
     if (textureObject && textureObject->getType() != target)
     {
-        context->validationErrorF(
-            entryPoint, GL_INVALID_OPERATION, err::kTextureTargetMismatchWithLabel,
-            static_cast<uint8_t>(target), static_cast<uint8_t>(textureObject->getType()),
-            textureObject->getLabel().c_str());
+        ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, err::kTextureTargetMismatchWithLabel,
+                                static_cast<uint8_t>(target),
+                                static_cast<uint8_t>(textureObject->getType()),
+                                textureObject->getLabel().c_str());
         return false;
     }
 
     if (!context->getState().isBindGeneratesResourceEnabled() &&
         !context->isTextureGenerated(texture))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, err::kObjectNotGenerated);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kObjectNotGenerated);
         return false;
     }
 

src/libANGLE/validationES3.cpp

diff --git a/src/libANGLE/validationES3.cpp b/src/libANGLE/validationES3.cpp
index 1fa94ed..cfaba16 100644
--- a/src/libANGLE/validationES3.cpp
+++ b/src/libANGLE/validationES3.cpp
@@ -41,7 +41,7 @@
 {
     if (!(context->getExtensions().multiviewOVR || context->getExtensions().multiview2OVR))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kMultiviewNotAvailable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMultiviewNotAvailable);
         return false;
     }
 
@@ -52,13 +52,13 @@
 
     if (texture.value != 0 && numViews < 1)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kMultiviewViewsTooSmall);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kMultiviewViewsTooSmall);
         return false;
     }
 
     if (static_cast<GLuint>(numViews) > context->getCaps().maxViews)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kMultiviewViewsTooLarge);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kMultiviewViewsTooLarge);
         return false;
     }
 
@@ -73,15 +73,14 @@
     TextureType type = texture->getType();
     if (!ValidMipLevel(context, type, level))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
         return false;
     }
 
     const auto &format = texture->getFormat(NonCubeTextureTypeToTarget(type), level);
     if (format.info->compressed)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kCompressedTexturesNotAttachable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kCompressedTexturesNotAttachable);
         return false;
     }
     return true;
@@ -95,7 +94,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -112,7 +111,7 @@
     // Check for ES3 uniform entry points
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -123,7 +122,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateGenOrDelete(context, entryPoint, n);
@@ -133,12 +132,12 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     if (count < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeCount);
         return false;
     }
     return true;
@@ -156,19 +155,19 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (!context->getExtensions().copyTexture3dANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kANGLECopyTexture3DUnavailable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kANGLECopyTexture3DUnavailable);
         return false;
     }
 
     if (!ValidTexture3DTarget(context, source->getType()))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
@@ -190,14 +189,14 @@
         case GL_DEPTH_STENCIL:
             break;
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat,
-                                      srcInternalFormat);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kInvalidInternalFormat,
+                                    srcInternalFormat);
             return false;
     }
 
     if (!ValidTexture3DTarget(context, TextureTargetToType(destTarget)))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
@@ -262,8 +261,7 @@
         case GL_RGBA32UI:
             break;
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat,
-                                      internalFormat);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kInvalidInternalFormat, internalFormat);
             return false;
     }
 
@@ -284,13 +282,13 @@
         // The type and format are valid if any supported internal format has that type and format
         if (!ValidDesktopFormat(format))
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFormat);
             return false;
         }
 
         if (!ValidDesktopType(type))
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidType);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidType);
             return false;
         }
     }
@@ -302,7 +300,7 @@
         {
             if (!context->getExtensions().yuvInternalFormatANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFormat);
                 return false;
             }
         }
@@ -310,14 +308,14 @@
         {
             if (!ValidES3Format(format))
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFormat);
                 return false;
             }
         }
 
         if (!ValidES3Type(type) || (type == GL_HALF_FLOAT_OES && context->isWebGL()))
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidType);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidType);
             return false;
         }
     }
@@ -328,8 +326,7 @@
     // the validation codepaths for glTexImage2D/3D, we record a GL_INVALID_VALUE error.
     if (!ValidES3InternalFormat(internalFormat))
     {
-        context->validationErrorF(entryPoint, GL_INVALID_VALUE, kInvalidInternalFormat,
-                                  internalFormat);
+        ANGLE_VALIDATION_ERRORF(GL_INVALID_VALUE, kInvalidInternalFormat, internalFormat);
         return false;
     }
 
@@ -340,7 +337,7 @@
     // INVALID_OPERATION error.
     if (target == TextureType::_3D && (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, k3DDepthStencil);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, k3DDepthStencil);
         return false;
     }
 
@@ -349,7 +346,7 @@
         // Check if this is a valid format combination to load texture data
         if (!ValidDesktopFormatCombination(format, type, internalFormat))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormatCombination);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormatCombination);
             return false;
         }
     }
@@ -361,8 +358,7 @@
         {
             if (type != GL_UNSIGNED_BYTE)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kInvalidFormatCombination);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormatCombination);
                 return false;
             }
         }
@@ -370,8 +366,7 @@
         {
             if (!ValidES3FormatCombination(format, type, internalFormat))
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kInvalidFormatCombination);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormatCombination);
                 return false;
             }
         }
@@ -380,8 +375,7 @@
     const InternalFormat &formatInfo = GetInternalFormatInfo(internalFormat, type);
     if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions()))
     {
-        context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat,
-                                  internalFormat);
+        ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kInvalidInternalFormat, internalFormat);
         return false;
     }
 
@@ -394,8 +388,7 @@
 {
     if (IsETC1Format(format) || IsPVRTC1Format(format))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kInternalFormatRequiresTexture2D);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInternalFormatRequiresTexture2D);
         return false;
     }
 
@@ -408,16 +401,14 @@
 {
     if (IsETC1Format(format) || IsPVRTC1Format(format))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kInternalFormatRequiresTexture2D);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInternalFormatRequiresTexture2D);
         return false;
     }
 
     if (IsETC2EACFormat(format))
     {
         // ES 3.1, Section 8.7, page 169.
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kInternalFormatRequiresTexture2DArray);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInternalFormatRequiresTexture2DArray);
         return false;
     }
 
@@ -425,32 +416,28 @@
                                     context->getExtensions().textureCompressionAstcSliced3dKHR))
     {
         // GL_KHR_texture_compression_astc_hdr, TEXTURE_3D is not supported without HDR profile
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kInternalFormatRequiresTexture2DArrayASTC);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInternalFormatRequiresTexture2DArrayASTC);
         return false;
     }
 
     if (IsS3TCFormat(format))
     {
         // GL_EXT_texture_compression_s3tc
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kInternalFormatRequiresTexture2DArrayS3TC);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInternalFormatRequiresTexture2DArrayS3TC);
         return false;
     }
 
     if (IsRGTCFormat(format))
     {
         // GL_EXT_texture_compression_rgtc
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kInternalFormatRequiresTexture2DArrayRGTC);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInternalFormatRequiresTexture2DArrayRGTC);
         return false;
     }
 
     if (IsBPTCFormat(format) && (context->getLimitations().noCompressedTexture3D))
     {
         // GL_EXT_texture_compression_bptc
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kInternalFormatRequiresTexture2DArrayBPTC);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInternalFormatRequiresTexture2DArrayBPTC);
         return false;
     }
 
@@ -484,19 +471,19 @@
         // texture, texture target can only be TEXTURE_2D and there is no mipmap support
         if (!context->getExtensions().yuvInternalFormatANGLE || !isSubImage)
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFormat);
             return false;
         }
 
         if (target != TextureTarget::_2D)
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
             return false;
         }
 
         if (level != 0)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
             return false;
         }
     }
@@ -512,13 +499,13 @@
     // Verify zero border
     if (border != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidBorder);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidBorder);
         return false;
     }
 
     if (xoffset < 0 || yoffset < 0 || zoffset < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeOffset);
         return false;
     }
 
@@ -526,7 +513,7 @@
         std::numeric_limits<GLsizei>::max() - yoffset < height ||
         std::numeric_limits<GLsizei>::max() - zoffset < depth)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kOffsetOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kOffsetOverflow);
         return false;
     }
 
@@ -540,7 +527,7 @@
             if (width > (caps.max2DTextureSize >> level) ||
                 height > (caps.max2DTextureSize >> level))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
             break;
@@ -549,12 +536,12 @@
             ASSERT(level == 0);
             if (width > caps.maxRectangleTextureSize || height > caps.maxRectangleTextureSize)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
             if (isCompressed)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kRectangleTextureCompressed);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kRectangleTextureCompressed);
                 return false;
             }
             break;
@@ -562,14 +549,13 @@
         case TextureType::CubeMap:
             if (!isSubImage && width != height)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kCubemapFacesEqualDimensions);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kCubemapFacesEqualDimensions);
                 return false;
             }
 
             if (width > (caps.maxCubeMapTextureSize >> level))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
             break;
@@ -579,7 +565,7 @@
                 height > (caps.max3DTextureSize >> level) ||
                 depth > (caps.max3DTextureSize >> level))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
             break;
@@ -588,7 +574,7 @@
             if (width > (caps.max2DTextureSize >> level) ||
                 height > (caps.max2DTextureSize >> level) || depth > caps.maxArrayTextureLayers)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
             break;
@@ -596,14 +582,13 @@
         case TextureType::CubeMapArray:
             if (!isSubImage && width != height)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kCubemapFacesEqualDimensions);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kCubemapFacesEqualDimensions);
                 return false;
             }
 
             if (width > (caps.maxCubeMapTextureSize >> level))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
 
@@ -611,36 +596,35 @@
                 height > (caps.max3DTextureSize >> level) ||
                 depth > (caps.max3DTextureSize >> level))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
 
             if (!isSubImage && depth % 6 != 0)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kCubemapInvalidDepth);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kCubemapInvalidDepth);
                 return false;
             }
             break;
 
         case TextureType::InvalidEnum:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kEnumInvalid);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumInvalid);
             return false;
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                      ToGLenum(texType));
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, ToGLenum(texType));
             return false;
     }
 
     Texture *texture = context->getTextureByType(texType);
     if (!texture)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kMissingTexture);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMissingTexture);
         return false;
     }
 
     if (texture->getImmutableFormat() && !isSubImage)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureIsImmutable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureIsImmutable);
         return false;
     }
 
@@ -649,7 +633,7 @@
         isSubImage ? texture->getFormat(target, level).info->internalFormat : internalformat;
     if (isSubImage && actualInternalFormat == GL_NONE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidMipLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidMipLevel);
         return false;
     }
 
@@ -663,14 +647,14 @@
         {
             if (!actualFormatInfo.compressed && !actualFormatInfo.paletted)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kCompressedMismatch);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kCompressedMismatch);
                 return false;
             }
 
             if (!actualFormatInfo.textureSupport(context->getClientVersion(),
                                                  context->getExtensions()))
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFormat);
                 return false;
             }
         }
@@ -703,14 +687,13 @@
                     height, depth, texture->getWidth(target, level),
                     texture->getHeight(target, level), texture->getDepth(target, level)))
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kInvalidCompressedImageSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidCompressedImageSize);
                 return false;
             }
 
             if (format != actualInternalFormat)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedFormat);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMismatchedFormat);
                 return false;
             }
 
@@ -718,8 +701,8 @@
             if (IsETC1Format(actualInternalFormat) &&
                 !context->getExtensions().compressedETC1RGB8SubTextureEXT)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat,
-                                          internalformat);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kInvalidInternalFormat,
+                                        internalformat);
                 return false;
             }
         }
@@ -728,8 +711,7 @@
             if (!ValidCompressedImageSize(context, actualInternalFormat, level, width, height,
                                           depth))
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kInvalidCompressedImageSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidCompressedImageSize);
                 return false;
             }
         }
@@ -737,7 +719,7 @@
         // Disallow 3D-only compressed formats from being set on 2D textures
         if (actualFormatInfo.compressedBlockDepth > 1 && texType != TextureType::_3D)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureTarget);
             return false;
         }
     }
@@ -749,8 +731,7 @@
             const InternalFormat &internalFormatInfo = GetSizedInternalFormatInfo(internalformat);
             if (internalFormatInfo.compressed)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_VALUE, kInvalidInternalFormat,
-                                          internalformat);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_VALUE, kInvalidInternalFormat, internalformat);
                 return false;
             }
         }
@@ -767,7 +748,7 @@
     {
         if (isCompressed != actualFormatInfo.compressed)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kCompressedMismatch);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kCompressedMismatch);
             return false;
         }
 
@@ -781,14 +762,14 @@
             static_cast<size_t>(yoffset + height) > texture->getHeight(target, level) ||
             static_cast<size_t>(zoffset + depth) > texture->getDepth(target, level))
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kOffsetOverflow);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kOffsetOverflow);
             return false;
         }
 
         if (width > 0 && height > 0 && depth > 0 && pixels == nullptr &&
             context->getState().getTargetBuffer(BufferBinding::PixelUnpack) == nullptr)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kPixelDataNull);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kPixelDataNull);
             return false;
         }
     }
@@ -814,7 +795,7 @@
 
             if ((offset % dataBytesPerPixel) != 0)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kDataTypeNotAligned);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDataTypeNotAligned);
                 return false;
             }
         }
@@ -822,7 +803,7 @@
         // ...the buffer object's data store is currently mapped but not persistently.
         if (pixelUnpackBuffer->isMapped() && !pixelUnpackBuffer->isPersistentlyMapped())
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferMapped);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferMapped);
             return false;
         }
     }
@@ -855,8 +836,7 @@
             GLint dataStoreWidth = unpack.rowLength ? unpack.rowLength : width;
             if (unpack.skipPixels + width > dataStoreWidth)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kInvalidUnpackParametersForWebGL);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidUnpackParametersForWebGL);
                 return false;
             }
             if (target == TextureTarget::_3D || target == TextureTarget::_2DArray)
@@ -864,8 +844,7 @@
                 GLint dataStoreHeight = unpack.imageHeight ? unpack.imageHeight : height;
                 if (unpack.skipRows + height > dataStoreHeight)
                 {
-                    context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                             kInvalidUnpackParametersForWebGL);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidUnpackParametersForWebGL);
                     return false;
                 }
             }
@@ -896,7 +875,7 @@
 {
     if (!ValidTexture2DDestinationTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
@@ -926,7 +905,7 @@
 {
     if (!ValidTexture3DDestinationTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
@@ -1238,7 +1217,7 @@
     // is RGB9_E5 and copy to such a texture, generate INVALID_OPERATION.
     if (textureFormat.info->internalFormat == GL_RGB9_E5)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFormat);
         return false;
     }
 
@@ -1247,7 +1226,7 @@
         if (!IsValidES3CopyTexImageCombination(*textureFormat.info, *source->getFormat().info,
                                                readFramebufferID))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidCopyCombination);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidCopyCombination);
             return false;
         }
     }
@@ -1258,7 +1237,7 @@
         const InternalFormat &copyFormat = GetInternalFormatInfo(internalformat, GL_UNSIGNED_BYTE);
         if (!IsValidES3CopyTexImageCombination(copyFormat, framebufferFormat, readFramebufferID))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidCopyCombination);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidCopyCombination);
             return false;
         }
     }
@@ -1284,7 +1263,7 @@
 {
     if (!ValidTexture2DDestinationTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
@@ -1310,7 +1289,7 @@
 {
     if (!ValidTexture3DDestinationTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
@@ -1335,7 +1314,7 @@
 
     if (levels > log2(maxDim) + 1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidMipLevels);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidMipLevels);
         return false;
     }
 
@@ -1358,7 +1337,7 @@
         {
             if (width > caps.max2DTextureSize || height > caps.max2DTextureSize)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
         }
@@ -1368,13 +1347,13 @@
         {
             if (levels != 1)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevels);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevels);
                 return false;
             }
 
             if (width > caps.maxRectangleTextureSize || height > caps.maxRectangleTextureSize)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
         }
@@ -1384,14 +1363,13 @@
         {
             if (width != height)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kCubemapFacesEqualDimensions);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kCubemapFacesEqualDimensions);
                 return false;
             }
 
             if (width > caps.maxCubeMapTextureSize)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
         }
@@ -1402,7 +1380,7 @@
             if (width > caps.max3DTextureSize || height > caps.max3DTextureSize ||
                 depth > caps.max3DTextureSize)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
         }
@@ -1413,7 +1391,7 @@
             if (width > caps.max2DTextureSize || height > caps.max2DTextureSize ||
                 depth > caps.maxArrayTextureLayers)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
         }
@@ -1423,27 +1401,26 @@
         {
             if (width != height)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kCubemapFacesEqualDimensions);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kCubemapFacesEqualDimensions);
                 return false;
             }
 
             if (width > caps.maxCubeMapTextureSize)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
 
             if (width > caps.max3DTextureSize || height > caps.max3DTextureSize ||
                 depth > caps.max3DTextureSize)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
                 return false;
             }
 
             if (depth % 6 != 0)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kCubemapInvalidDepth);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kCubemapInvalidDepth);
                 return false;
             }
         }
@@ -1464,13 +1441,13 @@
     Texture *texture = context->getTextureByType(target);
     if (!texture || texture->id().value == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kMissingTexture);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMissingTexture);
         return false;
     }
 
     if (texture->getImmutableFormat())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureIsImmutable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureIsImmutable);
         return false;
     }
 
@@ -1492,20 +1469,19 @@
     {
         if (!context->getExtensions().yuvInternalFormatANGLE)
         {
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kInvalidInternalFormat,
-                                      internalformat);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kInvalidInternalFormat, internalformat);
             return false;
         }
 
         if (target != TextureType::_2D)
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
             return false;
         }
 
         if (levels != 1)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
             return false;
         }
     }
@@ -1513,15 +1489,13 @@
     const InternalFormat &formatInfo = GetSizedInternalFormatInfo(internalformat);
     if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions()))
     {
-        context->validationErrorF(entryPoint, GL_INVALID_ENUM, kInvalidInternalFormat,
-                                  internalformat);
+        ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kInvalidInternalFormat, internalformat);
         return false;
     }
 
     if (!formatInfo.sized)
     {
-        context->validationErrorF(entryPoint, GL_INVALID_ENUM, kInvalidInternalFormat,
-                                  internalformat);
+        ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kInvalidInternalFormat, internalformat);
         return false;
     }
 
@@ -1529,7 +1503,7 @@
     {
         if (target == TextureType::Rectangle)
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, kRectangleTextureCompressed);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kRectangleTextureCompressed);
             return false;
         }
 
@@ -1555,7 +1529,7 @@
 
         if (!ValidCompressedImageSize(context, formatInfo.internalFormat, 0, width, height, depth))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidCompressedImageSize);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidCompressedImageSize);
             return false;
         }
     }
@@ -1574,7 +1548,7 @@
 {
     if (width < 1 || height < 1 || depth < 1 || levels < 1)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureSizeTooSmall);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kTextureSizeTooSmall);
         return false;
     }
 
@@ -1619,7 +1593,7 @@
 {
     if (!ValidTexture2DTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
@@ -1638,7 +1612,7 @@
 {
     if (!ValidTexture3DTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
@@ -1653,7 +1627,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -1664,7 +1638,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -1679,7 +1653,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -1694,7 +1668,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -1711,7 +1685,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -1725,7 +1699,7 @@
     {
         if (layer < 0)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeLayer);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeLayer);
             return false;
         }
 
@@ -1738,15 +1712,13 @@
             {
                 if (level > log2(caps.max2DTextureSize))
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE,
-                                             kFramebufferTextureInvalidMipLevel);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kFramebufferTextureInvalidMipLevel);
                     return false;
                 }
 
                 if (layer >= caps.maxArrayTextureLayers)
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE,
-                                             kFramebufferTextureInvalidLayer);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kFramebufferTextureInvalidLayer);
                     return false;
                 }
             }
@@ -1756,15 +1728,13 @@
             {
                 if (level > log2(caps.max3DTextureSize))
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE,
-                                             kFramebufferTextureInvalidMipLevel);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kFramebufferTextureInvalidMipLevel);
                     return false;
                 }
 
                 if (layer >= caps.max3DTextureSize)
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE,
-                                             kFramebufferTextureInvalidLayer);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kFramebufferTextureInvalidLayer);
                     return false;
                 }
             }
@@ -1774,15 +1744,13 @@
             {
                 if (level != 0)
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE,
-                                             kFramebufferTextureInvalidMipLevel);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kFramebufferTextureInvalidMipLevel);
                     return false;
                 }
 
                 if (layer >= caps.maxArrayTextureLayers)
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE,
-                                             kFramebufferTextureInvalidLayer);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kFramebufferTextureInvalidLayer);
                     return false;
                 }
             }
@@ -1792,15 +1760,13 @@
             {
                 if (level > log2(caps.maxCubeMapTextureSize))
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE,
-                                             kFramebufferTextureInvalidMipLevel);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kFramebufferTextureInvalidMipLevel);
                     return false;
                 }
 
                 if (layer >= static_cast<GLint>(kCubeFaceCount))
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE,
-                                             kFramebufferTextureInvalidLayer);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kFramebufferTextureInvalidLayer);
                     return false;
                 }
             }
@@ -1810,31 +1776,28 @@
             {
                 if (level > log2(caps.maxCubeMapTextureSize))
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE,
-                                             kFramebufferTextureInvalidMipLevel);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kFramebufferTextureInvalidMipLevel);
                     return false;
                 }
 
                 if (layer >= caps.maxArrayTextureLayers)
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE,
-                                             kFramebufferTextureInvalidLayer);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kFramebufferTextureInvalidLayer);
                     return false;
                 }
             }
             break;
 
             default:
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kFramebufferTextureLayerIncorrectTextureType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                       kFramebufferTextureLayerIncorrectTextureType);
                 return false;
         }
 
         const auto &format = tex->getFormat(TextureTypeToTarget(tex->getType(), layer), level);
         if (format.info->compressed)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kCompressedTexturesNotAttachable);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kCompressedTexturesNotAttachable);
             return false;
         }
     }
@@ -1850,7 +1813,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -1866,7 +1829,7 @@
             defaultFramebuffer = context->getState().getReadFramebuffer()->isDefault();
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFramebufferTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFramebufferTarget);
             return false;
     }
 
@@ -1886,7 +1849,7 @@
 {
     if (width < 0 || height < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeSize);
         return false;
     }
 
@@ -1897,7 +1860,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -1920,13 +1883,13 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (end < start)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidElementRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidElementRange);
         return false;
     }
 
@@ -1952,7 +1915,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -1963,7 +1926,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -1971,7 +1934,7 @@
 
     if (readFBO == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kNoReadFramebuffer);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNoReadFramebuffer);
         return false;
     }
 
@@ -1982,7 +1945,7 @@
 
     if (src != GL_BACK && (src < GL_COLOR_ATTACHMENT0 || src > GL_COLOR_ATTACHMENT31))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidReadBuffer);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidReadBuffer);
         return false;
     }
 
@@ -1990,7 +1953,7 @@
     {
         if (src != GL_BACK)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidDefaultReadBuffer);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidDefaultReadBuffer);
             return false;
         }
     }
@@ -2000,7 +1963,7 @@
 
         if (drawBuffer >= static_cast<GLuint>(context->getCaps().maxColorAttachments))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kExceedsMaxColorAttachments);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExceedsMaxColorAttachments);
             return false;
         }
     }
@@ -2022,13 +1985,13 @@
 {
     if ((context->getClientMajorVersion() < 3) && !context->getExtensions().texture3DOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (!ValidTextureTarget(context, TextureTargetToType(target)))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
@@ -2043,20 +2006,20 @@
     const InternalFormat &formatInfo = GetSizedInternalFormatInfo(internalformat);
     if (!formatInfo.compressed)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidCompressedFormat);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidCompressedFormat);
         return false;
     }
 
     GLuint blockSize = 0;
     if (!formatInfo.computeCompressedImageSize(Extents(width, height, depth), &blockSize))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kIntegerOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIntegerOverflow);
         return false;
     }
 
     if (imageSize < 0 || static_cast<GLuint>(imageSize) != blockSize)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidCompressedImageSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidCompressedImageSize);
         return false;
     }
 
@@ -2065,7 +2028,7 @@
     {
         if (context->getClientVersion() < ES_3_2 || target != TextureTarget::CubeMapArray)
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
             return false;
         }
     }
@@ -2109,7 +2072,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -2122,7 +2085,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -2139,20 +2102,20 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (buffer.value != 0 && offset < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeOffset);
         return false;
     }
 
     if (!context->getState().isBindGeneratesResourceEnabled() &&
         !context->isBufferGenerated(buffer))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kObjectNotGenerated);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kObjectNotGenerated);
         return false;
     }
 
@@ -2163,20 +2126,19 @@
         {
             if (index >= static_cast<GLuint>(caps.maxTransformFeedbackSeparateAttributes))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kIndexExceedsTransformFeedbackBufferBindings);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE,
+                                       kIndexExceedsTransformFeedbackBufferBindings);
                 return false;
             }
             if (buffer.value != 0 && ((offset % 4) != 0 || (size % 4) != 0))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kOffsetAndSizeAlignment);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kOffsetAndSizeAlignment);
                 return false;
             }
 
             if (context->getState().isTransformFeedbackActive())
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kTransformFeedbackTargetActive);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTransformFeedbackTargetActive);
                 return false;
             }
             break;
@@ -2185,16 +2147,14 @@
         {
             if (index >= static_cast<GLuint>(caps.maxUniformBufferBindings))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kIndexExceedsMaxUniformBufferBindings);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxUniformBufferBindings);
                 return false;
             }
 
             ASSERT(caps.uniformBufferOffsetAlignment);
             if (buffer.value != 0 && (offset % caps.uniformBufferOffsetAlignment) != 0)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kUniformBufferOffsetAlignment);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kUniformBufferOffsetAlignment);
                 return false;
             }
             break;
@@ -2203,18 +2163,18 @@
         {
             if (context->getClientVersion() < ES_3_1)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumRequiresGLES31);
                 return false;
             }
             if (index >= static_cast<GLuint>(caps.maxAtomicCounterBufferBindings))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kIndexExceedsMaxAtomicCounterBufferBindings);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE,
+                                       kIndexExceedsMaxAtomicCounterBufferBindings);
                 return false;
             }
             if (buffer.value != 0 && (offset % 4) != 0)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kOffsetAlignment);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kOffsetAlignment);
                 return false;
             }
             break;
@@ -2223,20 +2183,18 @@
         {
             if (context->getClientVersion() < ES_3_1)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumRequiresGLES31);
                 return false;
             }
             if (index >= static_cast<GLuint>(caps.maxShaderStorageBufferBindings))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kExceedsMaxShaderStorageBufferBindings);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxShaderStorageBufferBindings);
                 return false;
             }
             ASSERT(caps.shaderStorageBufferOffsetAlignment);
             if (buffer.value != 0 && (offset % caps.shaderStorageBufferOffsetAlignment) != 0)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kShaderStorageBufferOffsetAlignment);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kShaderStorageBufferOffsetAlignment);
                 return false;
             }
             break;
@@ -2245,30 +2203,26 @@
         {
             if (!context->getExtensions().textureBufferAny())
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kTextureBufferExtensionNotAvailable);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kTextureBufferExtensionNotAvailable);
                 return false;
             }
             if (index != 0)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kIndexExceedsMaxUniformBufferBindings);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxUniformBufferBindings);
                 return false;
             }
             if (buffer.value != 0 && (offset % caps.textureBufferOffsetAlignment) != 0)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kTextureBufferOffsetAlignment);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kTextureBufferOffsetAlignment);
                 return false;
             }
             break;
         }
         case BufferBinding::InvalidEnum:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kEnumInvalid);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumInvalid);
             return false;
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                      ToGLenum(target));
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, ToGLenum(target));
             return false;
     }
 
@@ -2294,7 +2248,7 @@
 {
     if (buffer.value != 0 && size <= 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidBindBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidBindBufferSize);
         return false;
     }
     return ValidateBindBufferCommon(context, entryPoint, target, index, buffer, offset, size);
@@ -2309,7 +2263,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -2326,7 +2280,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -2350,7 +2304,7 @@
         case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
             if (value != GL_FALSE && value != GL_TRUE)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidBooleanValue);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidBooleanValue);
                 return false;
             }
             break;
@@ -2358,19 +2312,19 @@
         case GL_PROGRAM_SEPARABLE:
             if (context->getClientVersion() < ES_3_1)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kES31Required);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kES31Required);
                 return false;
             }
 
             if (value != GL_FALSE && value != GL_TRUE)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidBooleanValue);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidBooleanValue);
                 return false;
             }
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
             return false;
     }
 
@@ -2385,7 +2339,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -2407,7 +2361,7 @@
 {
     if (context->getClientMajorVersion() < 3 && !context->getExtensions().framebufferBlitNV)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -2430,7 +2384,7 @@
             }
             if (drawbuffer < 0 || drawbuffer >= context->getCaps().maxDrawBuffers)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
                 return false;
             }
             if (context->getExtensions().webglCompatibilityANGLE)
@@ -2448,14 +2402,13 @@
         case GL_STENCIL:
             if (drawbuffer != 0)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kInvalidDepthStencilDrawBuffer);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidDepthStencilDrawBuffer);
                 return false;
             }
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, buffer);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, buffer);
             return false;
     }
 
@@ -2477,7 +2430,7 @@
             }
             if (drawbuffer < 0 || drawbuffer >= context->getCaps().maxDrawBuffers)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
                 return false;
             }
             if (context->getExtensions().webglCompatibilityANGLE)
@@ -2493,7 +2446,7 @@
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, buffer);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, buffer);
             return false;
     }
 
@@ -2515,7 +2468,7 @@
             }
             if (drawbuffer < 0 || drawbuffer >= context->getCaps().maxDrawBuffers)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
                 return false;
             }
             if (context->getExtensions().webglCompatibilityANGLE)
@@ -2534,14 +2487,13 @@
         case GL_DEPTH:
             if (drawbuffer != 0)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kInvalidDepthStencilDrawBuffer);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidDepthStencilDrawBuffer);
                 return false;
             }
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, buffer);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, buffer);
             return false;
     }
 
@@ -2560,14 +2512,13 @@
         case GL_DEPTH_STENCIL:
             if (drawbuffer != 0)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kInvalidDepthStencilDrawBuffer);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidDepthStencilDrawBuffer);
                 return false;
             }
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, buffer);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, buffer);
             return false;
     }
 
@@ -2581,7 +2532,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -2602,7 +2553,7 @@
 {
     if ((context->getClientMajorVersion() < 3) && !context->getExtensions().texture3DOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -2626,7 +2577,7 @@
     const Texture *source = context->getTexture(sourceId);
     if (source == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTexture);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidSourceTexture);
         return false;
     }
 
@@ -2638,7 +2589,7 @@
     const Texture *dest = context->getTexture(destId);
     if (dest == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDestinationTexture);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidDestinationTexture);
         return false;
     }
 
@@ -2651,7 +2602,7 @@
 
     if (!ValidMipLevel(context, source->getType(), sourceLevel))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTextureLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidSourceTextureLevel);
         return false;
     }
 
@@ -2659,13 +2610,13 @@
     GLsizei sourceHeight = static_cast<GLsizei>(source->getHeight(sourceTarget, sourceLevel));
     if (sourceWidth == 0 || sourceHeight == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidSourceTextureSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidSourceTextureSize);
         return false;
     }
 
     if (dest->getImmutableFormat())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kDestinationImmutable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDestinationImmutable);
         return false;
     }
 
@@ -2695,7 +2646,7 @@
     const Texture *source = context->getTexture(sourceId);
     if (source == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTexture);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidSourceTexture);
         return false;
     }
 
@@ -2707,7 +2658,7 @@
     const Texture *dest = context->getTexture(destId);
     if (dest == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDestinationTexture);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidDestinationTexture);
         return false;
     }
 
@@ -2722,13 +2673,13 @@
 
     if (x < 0 || y < 0 || z < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeXYZ);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeXYZ);
         return false;
     }
 
     if (width < 0 || height < 0 || depth < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeHeightWidthDepth);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeHeightWidthDepth);
         return false;
     }
 
@@ -2736,19 +2687,19 @@
         static_cast<size_t>(y + height) > source->getHeight(sourceTarget, sourceLevel) ||
         static_cast<size_t>(z + depth) > source->getDepth(sourceTarget, sourceLevel))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kSourceTextureTooSmall);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kSourceTextureTooSmall);
         return false;
     }
 
     if (TextureTargetToType(destTarget) != dest->getType())
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDestinationTextureType);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidDestinationTextureType);
         return false;
     }
 
     if (xoffset < 0 || yoffset < 0 || zoffset < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeOffset);
         return false;
     }
 
@@ -2756,7 +2707,7 @@
         static_cast<size_t>(yoffset + height) > dest->getHeight(destTarget, destLevel) ||
         static_cast<size_t>(zoffset + depth) > dest->getDepth(destTarget, destLevel))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kDestinationTextureTooSmall);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kDestinationTextureTooSmall);
         return false;
     }
 
@@ -2778,7 +2729,7 @@
 {
     if ((context->getClientMajorVersion() < 3) && !context->getExtensions().texture3DOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2803,7 +2754,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -2833,7 +2784,7 @@
 {
     if ((context->getClientMajorVersion() < 3) && !context->getExtensions().texture3DOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -2859,7 +2810,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -2889,7 +2840,7 @@
 {
     if ((context->getClientMajorVersion() < 3) && !context->getExtensions().texture3DOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -2904,20 +2855,20 @@
 
     if (!formatInfo.compressed)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidCompressedFormat);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidCompressedFormat);
         return false;
     }
 
     GLuint blockSize = 0;
     if (!formatInfo.computeCompressedImageSize(Extents(width, height, depth), &blockSize))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kIntegerOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kIntegerOverflow);
         return false;
     }
 
     if (imageSize < 0 || static_cast<GLuint>(imageSize) != blockSize)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidCompressedImageSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidCompressedImageSize);
         return false;
     }
 
@@ -2926,14 +2877,14 @@
         if (context->getState().getTargetBuffer(BufferBinding::PixelUnpack) == nullptr)
         {
             // If data is null, we need an unpack buffer to read from
-            context->validationError(entryPoint, GL_INVALID_VALUE, kPixelDataNull);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kPixelDataNull);
             return false;
         }
 
         if (context->getTextureByTarget(target)->isCompressedFormatEmulated(context, target, level))
         {
             // TODO (anglebug.com/7464): Can't populate from a buffer using emulated format
-            context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidEmulatedFormat);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidEmulatedFormat);
             return false;
         }
     }
@@ -3020,8 +2971,7 @@
         if (transformFeedback != nullptr && transformFeedback->isActive())
         {
             // ES 3.0.4 section 2.15.1 page 86
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kTransformFeedbackActiveDelete);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTransformFeedbackActiveDelete);
             return false;
         }
     }
@@ -3050,7 +3000,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     switch (primitiveMode)
@@ -3061,7 +3011,7 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPrimitiveMode);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPrimitiveMode);
             return false;
     }
 
@@ -3070,7 +3020,7 @@
 
     if (transformFeedback->isActive())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kTransfomFeedbackAlreadyActive);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTransfomFeedbackAlreadyActive);
         return false;
     }
 
@@ -3081,15 +3031,15 @@
         {
             if (buffer->isMapped())
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferMapped);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferMapped);
                 return false;
             }
             if ((context->getLimitations().noDoubleBoundTransformFeedbackBuffers ||
                  context->getExtensions().webglCompatibilityANGLE) &&
                 buffer->isDoubleBoundForTransformFeedback())
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kTransformFeedbackBufferMultipleOutputs);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                       kTransformFeedbackBufferMultipleOutputs);
                 return false;
             }
         }
@@ -3099,20 +3049,19 @@
         context->getState().getLinkedProgramExecutable(context);
     if (!programExecutable)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotBound);
         return false;
     }
 
     if (programExecutable->getLinkedTransformFeedbackVaryings().empty())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kNoTransformFeedbackOutputVariables);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNoTransformFeedbackOutputVariables);
         return false;
     }
 
     if (!ValidateProgramExecutableXFBBuffersPresent(context, programExecutable))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kTransformFeedbackBufferMissing);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTransformFeedbackBufferMissing);
         return false;
     }
 
@@ -3127,7 +3076,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -3151,7 +3100,7 @@
 
     if (context->getClientMajorVersion() < 3 && !context->getExtensions().mapbufferOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3174,7 +3123,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -3190,7 +3139,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -3205,7 +3154,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -3227,7 +3176,7 @@
     unsigned int numParams;
     if (!context->getIndexedQueryParameterInfo(pname, &nativeType, &numParams))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
         return false;
     }
 
@@ -3243,13 +3192,12 @@
         case GL_COLOR_WRITEMASK:
             if (!context->getExtensions().drawBuffersIndexedAny())
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM,
-                                         kDrawBuffersIndexedExtensionNotAvailable);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kDrawBuffersIndexedExtensionNotAvailable);
                 return false;
             }
             if (index >= static_cast<GLuint>(caps.maxDrawBuffers))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
                 return false;
             }
             break;
@@ -3258,8 +3206,7 @@
         case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
             if (index >= static_cast<GLuint>(caps.maxTransformFeedbackSeparateAttributes))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kIndexExceedsMaxTransformFeedbackAttribs);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxTransformFeedbackAttribs);
                 return false;
             }
             break;
@@ -3269,8 +3216,7 @@
         case GL_UNIFORM_BUFFER_BINDING:
             if (index >= static_cast<GLuint>(caps.maxUniformBufferBindings))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kIndexExceedsMaxUniformBufferBindings);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxUniformBufferBindings);
                 return false;
             }
             break;
@@ -3279,8 +3225,7 @@
         case GL_MAX_COMPUTE_WORK_GROUP_COUNT:
             if (index >= 3u)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kIndexExceedsMaxWorkgroupDimensions);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxWorkgroupDimensions);
                 return false;
             }
             break;
@@ -3290,13 +3235,13 @@
         case GL_ATOMIC_COUNTER_BUFFER_BINDING:
             if (context->getClientVersion() < ES_3_1)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumRequiresGLES31);
                 return false;
             }
             if (index >= static_cast<GLuint>(caps.maxAtomicCounterBufferBindings))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kIndexExceedsMaxAtomicCounterBufferBindings);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE,
+                                       kIndexExceedsMaxAtomicCounterBufferBindings);
                 return false;
             }
             break;
@@ -3306,13 +3251,12 @@
         case GL_SHADER_STORAGE_BUFFER_BINDING:
             if (context->getClientVersion() < ES_3_1)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumRequiresGLES31);
                 return false;
             }
             if (index >= static_cast<GLuint>(caps.maxShaderStorageBufferBindings))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kExceedsMaxShaderStorageBufferBindings);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxShaderStorageBufferBindings);
                 return false;
             }
             break;
@@ -3323,25 +3267,24 @@
         case GL_VERTEX_BINDING_STRIDE:
             if (context->getClientVersion() < ES_3_1)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumRequiresGLES31);
                 return false;
             }
             if (index >= static_cast<GLuint>(caps.maxVertexAttribBindings))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kExceedsMaxVertexAttribBindings);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxVertexAttribBindings);
                 return false;
             }
             break;
         case GL_SAMPLE_MASK_VALUE:
             if (context->getClientVersion() < ES_3_1)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumRequiresGLES31);
                 return false;
             }
             if (index >= static_cast<GLuint>(caps.maxSampleMaskWords))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSampleMaskNumber);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidSampleMaskNumber);
                 return false;
             }
             break;
@@ -3353,17 +3296,17 @@
         case GL_IMAGE_BINDING_FORMAT:
             if (context->getClientVersion() < ES_3_1)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kEnumRequiresGLES31);
                 return false;
             }
             if (index >= static_cast<GLuint>(caps.maxImageUnits))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxImageUnits);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxImageUnits);
                 return false;
             }
             break;
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
 
@@ -3390,7 +3333,7 @@
 {
     if (context->getClientVersion() < ES_3_0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateIndexedStateQuery(context, entryPoint, target, index, nullptr);
@@ -3406,7 +3349,7 @@
 {
     if (context->getClientVersion() < ES_3_0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -3440,7 +3383,7 @@
 {
     if (context->getClientVersion() < ES_3_0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateIndexedStateQuery(context, entryPoint, target, index, nullptr);
@@ -3456,7 +3399,7 @@
 {
     if (context->getClientVersion() < ES_3_0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -3492,13 +3435,13 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (!context->isValidBufferBinding(readTarget) || !context->isValidBufferBinding(writeTarget))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBufferTypes);
         return false;
     }
 
@@ -3507,7 +3450,7 @@
 
     if (!readBuffer || !writeBuffer)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferNotBound);
         return false;
     }
 
@@ -3519,15 +3462,14 @@
     if ((readBuffer->isMapped() && !isReadPersistent) ||
         (writeBuffer->isMapped() && !isWritePersistent))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferMapped);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferMapped);
         return false;
     }
 
     if (readBuffer->hasWebGLXFBBindingConflict(context->isWebGL()) ||
         writeBuffer->hasWebGLXFBBindingConflict(context->isWebGL()))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kBufferBoundForTransformFeedback);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferBoundForTransformFeedback);
         return false;
     }
 
@@ -3542,26 +3484,26 @@
         !IsValueInRangeForNumericType<GLintptr>(readBuffer->getSize()) ||
         !IsValueInRangeForNumericType<GLintptr>(writeBuffer->getSize()))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kIntegerOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIntegerOverflow);
         return false;
     }
 
     if (readOffset < 0 || writeOffset < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeOffset);
         return false;
     }
 
     if (size < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeSize);
         return false;
     }
 
     if (checkedReadSum.ValueOrDie() > readBuffer->getSize() ||
         checkedWriteSum.ValueOrDie() > writeBuffer->getSize())
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kBufferOffsetOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kBufferOffsetOverflow);
         return false;
     }
 
@@ -3572,13 +3514,13 @@
         {
             // This shold not be possible.
             UNREACHABLE();
-            context->validationError(entryPoint, GL_INVALID_VALUE, kIntegerOverflow);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIntegerOverflow);
             return false;
         }
 
         if (checkedOffsetDiff.ValueOrDie() < size)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kCopyAlias);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kCopyAlias);
             return false;
         }
     }
@@ -3593,7 +3535,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -3602,7 +3544,7 @@
         case GL_EXTENSIONS:
             if (index >= context->getExtensionStringCount())
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsNumExtensions);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsNumExtensions);
                 return false;
             }
             break;
@@ -3610,19 +3552,18 @@
         case GL_REQUESTABLE_EXTENSIONS_ANGLE:
             if (!context->getExtensions().requestExtensionANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidName);
                 return false;
             }
             if (index >= context->getRequestableExtensionStringCount())
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kExceedsNumRequestableExtensions);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsNumRequestableExtensions);
                 return false;
             }
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidName);
             return false;
     }
 
@@ -3639,7 +3580,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -3658,7 +3599,7 @@
         if ((samples > 0 && context->getClientVersion() == ES_3_0) ||
             samples > context->getCaps().maxIntegerSamples)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kSamplesOutOfRange);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kSamplesOutOfRange);
             return false;
         }
     }
@@ -3667,7 +3608,7 @@
     const TextureCaps &formatCaps = context->getTextureCaps().get(internalformat);
     if (static_cast<GLuint>(samples) > formatCaps.getMaxSamples())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kSamplesOutOfRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kSamplesOutOfRange);
         return false;
     }
 
@@ -3684,7 +3625,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -3695,7 +3636,7 @@
 
     if (stride < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeStride);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeStride);
         return false;
     }
 
@@ -3704,7 +3645,7 @@
     {
         if (stride > caps.maxVertexAttribStride)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxVertexAttribStride);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxVertexAttribStride);
             return false;
         }
 
@@ -3713,7 +3654,7 @@
         // validation should be inherited.
         if (index >= static_cast<GLuint>(caps.maxVertexAttribBindings))
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxVertexAttribBindings);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxVertexAttribBindings);
             return false;
         }
     }
@@ -3725,7 +3666,7 @@
     if (context->getState().getVertexArrayId().value != 0 &&
         context->getState().getTargetBuffer(BufferBinding::Array) == 0 && pointer != nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kClientDataInVertexArray);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kClientDataInVertexArray);
         return false;
     }
 
@@ -3751,19 +3692,19 @@
 {
     if ((context->getClientMajorVersion() < 3) && !context->getExtensions().syncARB)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (bufSize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBufferSize);
         return false;
     }
 
     if (context->isContextLost())
     {
-        context->validationError(entryPoint, GL_CONTEXT_LOST, kContextLost);
+        ANGLE_VALIDATION_ERROR(GL_CONTEXT_LOST, kContextLost);
 
         if (pname == GL_SYNC_STATUS)
         {
@@ -3780,7 +3721,7 @@
     Sync *syncObject = context->getSync(syncPacked);
     if (!syncObject)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kSyncMissing);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kSyncMissing);
         return false;
     }
 
@@ -3793,7 +3734,7 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
             return false;
     }
 
@@ -3810,7 +3751,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -3828,14 +3769,14 @@
 {
     if (!context->getExtensions().multiDrawANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     if (context->getClientMajorVersion() < 3)
     {
         if (!context->getExtensions().instancedArraysAny())
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
             return false;
         }
         if (!ValidateDrawInstancedANGLE(context, entryPoint))
@@ -3865,14 +3806,14 @@
 {
     if (!context->getExtensions().multiDrawANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     if (context->getClientMajorVersion() < 3)
     {
         if (!context->getExtensions().instancedArraysAny())
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
             return false;
         }
         if (!ValidateDrawInstancedANGLE(context, entryPoint))
@@ -3901,7 +3842,7 @@
 {
     if (!context->getExtensions().baseVertexBaseInstanceANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3920,7 +3861,7 @@
 {
     if (!context->getExtensions().baseVertexBaseInstanceANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3939,7 +3880,7 @@
 {
     if (!context->getExtensions().multiDrawANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     if (drawcount < 0)
@@ -3970,7 +3911,7 @@
 {
     if (!context->getExtensions().multiDrawANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     if (drawcount < 0)
@@ -4007,7 +3948,7 @@
     {
         if (baseViewIndex < 0)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBaseViewIndex);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBaseViewIndex);
             return false;
         }
 
@@ -4023,8 +3964,7 @@
                 {
                     if (!context->getExtensions().multiviewMultisampleANGLE)
                     {
-                        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                                 kInvalidTextureType);
+                        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureType);
                         return false;
                     }
                 }
@@ -4032,15 +3972,14 @@
                 const Caps &caps = context->getCaps();
                 if (baseViewIndex + numViews > caps.maxArrayTextureLayers)
                 {
-                    context->validationError(entryPoint, GL_INVALID_VALUE,
-                                             kViewsExceedMaxArrayLayers);
+                    ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kViewsExceedMaxArrayLayers);
                     return false;
                 }
 
                 break;
             }
             default:
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureType);
                 return false;
         }
 
@@ -4131,7 +4070,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4208,7 +4147,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4217,7 +4156,7 @@
 
     if (!transformFeedback->isActive())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kTransformFeedbackNotActive);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTransformFeedbackNotActive);
         return false;
     }
 
@@ -4233,13 +4172,13 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (count < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeCount);
         return false;
     }
 
@@ -4252,14 +4191,13 @@
             const Caps &caps = context->getCaps();
             if (count > caps.maxTransformFeedbackSeparateAttributes)
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE,
-                                         kInvalidTransformFeedbackAttribsCount);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTransformFeedbackAttribsCount);
                 return false;
             }
             break;
         }
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, bufferMode);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, bufferMode);
             return false;
     }
 
@@ -4284,13 +4222,13 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (bufSize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBufferSize);
         return false;
     }
 
@@ -4302,8 +4240,7 @@
 
     if (index >= static_cast<GLuint>(programObject->getTransformFeedbackVaryingCount()))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE,
-                                 kTransformFeedbackVaryingIndexOutOfRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kTransformFeedbackVaryingIndexOutOfRange);
         return false;
     }
 
@@ -4317,7 +4254,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4329,8 +4266,7 @@
             // paused (3.0.2 pg 85 section 2.14.1)
             if (context->getState().isTransformFeedbackActiveUnpaused())
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kTransformFeedbackNotPaused);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTransformFeedbackNotPaused);
                 return false;
             }
 
@@ -4338,15 +4274,14 @@
             // 2.14.1)
             if (!context->isTransformFeedbackGenerated(id))
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kTransformFeedbackDoesNotExist);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTransformFeedbackDoesNotExist);
                 return false;
             }
         }
         break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, target);
             return false;
     }
 
@@ -4359,7 +4294,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4370,7 +4305,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4380,13 +4315,13 @@
     // Current transform feedback must be active and not paused in order to pause (3.0.2 pg 86)
     if (!transformFeedback->isActive())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kTransformFeedbackNotActive);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTransformFeedbackNotActive);
         return false;
     }
 
     if (transformFeedback->isPaused())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kTransformFeedbackPaused);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTransformFeedbackPaused);
         return false;
     }
 
@@ -4397,7 +4332,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4407,20 +4342,20 @@
     // Current transform feedback must be active and paused in order to resume (3.0.2 pg 86)
     if (!transformFeedback->isActive())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kTransformFeedbackNotActive);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTransformFeedbackNotActive);
         return false;
     }
 
     if (!transformFeedback->isPaused())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kTransformFeedbackNotPaused);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTransformFeedbackNotPaused);
         return false;
     }
 
     if (!ValidateProgramExecutableXFBBuffersPresent(
             context, context->getState().getLinkedProgramExecutable(context)))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kTransformFeedbackBufferMissing);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTransformFeedbackBufferMissing);
         return false;
     }
 
@@ -4437,7 +4372,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4454,7 +4389,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4468,7 +4403,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4482,7 +4417,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4496,7 +4431,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4508,7 +4443,7 @@
 
     if (!programObject->isLinked())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotLinked);
         return false;
     }
 
@@ -4524,13 +4459,13 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (uniformCount < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeCount);
         return false;
     }
 
@@ -4553,13 +4488,13 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (uniformCount < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeCount);
         return false;
     }
 
@@ -4577,7 +4512,7 @@
         case GL_UNIFORM_NAME_LENGTH:
             if (context->getExtensions().webglCompatibilityANGLE)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
                 return false;
             }
             break;
@@ -4589,13 +4524,13 @@
             break;
 
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
 
     if (uniformCount > programObject->getActiveUniformCount())
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxActiveUniform);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxActiveUniform);
         return false;
     }
 
@@ -4605,7 +4540,7 @@
 
         if (index >= static_cast<GLuint>(programObject->getActiveUniformCount()))
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxActiveUniform);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxActiveUniform);
             return false;
         }
     }
@@ -4620,7 +4555,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4654,7 +4589,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4666,7 +4601,7 @@
 
     if (uniformBlockIndex.value >= programObject->getActiveUniformBlockCount())
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxActiveUniformBlock);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxActiveUniformBlock);
         return false;
     }
 
@@ -4681,14 +4616,13 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (uniformBlockBinding >= static_cast<GLuint>(context->getCaps().maxUniformBufferBindings))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE,
-                                 kIndexExceedsMaxUniformBufferBindings);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxUniformBufferBindings);
         return false;
     }
 
@@ -4701,8 +4635,7 @@
     // if never linked, there won't be any uniform blocks
     if (uniformBlockIndex.value >= programObject->getActiveUniformBlockCount())
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE,
-                                 kIndexExceedsMaxUniformBufferBindings);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxUniformBufferBindings);
         return false;
     }
 
@@ -4718,7 +4651,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4732,19 +4665,19 @@
 {
     if ((context->getClientMajorVersion() < 3) && !context->getExtensions().syncARB)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (condition != GL_SYNC_GPU_COMMANDS_COMPLETE)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFenceCondition);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFenceCondition);
         return false;
     }
 
     if (flags != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFlags);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidFlags);
         return false;
     }
 
@@ -4755,7 +4688,7 @@
 {
     if ((context->getClientMajorVersion() < 3) && !context->getExtensions().syncARB)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4766,13 +4699,13 @@
 {
     if ((context->getClientMajorVersion() < 3) && !context->getExtensions().syncARB)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (syncPacked.value != 0 && !context->getSync(syncPacked))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kSyncMissing);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kSyncMissing);
         return false;
     }
 
@@ -4787,20 +4720,20 @@
 {
     if ((context->getClientMajorVersion() < 3) && !context->getExtensions().syncARB)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if ((flags & ~(GL_SYNC_FLUSH_COMMANDS_BIT)) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFlags);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidFlags);
         return false;
     }
 
     Sync *clientWaitSync = context->getSync(syncPacked);
     if (!clientWaitSync)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kSyncMissing);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kSyncMissing);
         return false;
     }
 
@@ -4815,26 +4748,26 @@
 {
     if ((context->getClientMajorVersion() < 3) && !context->getExtensions().syncARB)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (flags != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFlags);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidFlags);
         return false;
     }
 
     if (timeout != GL_TIMEOUT_IGNORED)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidTimeout);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTimeout);
         return false;
     }
 
     Sync *waitSync = context->getSync(syncPacked);
     if (!waitSync)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kSyncMissing);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kSyncMissing);
         return false;
     }
 
@@ -4848,7 +4781,7 @@
 {
     if ((context->getClientMajorVersion() < 3) && !context->getExtensions().syncARB)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4866,7 +4799,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4880,19 +4813,19 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
     if (GetIDValue(sampler) != 0 && !context->isSampler(sampler))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidSampler);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidSampler);
         return false;
     }
 
     if (unit >= static_cast<GLuint>(context->getCaps().maxCombinedTextureImageUnits))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidCombinedImageUnit);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidCombinedImageUnit);
         return false;
     }
 
@@ -4906,7 +4839,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4923,7 +4856,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4947,7 +4880,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
 
@@ -4995,7 +4928,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateGetSamplerParameterBase(context, entryPoint, sampler, pname, nullptr);
@@ -5009,7 +4942,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateGetSamplerParameterBase(context, entryPoint, sampler, pname, nullptr);
@@ -5059,7 +4992,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateSamplerParameterBase(context, entryPoint, sampler, pname, -1, true, params);
@@ -5073,7 +5006,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateSamplerParameterBase(context, entryPoint, sampler, pname, -1, true, params);
@@ -5118,12 +5051,12 @@
 {
     if (!context->getExtensions().blendFuncExtendedEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     if (index > 1)
@@ -5131,15 +5064,15 @@
         // This error is not explicitly specified but the spec does say that "<index> may be zero or
         // one to specify that the color be used as either the first or second color input to the
         // blend equation, respectively"
-        context->validationError(entryPoint, GL_INVALID_VALUE, kFragDataBindingIndexOutOfRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kFragDataBindingIndexOutOfRange);
         return false;
     }
     if (index == 1)
     {
         if (colorNumber >= context->getCaps().maxDualSourceDrawBuffers)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE,
-                                     kColorNumberGreaterThanMaxDualSourceDrawBuffers);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE,
+                                   kColorNumberGreaterThanMaxDualSourceDrawBuffers);
             return false;
         }
     }
@@ -5147,8 +5080,7 @@
     {
         if (colorNumber >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE,
-                                     kColorNumberGreaterThanMaxDrawBuffers);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kColorNumberGreaterThanMaxDrawBuffers);
             return false;
         }
     }
@@ -5177,12 +5109,12 @@
 {
     if (!context->getExtensions().blendFuncExtendedEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     Program *programObject = GetValidProgram(context, entryPoint, program);
@@ -5192,7 +5124,7 @@
     }
     if (!programObject->isLinked())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotLinked);
         return false;
     }
     return true;
@@ -5209,8 +5141,7 @@
 {
     if (!context->getExtensions().textureMultisampleANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kMultisampleTextureExtensionOrES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMultisampleTextureExtensionOrES31Required);
         return false;
     }
 
@@ -5228,8 +5159,8 @@
     if (!context->getExtensions().textureMultisampleANGLE &&
         !context->getExtensions().getTexLevelParameterANGLE)
     {
-        context->validationError(
-            entryPoint, GL_INVALID_OPERATION,
+        ANGLE_VALIDATION_ERROR(
+            GL_INVALID_OPERATION,
             kMultisampleTextureExtensionOrGetTexLevelParameterExtensionOrES31Required);
         return false;
     }
@@ -5247,8 +5178,8 @@
     if (!context->getExtensions().textureMultisampleANGLE &&
         !context->getExtensions().getTexLevelParameterANGLE)
     {
-        context->validationError(
-            entryPoint, GL_INVALID_OPERATION,
+        ANGLE_VALIDATION_ERROR(
+            GL_INVALID_OPERATION,
             kMultisampleTextureExtensionOrGetTexLevelParameterExtensionOrES31Required);
         return false;
     }
@@ -5264,8 +5195,7 @@
 {
     if (!context->getExtensions().textureMultisampleANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kMultisampleTextureExtensionOrES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMultisampleTextureExtensionOrES31Required);
         return false;
     }
 
@@ -5279,8 +5209,7 @@
 {
     if (!context->getExtensions().textureMultisampleANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kMultisampleTextureExtensionOrES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMultisampleTextureExtensionOrES31Required);
         return false;
     }
 
@@ -5303,15 +5232,15 @@
         //
         if (drawBufferIdx >= context->getCaps().maxColorAttachmentsWithActivePixelLocalStorage)
         {
-            context->validationErrorF(entryPoint, GL_INVALID_OPERATION,
-                                      kPLSDrawBufferExceedsAttachmentLimit, argumentName);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kPLSDrawBufferExceedsAttachmentLimit,
+                                    argumentName);
             return false;
         }
         if (drawBufferIdx >=
             context->getCaps().maxCombinedDrawBuffersAndPixelLocalStoragePlanes - numPLSPlanes)
         {
-            context->validationErrorF(entryPoint, GL_INVALID_OPERATION,
-                                      kPLSDrawBufferExceedsCombinedAttachmentLimit, argumentName);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION,
+                                    kPLSDrawBufferExceedsCombinedAttachmentLimit, argumentName);
             return false;
         }
     }

src/libANGLE/validationES31.cpp

diff --git a/src/libANGLE/validationES31.cpp b/src/libANGLE/validationES31.cpp
index c0222f7..d6b04b5 100644
--- a/src/libANGLE/validationES31.cpp
+++ b/src/libANGLE/validationES31.cpp
@@ -353,14 +353,14 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
     const Caps &caps = context->getCaps();
     if (relativeOffset > static_cast<GLuint>(caps.maxVertexAttribRelativeOffset))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kRelativeOffsetTooLarge);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kRelativeOffsetTooLarge);
         return false;
     }
 
@@ -368,7 +368,7 @@
     // An INVALID_OPERATION error is generated if the default vertex array object is bound.
     if (context->getState().getVertexArrayId().value == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kDefaultVertexArray);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDefaultVertexArray);
         return false;
     }
 
@@ -385,8 +385,8 @@
 {
     if (context->getClientVersion() < ES_3_1 && !context->getExtensions().drawBuffersIndexedAny())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kES31OrDrawBuffersIndexedExtensionNotAvailable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                               kES31OrDrawBuffersIndexedExtensionNotAvailable);
         return false;
     }
 
@@ -408,8 +408,8 @@
 {
     if (context->getClientVersion() < ES_3_1 && !context->getExtensions().drawBuffersIndexedAny())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kES31OrDrawBuffersIndexedExtensionNotAvailable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                               kES31OrDrawBuffersIndexedExtensionNotAvailable);
         return false;
     }
 
@@ -441,7 +441,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -457,20 +457,20 @@
     // DRAW_INDIRECT_BUFFER or to any enabled vertex array.
     if (state.getVertexArrayId().value == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kDefaultVertexArray);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDefaultVertexArray);
         return false;
     }
 
     if (context->getStateCache().hasAnyActiveClientAttrib())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kClientDataInVertexArray);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kClientDataInVertexArray);
         return false;
     }
 
     Buffer *drawIndirectBuffer = state.getTargetBuffer(BufferBinding::DrawIndirect);
     if (!drawIndirectBuffer)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kDrawIndirectBufferNotBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDrawIndirectBufferNotBound);
         return false;
     }
 
@@ -479,7 +479,7 @@
     GLint64 offset = reinterpret_cast<GLint64>(indirect);
     if ((static_cast<GLuint>(offset) % sizeof(GLuint)) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidIndirectOffset);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidIndirectOffset);
         return false;
     }
 
@@ -503,8 +503,7 @@
             if (!ValidateTransformFeedbackPrimitiveMode(
                     context, entryPoint, curTransformFeedback->getPrimitiveMode(), mode))
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kInvalidDrawModeTransformFeedback);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidDrawModeTransformFeedback);
                 return false;
             }
         }
@@ -512,8 +511,7 @@
         {
             // An INVALID_OPERATION error is generated if transform feedback is active and not
             // paused.
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kUnsupportedDrawModeForTransformFeedback);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kUnsupportedDrawModeForTransformFeedback);
             return false;
         }
     }
@@ -529,7 +527,7 @@
     if (!checkedSum.IsValid() ||
         checkedSum.ValueOrDie() > static_cast<size_t>(drawIndirectBuffer->getSize()))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kParamOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kParamOverflow);
         return false;
     }
 
@@ -552,7 +550,7 @@
     Buffer *elementArrayBuffer = vao->getElementArrayBuffer();
     if (!elementArrayBuffer)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kMustHaveElementArrayBinding);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMustHaveElementArrayBinding);
         return false;
     }
 
@@ -567,7 +565,7 @@
     if (!checkedSum.IsValid() ||
         checkedSum.ValueOrDie() > static_cast<size_t>(drawIndirectBuffer->getSize()))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kParamOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kParamOverflow);
         return false;
     }
 
@@ -581,21 +579,21 @@
 {
     if (!context->getExtensions().multiDrawIndirectEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     // An INVALID_VALUE error is generated if stride is neither 0 nor a multiple of 4.
     if ((stride & 3) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDrawBufferValue);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidDrawBufferValue);
         return false;
     }
 
     // An INVALID_VALUE error is generated if drawcount is not positive.
     if (drawcount <= 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidValueNonPositive);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidValueNonPositive);
         return false;
     }
 
@@ -982,7 +980,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -1011,7 +1009,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -1042,7 +1040,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -1063,7 +1061,7 @@
 {
     if (!context->getExtensions().memoryObjectEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1079,7 +1077,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -1106,7 +1104,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -1121,7 +1119,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -1148,7 +1146,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -1160,7 +1158,7 @@
 
     if (!ValidateNamedProgramInterface(programInterface))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProgramInterface);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidProgramInterface);
         return false;
     }
 
@@ -1176,32 +1174,32 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
     if (!context->isBufferGenerated(buffer))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kObjectNotGenerated);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kObjectNotGenerated);
         return false;
     }
 
     const Caps &caps = context->getCaps();
     if (bindingIndex >= static_cast<GLuint>(caps.maxVertexAttribBindings))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxVertexAttribBindings);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxVertexAttribBindings);
         return false;
     }
 
     if (offset < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeOffset);
         return false;
     }
 
     if (stride < 0 || stride > caps.maxVertexAttribStride)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxVertexAttribStride);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxVertexAttribStride);
         return false;
     }
 
@@ -1209,7 +1207,7 @@
     // An INVALID_OPERATION error is generated if the default vertex array object is bound.
     if (context->getState().getVertexArrayId().value == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kDefaultVertexArray);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDefaultVertexArray);
         return false;
     }
 
@@ -1223,14 +1221,14 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
     const Caps &caps = context->getCaps();
     if (bindingIndex >= static_cast<GLuint>(caps.maxVertexAttribBindings))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxVertexAttribBindings);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxVertexAttribBindings);
         return false;
     }
 
@@ -1238,7 +1236,7 @@
     // An INVALID_OPERATION error is generated if the default vertex array object is bound.
     if (context->getState().getVertexArrayId().value == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kDefaultVertexArray);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDefaultVertexArray);
         return false;
     }
 
@@ -1283,7 +1281,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -1291,20 +1289,20 @@
     // An INVALID_OPERATION error is generated if the default vertex array object is bound.
     if (context->getState().getVertexArrayId().value == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kDefaultVertexArray);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDefaultVertexArray);
         return false;
     }
 
     const Caps &caps = context->getCaps();
     if (attribIndex >= static_cast<GLuint>(caps.maxVertexAttributes))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxVertexAttribute);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxVertexAttribute);
         return false;
     }
 
     if (bindingIndex >= static_cast<GLuint>(caps.maxVertexAttribBindings))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxVertexAttribBindings);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxVertexAttribBindings);
         return false;
     }
 
@@ -1322,7 +1320,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -1334,19 +1332,19 @@
 
     if (!ValidateNamedProgramInterface(programInterface))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProgramInterface);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidProgramInterface);
         return false;
     }
 
     if (!ValidateProgramResourceIndex(programObject, programInterface, index))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProgramResourceIndex);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidProgramResourceIndex);
         return false;
     }
 
     if (bufSize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBufferSize);
         return false;
     }
 
@@ -1361,7 +1359,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -1370,25 +1368,24 @@
 
     if (executable == nullptr || !executable->hasLinkedShaderStage(ShaderType::Compute))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kNoActiveProgramWithComputeShader);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNoActiveProgramWithComputeShader);
         return false;
     }
 
     const Caps &caps = context->getCaps();
     if (numGroupsX > static_cast<GLuint>(caps.maxComputeWorkGroupCount[0]))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsComputeWorkGroupCountX);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsComputeWorkGroupCountX);
         return false;
     }
     if (numGroupsY > static_cast<GLuint>(caps.maxComputeWorkGroupCount[1]))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsComputeWorkGroupCountY);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsComputeWorkGroupCountY);
         return false;
     }
     if (numGroupsZ > static_cast<GLuint>(caps.maxComputeWorkGroupCount[2]))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsComputeWorkGroupCountZ);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsComputeWorkGroupCountZ);
         return false;
     }
 
@@ -1401,7 +1398,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -1410,27 +1407,26 @@
 
     if (executable == nullptr || !executable->hasLinkedShaderStage(ShaderType::Compute))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kNoActiveProgramWithComputeShader);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kNoActiveProgramWithComputeShader);
         return false;
     }
 
     if (indirect < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeOffset);
         return false;
     }
 
     if ((indirect & (sizeof(GLuint) - 1)) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kOffsetMustBeMultipleOfUint);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kOffsetMustBeMultipleOfUint);
         return false;
     }
 
     Buffer *dispatchIndirectBuffer = state.getTargetBuffer(BufferBinding::DispatchIndirect);
     if (!dispatchIndirectBuffer)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kDispatchIndirectBufferNotBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kDispatchIndirectBufferNotBound);
         return false;
     }
 
@@ -1439,7 +1435,7 @@
     if (!checkedSum.IsValid() ||
         checkedSum.ValueOrDie() > static_cast<GLuint64>(dispatchIndirectBuffer->getSize()))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInsufficientBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInsufficientBufferSize);
         return false;
     }
 
@@ -1458,32 +1454,32 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
     GLuint maxImageUnits = static_cast<GLuint>(context->getCaps().maxImageUnits);
     if (unit >= maxImageUnits)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxImageUnits);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxImageUnits);
         return false;
     }
 
     if (level < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeLevel);
         return false;
     }
 
     if (layer < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeLayer);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeLayer);
         return false;
     }
 
     if (access != GL_READ_ONLY && access != GL_WRITE_ONLY && access != GL_READ_WRITE)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidImageAccess);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidImageAccess);
         return false;
     }
 
@@ -1504,7 +1500,7 @@
         case GL_RGBA8_SNORM:
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidImageFormat);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidImageFormat);
             return false;
     }
 
@@ -1514,14 +1510,14 @@
 
         if (tex == nullptr)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kMissingTextureName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kMissingTextureName);
             return false;
         }
 
         if (!tex->getImmutableFormat() && tex->getType() != gl::TextureType::Buffer)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kTextureIsNeitherImmutableNorTextureBuffer);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                                   kTextureIsNeitherImmutableNorTextureBuffer);
             return false;
         }
     }
@@ -1537,7 +1533,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -1549,13 +1545,13 @@
 
     if (!programObject->isLinked())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotLinked);
         return false;
     }
 
     if (!ValidateLocationProgramInterface(programInterface))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProgramInterface);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidProgramInterface);
         return false;
     }
     return true;
@@ -1574,7 +1570,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -1585,35 +1581,34 @@
     }
     if (!ValidateProgramInterface(programInterface))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProgramInterface);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidProgramInterface);
         return false;
     }
     if (propCount <= 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidPropCount);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidPropCount);
         return false;
     }
     if (bufSize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBufSize);
         return false;
     }
     if (!ValidateProgramResourceIndex(programObject, programInterface, index))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProgramResourceIndex);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidProgramResourceIndex);
         return false;
     }
     for (GLsizei i = 0; i < propCount; i++)
     {
         if (!ValidateProgramResourceProperty(context, entryPoint, props[i]))
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProgramResourceProperty);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidProgramResourceProperty);
             return false;
         }
         if (!ValidateProgramResourcePropertyByInterface(props[i], programInterface))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kInvalidPropertyForProgramInterface);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidPropertyForProgramInterface);
             return false;
         }
     }
@@ -1629,7 +1624,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -1641,7 +1636,7 @@
 
     if (!ValidateProgramInterface(programInterface))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProgramInterface);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidProgramInterface);
         return false;
     }
 
@@ -1653,13 +1648,13 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
             return false;
     }
 
     if (pname == GL_MAX_NAME_LENGTH && programInterface == GL_ATOMIC_COUNTER_BUFFER)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kAtomicCounterResourceName);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kAtomicCounterResourceName);
         return false;
     }
 
@@ -1673,8 +1668,7 @@
                 break;
 
             default:
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kMaxActiveVariablesInterface);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kMaxActiveVariablesInterface);
                 return false;
         }
     }
@@ -1717,7 +1711,7 @@
 {
     if (!context->isProgramPipelineGenerated({pipeline}))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kObjectNotGenerated);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kObjectNotGenerated);
         return false;
     }
 
@@ -1755,7 +1749,7 @@
 
     if ((stages & ~knownShaderBits) && (stages != GL_ALL_SHADER_BITS))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kUnrecognizedShaderStageBit);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kUnrecognizedShaderStageBit);
         return false;
     }
 
@@ -1764,7 +1758,7 @@
     // glDeleteProgramPipelines.
     if (!context->isProgramPipelineGenerated({pipeline}))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kObjectNotGenerated);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kObjectNotGenerated);
         return false;
     }
 
@@ -1779,7 +1773,7 @@
     Program *program = context->getProgramNoResolveLink(programId);
     if (!program)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kProgramDoesNotExist);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kProgramDoesNotExist);
         return false;
     }
 
@@ -1790,7 +1784,7 @@
     program->resolveLink(context);
     if (!program->isSeparable())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotSeparable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotSeparable);
         return false;
     }
 
@@ -1798,7 +1792,7 @@
     // successfully linked.
     if (!program->isLinked())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotLinked);
         return false;
     }
 
@@ -1815,7 +1809,7 @@
     // DeleteProgramPipelines.
     if (!context->isProgramPipelineGenerated({pipeline}))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kObjectNotGenerated);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kObjectNotGenerated);
         return false;
     }
 
@@ -1823,14 +1817,14 @@
     // program or shader object.
     if ((programId.value != 0) && !context->isProgram(programId) && !context->isShader(programId))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kProgramDoesNotExist);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kProgramDoesNotExist);
         return false;
     }
 
     // An INVALID_OPERATION error is generated if program is the name of a shader object.
     if (context->isShader(programId))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExpectedProgramName);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExpectedProgramName);
         return false;
     }
 
@@ -1839,7 +1833,7 @@
     Program *program = context->getProgramNoResolveLink(programId);
     if ((programId.value != 0) && !program->isLinked())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotLinked);
         return false;
     }
 
@@ -1855,7 +1849,7 @@
     switch (type)
     {
         case ShaderType::InvalidEnum:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderType);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidShaderType);
             return false;
         case ShaderType::Vertex:
         case ShaderType::Fragment:
@@ -1865,7 +1859,7 @@
             if (!context->getExtensions().geometryShaderAny() &&
                 context->getClientVersion() < ES_3_2)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidShaderType);
                 return false;
             }
             break;
@@ -1874,7 +1868,7 @@
             if (!context->getExtensions().tessellationShaderEXT &&
                 context->getClientVersion() < ES_3_2)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidShaderType);
                 return false;
             }
             break;
@@ -1885,7 +1879,7 @@
     // GL_INVALID_VALUE is generated if count is negative.
     if (count < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeCount);
         return false;
     }
 
@@ -1913,7 +1907,7 @@
     // DeleteProgramPipelines.
     if ((pipeline.value == 0) || (!context->isProgramPipelineGenerated(pipeline)))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramPipelineDoesNotExist);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramPipelineDoesNotExist);
         return false;
     }
 
@@ -1938,7 +1932,7 @@
                    context->getClientVersion() >= ES_3_2;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
             return false;
     }
 
@@ -1956,7 +1950,7 @@
 
     if (!context->isProgramPipelineGenerated(pipeline))
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramPipelineDoesNotExist);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramPipelineDoesNotExist);
         return false;
     }
 
@@ -1972,13 +1966,13 @@
 {
     if (bufSize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBufferSize);
         return false;
     }
 
     if (!context->isProgramPipelineGenerated(pipeline))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kProgramPipelineDoesNotExist);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kProgramPipelineDoesNotExist);
         return false;
     }
 
@@ -1992,7 +1986,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2005,7 +1999,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2020,7 +2014,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2034,7 +2028,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2048,7 +2042,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2064,7 +2058,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2080,7 +2074,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2093,7 +2087,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2108,7 +2102,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2124,7 +2118,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2140,7 +2134,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2156,7 +2150,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2172,7 +2166,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2188,7 +2182,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2205,7 +2199,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2221,7 +2215,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2238,7 +2232,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2254,7 +2248,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2271,7 +2265,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2288,7 +2282,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2306,7 +2300,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2323,7 +2317,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2341,7 +2335,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2358,7 +2352,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2376,7 +2370,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2393,7 +2387,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2412,7 +2406,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2429,7 +2423,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2448,7 +2442,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2465,7 +2459,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2484,7 +2478,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2501,7 +2495,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2519,7 +2513,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2537,7 +2531,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2555,7 +2549,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2573,7 +2567,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2591,7 +2585,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2609,7 +2603,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2627,7 +2621,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2645,7 +2639,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2663,7 +2657,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2679,7 +2673,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2692,7 +2686,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2705,7 +2699,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2728,7 +2722,7 @@
 
     if (barriers == 0 || (barriers & ~supported_barrier_bits) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMemoryBarrierBit);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMemoryBarrierBit);
         return false;
     }
 
@@ -2741,7 +2735,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2756,7 +2750,7 @@
                                         GL_TEXTURE_FETCH_BARRIER_BIT | GL_UNIFORM_BARRIER_BIT;
     if (barriers == 0 || (barriers & ~supported_barrier_bits) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMemoryBarrierBit);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMemoryBarrierBit);
         return false;
     }
 
@@ -2770,7 +2764,7 @@
 {
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
 
@@ -2783,7 +2777,7 @@
 {
     if (!context->getExtensions().sampleShadingOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2813,13 +2807,13 @@
         // three-dimensional or two-dimensional array texture.
         if (tex == nullptr)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidTextureName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidTextureName);
             return false;
         }
 
         if (!ValidMipLevel(context, tex->getType(), level))
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
             return false;
         }
 
@@ -2827,7 +2821,7 @@
         // If textarget is TEXTURE_2D_MULTISAMPLE, then level must be zero.
         if (tex->getType() == TextureType::_2DMultisample && level != 0)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kLevelNotZero);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kLevelNotZero);
             return false;
         }
 
@@ -2837,7 +2831,7 @@
         if (context->getExtensions().textureStorageMultisample2dArrayOES &&
             tex->getType() == TextureType::_2DMultisampleArray && level != 0)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kLevelNotZero);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kLevelNotZero);
             return false;
         }
     }
@@ -2859,8 +2853,7 @@
 {
     if (!context->getExtensions().geometryShaderEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kGeometryShaderExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kGeometryShaderExtensionNotEnabled);
         return false;
     }
 
@@ -2877,8 +2870,7 @@
 {
     if (!context->getExtensions().geometryShaderOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kGeometryShaderExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kGeometryShaderExtensionNotEnabled);
         return false;
     }
 
@@ -2899,26 +2891,25 @@
 {
     if (!context->getExtensions().textureStorageMultisample2dArrayOES)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kMultisampleArrayExtensionRequired);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kMultisampleArrayExtensionRequired);
         return false;
     }
 
     if (target != TextureType::_2DMultisampleArray)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM,
-                                 kTargetMustBeTexture2DMultisampleArrayOES);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kTargetMustBeTexture2DMultisampleArrayOES);
         return false;
     }
 
     if (width < 1 || height < 1 || depth < 1)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeSize);
         return false;
     }
 
     if (depth > context->getCaps().maxArrayTextureLayers)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureDepthOutOfRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kTextureDepthOutOfRange);
         return false;
     }
 
@@ -2940,7 +2931,7 @@
 {
     if (!context->getExtensions().memoryObjectEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2956,17 +2947,17 @@
 {
     if (!context->getExtensions().blendFuncExtendedEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     if (context->getClientVersion() < ES_3_1)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES31Required);
         return false;
     }
     if (programInterface != GL_PROGRAM_OUTPUT)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kProgramInterfaceMustBeProgramOutput);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kProgramInterfaceMustBeProgramOutput);
         return false;
     }
     Program *programObject = GetValidProgram(context, entryPoint, program);
@@ -2976,7 +2967,7 @@
     }
     if (!programObject->isLinked())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kProgramNotLinked);
         return false;
     }
     return true;
@@ -2991,8 +2982,7 @@
 {
     if (!context->getExtensions().textureBufferOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kTextureBufferExtensionNotAvailable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureBufferExtensionNotAvailable);
         return false;
     }
 
@@ -3009,8 +2999,7 @@
 {
     if (!context->getExtensions().textureBufferOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kTextureBufferExtensionNotAvailable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureBufferExtensionNotAvailable);
         return false;
     }
 
@@ -3027,8 +3016,7 @@
 {
     if (!context->getExtensions().textureBufferEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kTextureBufferExtensionNotAvailable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureBufferExtensionNotAvailable);
         return false;
     }
 
@@ -3045,8 +3033,7 @@
 {
     if (!context->getExtensions().textureBufferEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kTextureBufferExtensionNotAvailable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureBufferExtensionNotAvailable);
         return false;
     }
 
@@ -3062,7 +3049,7 @@
 {
     if (target != TextureType::Buffer)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kTextureBufferTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kTextureBufferTarget);
         return false;
     }
 
@@ -3101,7 +3088,7 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kTextureBufferInternalFormat);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kTextureBufferInternalFormat);
             return false;
     }
 
@@ -3109,7 +3096,7 @@
     {
         if (!context->isBufferGenerated(bufferPacked))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureBufferInvalidBuffer);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureBufferInvalidBuffer);
             return false;
         }
     }
@@ -3129,25 +3116,25 @@
 
     if (offset < 0 || (offset % caps.textureBufferOffsetAlignment) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureBufferOffsetAlignment);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kTextureBufferOffsetAlignment);
         return false;
     }
     if (size <= 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kTextureBufferSize);
         return false;
     }
     const Buffer *buffer = context->getBuffer(bufferPacked);
 
     if (!buffer)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferNotBound);
         return false;
     }
 
     if (offset + size > buffer->getSize())
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureBufferSizeOffset);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kTextureBufferSizeOffset);
         return false;
     }
 

src/libANGLE/validationES32.cpp

diff --git a/src/libANGLE/validationES32.cpp b/src/libANGLE/validationES32.cpp
index bfdd4d4..6d1ccfb 100644
--- a/src/libANGLE/validationES32.cpp
+++ b/src/libANGLE/validationES32.cpp
@@ -63,7 +63,7 @@
 
     if (buf >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
         return false;
     }
 
@@ -88,7 +88,7 @@
 
     if (buf >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
         return false;
     }
 
@@ -116,7 +116,7 @@
 
     if (buf >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
         return false;
     }
 
@@ -142,7 +142,7 @@
 
     if (buf >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
         return false;
     }
 
@@ -170,7 +170,7 @@
 
     if (buf >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
         return false;
     }
 
@@ -197,7 +197,7 @@
 {
     if (context->getClientVersion() < ES_3_2)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES32Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES32Required);
         return false;
     }
 
@@ -248,7 +248,7 @@
     {
         if (IsIndexedCapBannedWithActivePLS(target))
         {
-            context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kPLSCapNotAllowed, target);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kPLSCapNotAllowed, target);
             return false;
         }
         if (target == GL_BLEND &&
@@ -263,12 +263,12 @@
         case GL_BLEND:
             if (index >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
                 return false;
             }
             break;
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, target);
             return false;
     }
     return true;
@@ -310,7 +310,7 @@
 {
     if (end < start)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidElementRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidElementRange);
         return false;
     }
 
@@ -338,7 +338,7 @@
     {
         if (IsIndexedCapBannedWithActivePLS(target))
         {
-            context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kPLSCapNotAllowed, target);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, kPLSCapNotAllowed, target);
             return false;
         }
         if (target == GL_BLEND &&
@@ -353,12 +353,12 @@
         case GL_BLEND:
             if (index >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
                 return false;
             }
             break;
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, target);
             return false;
     }
     return true;
@@ -432,7 +432,7 @@
             case GL_POINT_SIZE_ARRAY_POINTER_OES:
                 return true;
             default:
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPointerQuery);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPointerQuery);
                 return false;
         }
     }
@@ -444,13 +444,13 @@
             case GL_DEBUG_CALLBACK_USER_PARAM:
                 return true;
             default:
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPointerQuery);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPointerQuery);
                 return false;
         }
     }
     else
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES1or32Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES1or32Required);
         return false;
     }
 }
@@ -531,12 +531,12 @@
         case GL_BLEND:
             if (index >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
             {
-                context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
                 return false;
             }
             break;
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, target);
             return false;
     }
     return true;
@@ -643,7 +643,7 @@
 {
     if (context->getClientVersion() < ES_3_2)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES32Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES32Required);
         return false;
     }
 
@@ -660,7 +660,7 @@
 {
     if (context->getClientVersion() < ES_3_2)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES32Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES32Required);
         return false;
     }
 

src/libANGLE/validationESEXT.cpp

diff --git a/src/libANGLE/validationESEXT.cpp b/src/libANGLE/validationESEXT.cpp
index 860fcd7..011be06 100644
--- a/src/libANGLE/validationESEXT.cpp
+++ b/src/libANGLE/validationESEXT.cpp
@@ -34,14 +34,14 @@
     GLenum implFormat = obj->getImplementationColorReadFormat(context);
     if (!ValidES3Format(format) && (format != implFormat || format == GL_NONE))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidFormat);
         return false;
     }
 
     GLenum implType = obj->getImplementationColorReadType(context);
     if (!ValidES3Type(type) && (type != implType || type == GL_NONE))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidType);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidType);
         return false;
     }
 
@@ -83,7 +83,7 @@
         case GL_PROTECTED_MEMORY_OBJECT_EXT:
             if (!context->getExtensions().protectedTexturesEXT)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
                 return false;
             }
             return true;
@@ -106,7 +106,7 @@
         case GL_BUFFER_OBJECT_EXT:
             if (context->getBuffer({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidBufferName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidBufferName);
                 return false;
             }
             return true;
@@ -114,12 +114,12 @@
         case GL_SHADER_OBJECT_EXT:
             if (isGLES11)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidType);
                 return false;
             }
             if (context->getShader({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidShaderName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidShaderName);
                 return false;
             }
             return true;
@@ -127,12 +127,12 @@
         case GL_PROGRAM_OBJECT_EXT:
             if (isGLES11)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidType);
                 return false;
             }
             if (context->getProgramNoResolveLink({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidProgramName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidProgramName);
                 return false;
             }
             return true;
@@ -140,12 +140,12 @@
         case GL_VERTEX_ARRAY_OBJECT_EXT:
             if (!isGLES3 && !context->getExtensions().vertexArrayObjectOES)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidType);
                 return false;
             }
             if (context->getVertexArray({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidVertexArrayName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidVertexArrayName);
                 return false;
             }
             return true;
@@ -153,12 +153,12 @@
         case GL_QUERY_OBJECT_EXT:
             if (!isGLES3 && !context->getExtensions().occlusionQueryBooleanEXT)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidType);
                 return false;
             }
             if (context->getQuery({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidQueryName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidQueryName);
                 return false;
             }
             return true;
@@ -166,13 +166,12 @@
         case GL_TRANSFORM_FEEDBACK:
             if (!isGLES3)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidType);
                 return false;
             }
             if (context->getTransformFeedback({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kInvalidTransformFeedbackName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTransformFeedbackName);
                 return false;
             }
             return true;
@@ -180,12 +179,12 @@
         case GL_SAMPLER:
             if (!isGLES3)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidType);
                 return false;
             }
             if (context->getSampler({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidSamplerName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidSamplerName);
                 return false;
             }
             return true;
@@ -193,7 +192,7 @@
         case GL_TEXTURE:
             if (context->getTexture({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureName);
                 return false;
             }
             return true;
@@ -201,8 +200,7 @@
         case GL_RENDERBUFFER:
             if (!context->isRenderbuffer({name}))
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kInvalidRenderbufferName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidRenderbufferName);
                 return false;
             }
             return true;
@@ -210,7 +208,7 @@
         case GL_FRAMEBUFFER:
             if (context->getFramebuffer({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFramebufferName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidFramebufferName);
                 return false;
             }
             return true;
@@ -218,19 +216,18 @@
         case GL_PROGRAM_PIPELINE_OBJECT_EXT:
             if (!isGLES31 && !context->getExtensions().separateShaderObjectsEXT)
             {
-                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidType);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidType);
                 return false;
             }
             if (context->getProgramPipeline({name}) == nullptr)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kInvalidProgramPipelineName);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidProgramPipelineName);
                 return false;
             }
             return true;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidIndentifier);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidIndentifier);
             return false;
     }
 }
@@ -243,27 +240,27 @@
 {
     if (!context->getExtensions().getImageANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kGetImageExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kGetImageExtensionNotEnabled);
         return false;
     }
 
     if (!ValidTexture2DDestinationTarget(context, target) &&
         !ValidTexture3DDestinationTarget(context, target))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
         return false;
     }
 
     if (level < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeLevel);
         return false;
     }
 
     TextureType textureType = TextureTargetToType(target);
     if (!ValidMipLevel(context, textureType, level))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMipLevel);
         return false;
     }
 
@@ -300,7 +297,7 @@
 
     if (texture->getFormat(target, level).info->compressed)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kGetImageCompressed);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kGetImageCompressed);
         return false;
     }
 
@@ -321,14 +318,14 @@
     Texture *texture = context->getTextureByTarget(target);
     if (!texture->getFormat(target, level).info->compressed)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kGetImageNotCompressed);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kGetImageNotCompressed);
         return false;
     }
 
     if (texture->isCompressedFormatEmulated(context, target, level))
     {
         // TODO (anglebug.com/7464): We can't currently read back from an emulated format
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidEmulatedFormat);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidEmulatedFormat);
         return false;
     }
 
@@ -344,13 +341,13 @@
 {
     if (!context->getExtensions().getImageANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kGetImageExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kGetImageExtensionNotEnabled);
         return false;
     }
 
     if (target != GL_RENDERBUFFER)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidRenderbufferTarget);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidRenderbufferTarget);
         return false;
     }
 
@@ -382,7 +379,7 @@
 {
     if (!context->getExtensions().drawElementsBaseVertexAny())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -400,7 +397,7 @@
 {
     if (!context->getExtensions().drawElementsBaseVertexAny())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -420,13 +417,13 @@
 {
     if (!context->getExtensions().drawElementsBaseVertexAny())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (end < start)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidElementRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidElementRange);
         return false;
     }
 
@@ -449,7 +446,7 @@
     if (indexRange.end > end || indexRange.start < start)
     {
         // GL spec says that behavior in this case is undefined - generating an error is fine.
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExceedsElementRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExceedsElementRange);
         return false;
     }
     return true;
@@ -517,8 +514,7 @@
             if (!ValidateTransformFeedbackPrimitiveMode(
                     context, entryPoint, curTransformFeedback->getPrimitiveMode(), modePacked))
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kInvalidDrawModeTransformFeedback);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidDrawModeTransformFeedback);
                 return false;
             }
         }
@@ -526,8 +522,7 @@
         {
             // An INVALID_OPERATION error is generated if transform feedback is active and not
             // paused.
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kUnsupportedDrawModeForTransformFeedback);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kUnsupportedDrawModeForTransformFeedback);
             return false;
         }
     }
@@ -545,7 +540,7 @@
 {
     if (!context->getExtensions().baseInstanceEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -563,7 +558,7 @@
 {
     if (!context->getExtensions().baseInstanceEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -583,7 +578,7 @@
 {
     if (!context->getExtensions().baseInstanceEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -601,7 +596,7 @@
 {
     if (!context->getExtensions().drawElementsBaseVertexAny())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -619,7 +614,7 @@
 {
     if (!context->getExtensions().drawElementsBaseVertexAny())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -639,13 +634,13 @@
 {
     if (!context->getExtensions().drawElementsBaseVertexAny())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (end < start)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidElementRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidElementRange);
         return false;
     }
 
@@ -668,7 +663,7 @@
     if (indexRange.end > end || indexRange.start < start)
     {
         // GL spec says that behavior in this case is undefined - generating an error is fine.
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExceedsElementRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExceedsElementRange);
         return false;
     }
     return true;
@@ -681,7 +676,7 @@
 
     if (!extensions.blendEquationAdvancedKHR)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kAdvancedBlendExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kAdvancedBlendExtensionNotEnabled);
     }
 
     return true;
@@ -695,7 +690,7 @@
 {
     if (!context->getExtensions().drawBuffersIndexedEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -709,7 +704,7 @@
 {
     if (!context->getExtensions().drawBuffersIndexedEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -726,7 +721,7 @@
 {
     if (!context->getExtensions().drawBuffersIndexedEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -741,7 +736,7 @@
 {
     if (!context->getExtensions().drawBuffersIndexedEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -758,7 +753,7 @@
 {
     if (!context->getExtensions().drawBuffersIndexedEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -772,7 +767,7 @@
 {
     if (!context->getExtensions().drawBuffersIndexedEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -786,7 +781,7 @@
 {
     if (!context->getExtensions().drawBuffersIndexedEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -800,7 +795,7 @@
 {
     if (!context->getExtensions().drawBuffersIndexedEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -815,7 +810,7 @@
 {
     if (!context->getExtensions().drawBuffersIndexedOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -829,7 +824,7 @@
 {
     if (!context->getExtensions().drawBuffersIndexedOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -846,7 +841,7 @@
 {
     if (!context->getExtensions().drawBuffersIndexedOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -861,7 +856,7 @@
 {
     if (!context->getExtensions().drawBuffersIndexedOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -878,7 +873,7 @@
 {
     if (!context->getExtensions().drawBuffersIndexedOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -892,7 +887,7 @@
 {
     if (!context->getExtensions().drawBuffersIndexedOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -906,7 +901,7 @@
 {
     if (!context->getExtensions().drawBuffersIndexedOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -920,7 +915,7 @@
 {
     if (!context->getExtensions().drawBuffersIndexedOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -933,7 +928,7 @@
 {
     if (!context->getExtensions().provokingVertexANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -943,7 +938,7 @@
         case ProvokingVertexConvention::LastVertexConvention:
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProvokingVertex);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidProvokingVertex);
             return false;
     }
 
@@ -957,7 +952,7 @@
 {
     if (!context->getExtensions().disjointTimerQueryEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -991,7 +986,7 @@
 {
     if (!context->getExtensions().copyImageEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1020,7 +1015,7 @@
 {
     if (!context->getExtensions().copyImageEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1038,7 +1033,7 @@
 {
     if (!context->getExtensions().memoryObjectEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1053,7 +1048,7 @@
 {
     if (!context->getExtensions().memoryObjectEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1067,7 +1062,7 @@
 {
     if (!context->getExtensions().memoryObjectEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1082,19 +1077,19 @@
 {
     if (!context->getExtensions().memoryObjectEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     const MemoryObject *memory = context->getMemoryObject(memoryObject);
     if (memory == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMemoryObject);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMemoryObject);
     }
 
     if (!IsValidMemoryObjectParamater(context, entryPoint, pname))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidMemoryObjectParameter);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidMemoryObjectParameter);
         return false;
     }
 
@@ -1108,7 +1103,7 @@
 {
     if (!context->getExtensions().memoryObjectEXT && !context->getExtensions().semaphoreEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1124,7 +1119,7 @@
 {
     if (!context->getExtensions().memoryObjectEXT && !context->getExtensions().semaphoreEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1138,7 +1133,7 @@
 {
     if (!context->getExtensions().memoryObjectEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1153,26 +1148,26 @@
 {
     if (!context->getExtensions().memoryObjectEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     const MemoryObject *memory = context->getMemoryObject(memoryObject);
     if (memory == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMemoryObject);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidMemoryObject);
         return false;
     }
 
     if (memory->isImmutable())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kImmutableMemoryObject);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kImmutableMemoryObject);
         return false;
     }
 
     if (!IsValidMemoryObjectParamater(context, entryPoint, pname))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidMemoryObjectParameter);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidMemoryObjectParameter);
         return false;
     }
 
@@ -1191,7 +1186,7 @@
 {
     if (!context->getExtensions().memoryObjectEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1219,7 +1214,7 @@
 {
     if (!context->getExtensions().memoryObjectEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1236,7 +1231,7 @@
 {
     if (!context->getExtensions().memoryObjectFdEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1245,7 +1240,7 @@
         case HandleType::OpaqueFd:
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidHandleType);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidHandleType);
             return false;
     }
 
@@ -1261,7 +1256,7 @@
 {
     if (!context->getExtensions().memoryObjectFuchsiaANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1270,7 +1265,7 @@
         case HandleType::ZirconVmo:
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidHandleType);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidHandleType);
             return false;
     }
 
@@ -1284,7 +1279,7 @@
 {
     if (!context->getExtensions().semaphoreEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1298,7 +1293,7 @@
 {
     if (!context->getExtensions().semaphoreEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1313,7 +1308,7 @@
 {
     if (!context->getExtensions().semaphoreEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1327,7 +1322,7 @@
 {
     if (!context->getExtensions().semaphoreEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1342,7 +1337,7 @@
 {
     if (!context->getExtensions().semaphoreEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1361,7 +1356,7 @@
 {
     if (!context->getExtensions().semaphoreEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1369,7 +1364,7 @@
     {
         if (!context->getBuffer(buffers[i]))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidBufferName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidBufferName);
             return false;
         }
     }
@@ -1378,12 +1373,12 @@
     {
         if (!context->getTexture(textures[i]))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureName);
             return false;
         }
         if (!IsValidImageLayout(FromGLenum<ImageLayout>(dstLayouts[i])))
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidImageLayout);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidImageLayout);
             return false;
         }
     }
@@ -1402,7 +1397,7 @@
 {
     if (!context->getExtensions().semaphoreEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1410,7 +1405,7 @@
     {
         if (!context->getBuffer(buffers[i]))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidBufferName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidBufferName);
             return false;
         }
     }
@@ -1419,12 +1414,12 @@
     {
         if (!context->getTexture(textures[i]))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureName);
             return false;
         }
         if (!IsValidImageLayout(FromGLenum<ImageLayout>(srcLayouts[i])))
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidImageLayout);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidImageLayout);
             return false;
         }
     }
@@ -1440,7 +1435,7 @@
 {
     if (!context->getExtensions().semaphoreFdEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1449,7 +1444,7 @@
         case HandleType::OpaqueFd:
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidHandleType);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidHandleType);
             return false;
     }
 
@@ -1464,7 +1459,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateGetSamplerParameterBase(context, entryPoint, samplerPacked, pname, nullptr);
@@ -1478,7 +1473,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateGetSamplerParameterBase(context, entryPoint, samplerPacked, pname, nullptr);
@@ -1492,7 +1487,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateGetTexParameterBase(context, entryPoint, targetPacked, pname, nullptr);
@@ -1506,7 +1501,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateGetTexParameterBase(context, entryPoint, targetPacked, pname, nullptr);
@@ -1520,7 +1515,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateSamplerParameterBase(context, entryPoint, samplerPacked, pname, -1, true, param);
@@ -1534,7 +1529,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateSamplerParameterBase(context, entryPoint, samplerPacked, pname, -1, true, param);
@@ -1548,7 +1543,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateTexParameterBase(context, entryPoint, targetPacked, pname, -1, true, params);
@@ -1562,7 +1557,7 @@
 {
     if (context->getClientMajorVersion() < 3)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES3Required);
         return false;
     }
     return ValidateTexParameterBase(context, entryPoint, targetPacked, pname, -1, true, params);
@@ -1576,7 +1571,7 @@
 {
     if (!context->getExtensions().semaphoreFuchsiaANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -1585,7 +1580,7 @@
         case HandleType::ZirconEvent:
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidHandleType);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidHandleType);
             return false;
     }
 
@@ -1608,7 +1603,7 @@
     // Check that the pixel local storage extension is enabled at all.
     if (!context->getExtensions().shaderPixelLocalStorageANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kPLSExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSExtensionNotEnabled);
         return false;
     }
 
@@ -1619,8 +1614,7 @@
         // bound to DRAW_FRAMEBUFFER.
         if (framebuffer->id().value == 0)
         {
-            context->validationError(entryPoint, GL_INVALID_FRAMEBUFFER_OPERATION,
-                                     kPLSDefaultFramebufferBound);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_FRAMEBUFFER_OPERATION, kPLSDefaultFramebufferBound);
             return false;
         }
     }
@@ -1630,7 +1624,7 @@
     const PixelLocalStorage *pls = framebuffer->peekPixelLocalStorage();
     if (pls != nullptr && pls->interruptCount() != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_FRAMEBUFFER_OPERATION, kPLSInterrupted);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_FRAMEBUFFER_OPERATION, kPLSInterrupted);
         return false;
     }
 
@@ -1639,7 +1633,7 @@
         // INVALID_OPERATION is generated if PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE is zero.
         if (context->getState().getPixelLocalStorageActivePlanes() == 0)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kPLSInactive);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSInactive);
             return false;
         }
     }
@@ -1666,12 +1660,12 @@
     // INVALID_VALUE is generated if <plane> < 0 or <plane> >= MAX_PIXEL_LOCAL_STORAGE_PLANES_ANGLE.
     if (plane < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kPLSPlaneLessThanZero);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kPLSPlaneLessThanZero);
         return false;
     }
     if (plane >= static_cast<GLint>(context->getCaps().maxPixelLocalStoragePlanes))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kPLSPlaneOutOfRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kPLSPlaneOutOfRange);
         return false;
     }
 
@@ -1693,7 +1687,7 @@
         case GL_R32UI:
             return true;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kPLSInvalidInternalformat);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kPLSInvalidInternalformat);
             return false;
     }
 }
@@ -1717,7 +1711,7 @@
             *textureDepth = tex->getDepth(TextureTarget::_3D, 0);
             return true;
         default:
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kPLSInvalidTextureType);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSInvalidTextureType);
             return false;
     }
 }
@@ -1736,7 +1730,7 @@
         case GL_ONE_MINUS_SRC1_COLOR_EXT:
         case GL_SRC1_ALPHA_EXT:
         case GL_ONE_MINUS_SRC1_ALPHA_EXT:
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kPLSSecondaryBlendEnabled);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSSecondaryBlendEnabled);
             return false;
         default:
             return true;
@@ -1766,7 +1760,7 @@
         case GL_HSL_SATURATION_KHR:
         case GL_HSL_COLOR_KHR:
         case GL_HSL_LUMINOSITY_KHR:
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kPLSAdvancedBlendEnabled);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSAdvancedBlendEnabled);
             return false;
         default:
             return true;
@@ -1785,8 +1779,7 @@
         case GL_DONT_CARE:
             return true;
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kPLSInvalidLoadOperation,
-                                      loadop);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kPLSInvalidLoadOperation, loadop);
             return false;
     }
 }
@@ -1801,8 +1794,7 @@
         case GL_DONT_CARE:
             return true;
         default:
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kPLSInvalidStoreOperation,
-                                      storeop);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kPLSInvalidStoreOperation, storeop);
             return false;
     }
 }
@@ -1817,13 +1809,13 @@
     // parameter.
     if (paramCount > bufSize)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kInsufficientParams);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInsufficientParams);
         return false;
     }
     // INVALID_VALUE is generated if <params> is NULL.
     if (params == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kPLSParamsNULL);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kPLSParamsNULL);
         return false;
     }
     return true;
@@ -1873,12 +1865,12 @@
         // immutable texture object, or zero.
         if (!tex)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureName);
             return false;
         }
         if (!tex->getImmutableFormat())
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureIsNotImmutable);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTextureIsNotImmutable);
             return false;
         }
 
@@ -1893,7 +1885,7 @@
         // INVALID_VALUE is generated if <backingtexture> is nonzero and <level> < 0.
         if (level < 0)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeLevel);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeLevel);
             return false;
         }
 
@@ -1901,14 +1893,14 @@
         // immutable number of mipmap levels in <backingtexture>.
         if (static_cast<GLuint>(level) >= tex->getImmutableLevels())
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kTextureLevelOutOfRange);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kTextureLevelOutOfRange);
             return false;
         }
 
         // INVALID_VALUE is generated if <backingtexture> is nonzero and <layer> < 0.
         if (layer < 0)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeLayer);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeLayer);
             return false;
         }
 
@@ -1916,7 +1908,7 @@
         // number of texture layers in <backingtexture>.
         if ((size_t)layer >= textureDepth)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kTextureLayerOutOfRange);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kTextureLayerOutOfRange);
             return false;
         }
 
@@ -1974,28 +1966,28 @@
     // multisampled framebuffer).
     if (framebuffer->getSamples(context) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kPLSMultisamplingEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSMultisamplingEnabled);
         return false;
     }
 
     // INVALID_OPERATION is generated if DITHER is enabled.
     if (state.isDitherEnabled())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kPLSDitherEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSDitherEnabled);
         return false;
     }
 
     // INVALID_OPERATION is generated if RASTERIZER_DISCARD is enabled.
     if (state.isRasterizerDiscardEnabled())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kPLSRasterizerDiscardEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSRasterizerDiscardEnabled);
         return false;
     }
 
     // INVALID_OPERATION is generated if TRANSFORM_FEEDBACK_ACTIVE is true.
     if (state.isTransformFeedbackActive())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kPLSTransformFeedbackActive);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSTransformFeedbackActive);
         return false;
     }
 
@@ -2032,12 +2024,12 @@
     // INVALID_VALUE is generated if <n> < 1 or <n> > MAX_PIXEL_LOCAL_STORAGE_PLANES_ANGLE.
     if (n < 1)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kPLSPlanesLessThanOne);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kPLSPlanesLessThanOne);
         return false;
     }
     if (n > static_cast<GLsizei>(context->getCaps().maxPixelLocalStoragePlanes))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kPLSPlanesOutOfRange);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kPLSPlanesOutOfRange);
         return false;
     }
 
@@ -2053,8 +2045,8 @@
     {
         if (framebuffer->getColorAttachment(i))
         {
-            context->validationError(entryPoint, GL_INVALID_FRAMEBUFFER_OPERATION,
-                                     kPLSMaxColorAttachmentsExceded);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_FRAMEBUFFER_OPERATION,
+                                   kPLSMaxColorAttachmentsExceded);
             return false;
         }
     }
@@ -2069,8 +2061,8 @@
     {
         if (framebuffer->getColorAttachment(i))
         {
-            context->validationError(entryPoint, GL_INVALID_FRAMEBUFFER_OPERATION,
-                                     kPLSMaxCombinedDrawBuffersAndPlanesExceded);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_FRAMEBUFFER_OPERATION,
+                                   kPLSMaxCombinedDrawBuffersAndPlanesExceded);
             return false;
         }
     }
@@ -2078,7 +2070,7 @@
     // INVALID_VALUE is generated if <loadops> is NULL.
     if (loadops == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kPLSLoadOpsNULL);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kPLSLoadOpsNULL);
         return false;
     }
 
@@ -2099,8 +2091,7 @@
         // deinitialized state.
         if (pls == nullptr || pls->getPlane(i).isDeinitialized())
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kPLSEnablingDeinitializedPlane);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSEnablingDeinitializedPlane);
             return false;
         }
 
@@ -2122,8 +2113,7 @@
             }
             else if (textureExtents != textureBackedPLSExtents)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kPLSMismatchedBackingTextureSizes);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSMismatchedBackingTextureSizes);
                 return false;
             }
         }
@@ -2134,8 +2124,7 @@
             // index is memoryless.
             if (loadops[i] == GL_LOAD_OP_LOAD_ANGLE)
             {
-                context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                         kPLSKeepingMemorylessPlane);
+                ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSKeepingMemorylessPlane);
                 return false;
             }
         }
@@ -2151,8 +2140,7 @@
         if (hasTextureBackedPLSPlanes &&
             textureBackedPLSExtents != framebuffer->getState().getAttachmentExtentsIntersection())
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kPLSDimensionsDontMatchRenderingArea);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSDimensionsDontMatchRenderingArea);
             return false;
         }
     }
@@ -2162,8 +2150,7 @@
         // enabled, texture-backed pixel local storage planes.
         if (!hasTextureBackedPLSPlanes)
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                     kPLSNoAttachmentsNoTextureBacked);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSNoAttachmentsNoTextureBacked);
             return false;
         }
     }
@@ -2196,7 +2183,7 @@
     // INVALID_VALUE is generated if <n> != PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE.
     if (n != context->getState().getPixelLocalStorageActivePlanes())
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kPLSNNotEqualActivePlanes);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kPLSNNotEqualActivePlanes);
         return false;
     }
 
@@ -2224,7 +2211,7 @@
     // Check that the pixel local storage extension is enabled at all.
     if (!context->getExtensions().shaderPixelLocalStorageANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kPLSExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSExtensionNotEnabled);
         return false;
     }
 
@@ -2234,8 +2221,7 @@
         context->getState().getDrawFramebuffer()->peekPixelLocalStorage();
     if (pls != nullptr && pls->interruptCount() >= 255)
     {
-        context->validationError(entryPoint, GL_INVALID_FRAMEBUFFER_OPERATION,
-                                 kPLSInterruptOverflow);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_FRAMEBUFFER_OPERATION, kPLSInterruptOverflow);
         return false;
     }
 
@@ -2248,7 +2234,7 @@
     // Check that the pixel local storage extension is enabled at all.
     if (!context->getExtensions().shaderPixelLocalStorageANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kPLSExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kPLSExtensionNotEnabled);
         return false;
     }
 
@@ -2264,7 +2250,7 @@
     const PixelLocalStorage *pls = framebuffer->peekPixelLocalStorage();
     if (pls == nullptr || pls->interruptCount() == 0)
     {
-        context->validationError(entryPoint, GL_INVALID_FRAMEBUFFER_OPERATION, kPLSNotInterrupted);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_FRAMEBUFFER_OPERATION, kPLSNotInterrupted);
         return false;
     }
 
@@ -2312,7 +2298,7 @@
         default:
             // INVALID_ENUM is generated if <pname> is not in Table 6.Y, or if the command issued is
             // not the associated "Get Command" for <pname> in Table 6.Y.
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
     return ValidatePLSQueryCommon(context, entryPoint, paramCount, bufSize, params);
@@ -2346,7 +2332,7 @@
         default:
             // INVALID_ENUM is generated if <pname> is not in Table 6.Y, or if the command issued is
             // not the associated "Get Command" for <pname> in Table 6.Y.
-            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
+            ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, pname);
             return false;
     }
     return ValidatePLSQueryCommon(context, entryPoint, paramCount, bufSize, params);
@@ -2356,8 +2342,8 @@
 {
     if (!context->getExtensions().shaderFramebufferFetchNonCoherentEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kFramebufferFetchNonCoherentExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION,
+                               kFramebufferFetchNonCoherentExtensionNotEnabled);
         return false;
     }
     return true;
@@ -2370,26 +2356,25 @@
 {
     if (!context->getExtensions().tessellationShaderEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION,
-                                 kTessellationShaderExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kTessellationShaderExtensionNotEnabled);
         return false;
     }
 
     if (pname != GL_PATCH_VERTICES)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
         return false;
     }
 
     if (value <= 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidValueNonPositive);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidValueNonPositive);
         return false;
     }
 
     if (value > context->getCaps().maxPatchVertices)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidValueExceedsMaxPatchSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidValueExceedsMaxPatchSize);
         return false;
     }
 
@@ -2411,7 +2396,7 @@
 {
     if (!context->getExtensions().memoryObjectFlagsANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2434,7 +2419,7 @@
 
     if ((createFlags & ~kAllCreateFlags) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidExternalCreateFlags);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidExternalCreateFlags);
         return false;
     }
 
@@ -2447,7 +2432,7 @@
 
     if ((usageFlags & ~kAllUsageFlags) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidExternalUsageFlags);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidExternalUsageFlags);
         return false;
     }
 
@@ -2519,13 +2504,13 @@
 {
     if (!context->isValidBufferBinding(targetPacked))
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidBufferTypes);
         return false;
     }
 
     if (size <= 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNonPositiveSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNonPositiveSize);
         return false;
     }
 
@@ -2534,20 +2519,20 @@
          GL_MAP_PERSISTENT_BIT_EXT | GL_MAP_COHERENT_BIT_EXT | GL_CLIENT_STORAGE_BIT_EXT);
     if ((flags & ~kAllUsageFlags) != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidBufferUsageFlags);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidBufferUsageFlags);
         return false;
     }
 
     if (((flags & GL_MAP_PERSISTENT_BIT_EXT) != 0) &&
         ((flags & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) == 0))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidBufferUsageFlags);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidBufferUsageFlags);
         return false;
     }
 
     if (((flags & GL_MAP_COHERENT_BIT_EXT) != 0) && ((flags & GL_MAP_PERSISTENT_BIT_EXT) == 0))
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidBufferUsageFlags);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidBufferUsageFlags);
         return false;
     }
 
@@ -2555,13 +2540,13 @@
 
     if (buffer == nullptr)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotBound);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferNotBound);
         return false;
     }
 
     if (buffer->isImmutable())
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferImmutable);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kBufferImmutable);
         return false;
     }
 
@@ -2576,19 +2561,19 @@
 {
     if (!context->getExtensions().clipControlEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (originPacked == ClipOrigin::InvalidEnum)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidOriginEnum);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidOriginEnum);
         return false;
     }
 
     if (depthPacked == ClipDepthMode::InvalidEnum)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDepthEnum);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidDepthEnum);
         return false;
     }
 
@@ -2611,13 +2596,13 @@
 
     if (offset != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kExternalBufferInvalidOffset);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kExternalBufferInvalidOffset);
         return false;
     }
 
     if (clientBuffer == nullptr && size > 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kClientBufferInvalid);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kClientBufferInvalid);
         return false;
     }
 
@@ -2644,19 +2629,19 @@
 {
     if (!context->getExtensions().polygonModeANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (face != GL_FRONT_AND_BACK)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidCullMode);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidCullMode);
         return false;
     }
 
     if (modePacked == PolygonMode::Point || modePacked == PolygonMode::InvalidEnum)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPolygonMode);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPolygonMode);
         return false;
     }
 
@@ -2671,19 +2656,19 @@
 {
     if (!context->getExtensions().polygonModeNV)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (face != GL_FRONT_AND_BACK)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidCullMode);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidCullMode);
         return false;
     }
 
     if (modePacked == PolygonMode::InvalidEnum)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPolygonMode);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPolygonMode);
         return false;
     }
 
@@ -2699,7 +2684,7 @@
 {
     if (!context->getExtensions().polygonOffsetClampEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2720,7 +2705,7 @@
 {
     if (!context->getExtensions().primitiveBoundingBoxEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2741,7 +2726,7 @@
 {
     if (!context->getExtensions().primitiveBoundingBoxOES)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2756,7 +2741,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2769,7 +2754,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2784,7 +2769,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2798,7 +2783,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2812,7 +2797,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2828,7 +2813,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2844,7 +2829,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2857,7 +2842,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2872,7 +2857,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2887,7 +2872,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2903,7 +2888,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2919,7 +2904,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2935,7 +2920,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2951,7 +2936,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2967,7 +2952,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -2984,7 +2969,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3000,7 +2985,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3017,7 +3002,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3033,7 +3018,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3050,7 +3035,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3067,7 +3052,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3085,7 +3070,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3102,7 +3087,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3120,7 +3105,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3137,7 +3122,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3155,7 +3140,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3172,7 +3157,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3191,7 +3176,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3208,7 +3193,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3227,7 +3212,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3257,7 +3242,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3286,7 +3271,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3304,7 +3289,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3322,7 +3307,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3340,7 +3325,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3358,7 +3343,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3376,7 +3361,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3394,7 +3379,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3412,7 +3397,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3430,7 +3415,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3446,7 +3431,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3459,7 +3444,7 @@
 {
     if (!context->getExtensions().separateShaderObjectsEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3477,13 +3462,13 @@
 {
     if (!context->getExtensions().debugLabelEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (bufSize < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeBufferSize);
         return false;
     }
 
@@ -3499,13 +3484,13 @@
 {
     if (!context->getExtensions().debugLabelEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (length < 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeLength);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kNegativeLength);
         return false;
     }
 
@@ -3530,7 +3515,7 @@
 {
     if (!context->getExtensions().EGLImageStorageEXT)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3540,15 +3525,13 @@
         case TextureType::External:
             if (!context->getExtensions().EGLImageExternalOES)
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                          ToGLenum(targetType));
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, ToGLenum(targetType));
             }
             break;
         case TextureType::CubeMapArray:
             if (!context->getExtensions().textureCubeMapArrayAny())
             {
-                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
-                                          ToGLenum(targetType));
+                ANGLE_VALIDATION_ERRORF(GL_INVALID_ENUM, kEnumNotSupported, ToGLenum(targetType));
             }
             break;
         case TextureType::_2D:
@@ -3557,7 +3540,7 @@
         case TextureType::CubeMap:
             break;
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidTextureTarget);
             return false;
     }
 
@@ -3571,7 +3554,7 @@
     // attrib list validation
     if (attrib_list != nullptr && attrib_list[0] != GL_NONE)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kAttributeListNotNull);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kAttributeListNotNull);
         return false;
     }
 
@@ -3584,7 +3567,7 @@
 
     if (width < 1 || height < 1 || depth < 1 || levelCount < 1)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureSizeTooSmall);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kTextureSizeTooSmall);
         return false;
     }
 
@@ -3600,7 +3583,7 @@
         const Caps &caps = context->getCaps();
         if (width > caps.max2DTextureSize || height > caps.max2DTextureSize)
         {
-            context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kResourceMaxTextureSize);
             return false;
         }
     }
@@ -3635,7 +3618,7 @@
 {
     if (!context->getExtensions().vulkanImageANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3643,12 +3626,12 @@
     {
         if (!context->getTexture(textures[i]))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureName);
             return false;
         }
         if (!IsValidImageLayout(FromGLenum<ImageLayout>(layouts[i])))
         {
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidImageLayout);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidImageLayout);
             return false;
         }
     }
@@ -3664,14 +3647,14 @@
 {
     if (!context->getExtensions().vulkanImageANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
     for (GLuint i = 0; i < numTextures; ++i)
     {
         if (!context->getTexture(textures[i]))
         {
-            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureName);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kInvalidTextureName);
             return false;
         }
     }
@@ -3687,7 +3670,7 @@
 {
     if (pname != GL_FRAMEBUFFER_FLIP_Y_MESA)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
         return false;
     }
     return ValidateFramebufferParameteriBase(context, entryPoint, target, pname, param);
@@ -3701,7 +3684,7 @@
 {
     if (pname != GL_FRAMEBUFFER_FLIP_Y_MESA)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
         return false;
     }
     return ValidateGetFramebufferParameterivBase(context, entryPoint, target, pname, params);
@@ -3714,7 +3697,7 @@
 {
     if (!context->getExtensions().performanceMonitorAMD)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3729,7 +3712,7 @@
 {
     if (!context->getExtensions().performanceMonitorAMD)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3741,7 +3724,7 @@
 {
     if (!context->getExtensions().performanceMonitorAMD)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3756,7 +3739,7 @@
 {
     if (!context->getExtensions().performanceMonitorAMD)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3774,13 +3757,13 @@
 {
     if (!context->getExtensions().performanceMonitorAMD)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     if (monitor != 0)
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidPerfMonitor);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidPerfMonitor);
         return false;
     }
 
@@ -3792,7 +3775,7 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
             return false;
     }
 
@@ -3808,7 +3791,7 @@
 {
     if (!context->getExtensions().performanceMonitorAMD)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3816,13 +3799,13 @@
 
     if (group >= groups.size())
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidPerfMonitorGroup);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidPerfMonitorGroup);
         return false;
     }
 
     if (counter >= groups[group].counters.size())
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidPerfMonitorCounter);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidPerfMonitorCounter);
         return false;
     }
 
@@ -3833,7 +3816,7 @@
             break;
 
         default:
-            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
+            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPname);
             return false;
     }
 
@@ -3850,7 +3833,7 @@
 {
     if (!context->getExtensions().performanceMonitorAMD)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3858,13 +3841,13 @@
 
     if (group >= groups.size())
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidPerfMonitorGroup);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidPerfMonitorGroup);
         return false;
     }
 
     if (counter >= groups[group].counters.size())
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidPerfMonitorCounter);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidPerfMonitorCounter);
         return false;
     }
 
@@ -3881,7 +3864,7 @@
 {
     if (!context->getExtensions().performanceMonitorAMD)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3889,7 +3872,7 @@
 
     if (group >= groups.size())
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidPerfMonitorGroup);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidPerfMonitorGroup);
         return false;
     }
 
@@ -3905,7 +3888,7 @@
 {
     if (!context->getExtensions().performanceMonitorAMD)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3913,7 +3896,7 @@
 
     if (group >= groups.size())
     {
-        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidPerfMonitorGroup);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, kInvalidPerfMonitorGroup);
         return false;
     }
 
@@ -3928,7 +3911,7 @@
 {
     if (!context->getExtensions().performanceMonitorAMD)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3945,7 +3928,7 @@
 {
     if (!context->getExtensions().performanceMonitorAMD)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
@@ -3957,14 +3940,14 @@
 {
     if (!context->getExtensions().shadingRateQCOM)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 
     gl::ShadingRate shadingRate = gl::FromGLenum<gl::ShadingRate>(rate);
     if (shadingRate == gl::ShadingRate::Undefined || shadingRate == gl::ShadingRate::InvalidEnum)
     {
-        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShadingRate);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidShadingRate);
         return false;
     }
 
@@ -3977,7 +3960,7 @@
 {
     if (!context->getExtensions().logicOpANGLE)
     {
-        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
+        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
         return false;
     }
 

src/libGLESv2/global_state.cpp

diff --git a/src/libGLESv2/global_state.cpp b/src/libGLESv2/global_state.cpp
index 9eb3b73..eb7edb1 100644
--- a/src/libGLESv2/global_state.cpp
+++ b/src/libGLESv2/global_state.cpp
@@ -175,7 +175,8 @@
 {
     if (context && context->isContextLost())
     {
-        context->validationError(angle::EntryPoint::Invalid, GL_CONTEXT_LOST, err::kContextLost);
+        context->getMutableErrorSetForValidation()->validationError(
+            angle::EntryPoint::Invalid, GL_CONTEXT_LOST, err::kContextLost);
     }
 }