EGL: Remove egl::Error from validation code.

src/libANGLE/Error.h

@@ -186,6 +186,22 @@ inline bool IsError(const egl::Error &err)
     return err.isError();
 }
 
+// TODO(jmadill): Remove this when refactor is complete. http://anglebug.com/3041
+inline bool IsError(bool value)
+{
+    return !value;
+}
+
+// Utility macro for handling implementation methods inside Validation.
+#define ANGLE_HANDLE_VALIDATION_ERR(X) \
+    do                                 \
+    {                                  \
+        (void)(X);                     \
+        return false;                  \
+    } while (0)
+
+#define ANGLE_VALIDATION_TRY(EXPR) ANGLE_TRY_TEMPLATE(EXPR, ANGLE_HANDLE_VALIDATION_ERR)
+
 #include "Error.inc"
 
 #endif  // LIBANGLE_ERROR_H_

src/libANGLE/Thread.cpp

@@ -19,6 +19,10 @@ bool gUseAndroidOpenGLTlsSlot;
 
 namespace egl
 {
+namespace
+{
+Debug *sDebug = nullptr;
+}  // namespace
 
 Thread::Thread()
     : mLabel(nullptr),
@@ -42,18 +46,29 @@ void Thread::setSuccess()
     mError = EGL_SUCCESS;
 }
 
-void Thread::setError(const Error &error,
-                      const Debug *debug,
+void Thread::setError(EGLint error,
                       const char *command,
-                      const LabeledObject *object)
+                      const LabeledObject *object,
+                      const char *message)
 {
-    ASSERT(debug != nullptr);
+    mError = error;
+    if (error != EGL_SUCCESS && message)
+    {
+        EnsureDebugAllocated();
+        sDebug->insertMessage(error, command, ErrorCodeToMessageType(error), getLabel(),
+                              object ? object->getLabel() : nullptr, message);
+    }
+}
 
+void Thread::setError(const Error &error, const char *command, const LabeledObject *object)
+{
     mError = error.getCode();
     if (error.isError() && !error.getMessage().empty())
     {
-        debug->insertMessage(error.getCode(), command, ErrorCodeToMessageType(error.getCode()),
-                             getLabel(), object ? object->getLabel() : nullptr, error.getMessage());
+        EnsureDebugAllocated();
+        sDebug->insertMessage(error.getCode(), command, ErrorCodeToMessageType(error.getCode()),
+                              getLabel(), object ? object->getLabel() : nullptr,
+                              error.getMessage());
     }
 }
 
@@ -108,4 +123,24 @@ Display *Thread::getDisplay() const
     }
     return nullptr;
 }
+
+void EnsureDebugAllocated()
+{
+    // All EGL calls use a global lock, this is thread safe
+    if (sDebug == nullptr)
+    {
+        sDebug = new Debug();
+    }
+}
+
+void DeallocateDebug()
+{
+    SafeDelete(sDebug);
+}
+
+Debug *GetDebug()
+{
+    EnsureDebugAllocated();
+    return sDebug;
+}
 }  // namespace egl

src/libANGLE/Thread.h

@@ -39,10 +39,14 @@ class Thread : public LabeledObject
     EGLLabelKHR getLabel() const override;
 
     void setSuccess();
-    void setError(const Error &error,
-                  const Debug *debug,
+
+    void setError(EGLint error,
                   const char *command,
-                  const LabeledObject *object);
+                  const LabeledObject *object,
+                  const char *message);
+
+    // TODO: Remove egl::Error. http://anglebug.com/3041
+    void setError(const Error &error, const char *command, const LabeledObject *object);
     EGLint getError() const;
 
     void setAPI(EGLenum api);
@@ -61,6 +65,10 @@ class Thread : public LabeledObject
     gl::Context *mContext;
 };
 
+void EnsureDebugAllocated();
+void DeallocateDebug();
+Debug *GetDebug();
+
 }  // namespace egl
 
 #endif  // LIBANGLE_THREAD_H_

src/libANGLE/validationEGL.h

@@ -36,14 +36,31 @@ class Sync;
 class Thread;
 class LabeledObject;
 
+struct ValidationContext
+{
+    ValidationContext(Thread *threadIn, const char *entryPointIn, const LabeledObject *objectIn)
+        : eglThread(threadIn), entryPoint(entryPointIn), labeledObject(objectIn)
+    {}
+
+    // We should remove the message-less overload once we have messages for all EGL errors.
+    void setError(EGLint error) const;
+    void setError(EGLint error, const char *message...) const;
+
+    Thread *eglThread;
+    const char *entryPoint;
+    const LabeledObject *labeledObject;
+};
+
 // Object validation
-Error ValidateDisplay(const Display *display);
-Error ValidateSurface(const Display *display, const Surface *surface);
-Error ValidateConfig(const Display *display, const Config *config);
-Error ValidateContext(const Display *display, const gl::Context *context);
-Error ValidateImage(const Display *display, const Image *image);
-Error ValidateDevice(const Device *device);
-Error ValidateSync(const Display *display, const Sync *sync);
+bool ValidateDisplay(const ValidationContext *val, const Display *display);
+bool ValidateSurface(const ValidationContext *val, const Display *display, const Surface *surface);
+bool ValidateConfig(const ValidationContext *val, const Display *display, const Config *config);
+bool ValidateContext(const ValidationContext *val,
+                     const Display *display,
+                     const gl::Context *context);
+bool ValidateImage(const ValidationContext *val, const Display *display, const Image *image);
+bool ValidateDevice(const ValidationContext *val, const Device *device);
+bool ValidateSync(const ValidationContext *val, const Display *display, const Sync *sync);
 
 // Return the requested object only if it is valid (otherwise nullptr)
 const Thread *GetThreadIfValid(const Thread *thread);
@@ -60,304 +77,454 @@ LabeledObject *GetLabeledObjectIfValid(Thread *thread,
                                        EGLObjectKHR object);
 
 // Entry point validation
-Error ValidateInitialize(const Display *display);
+bool ValidateInitialize(const ValidationContext *val, const Display *display);
 
-Error ValidateTerminate(const Display *display);
+bool ValidateTerminate(const ValidationContext *val, const Display *display);
 
-Error ValidateCreateContext(Display *display,
+bool ValidateCreateContext(const ValidationContext *val,
+                           Display *display,
                            Config *configuration,
                            gl::Context *shareContext,
                            const AttributeMap &attributes);
 
-Error ValidateCreateWindowSurface(Display *display,
+bool ValidateCreateWindowSurface(const ValidationContext *val,
+                                 Display *display,
                                  Config *config,
                                  EGLNativeWindowType window,
                                  const AttributeMap &attributes);
 
-Error ValidateCreatePbufferSurface(Display *display,
+bool ValidateCreatePbufferSurface(const ValidationContext *val,
+                                  Display *display,
                                   Config *config,
                                   const AttributeMap &attributes);
-Error ValidateCreatePbufferFromClientBuffer(Display *display,
+bool ValidateCreatePbufferFromClientBuffer(const ValidationContext *val,
+                                           Display *display,
                                            EGLenum buftype,
                                            EGLClientBuffer buffer,
                                            Config *config,
                                            const AttributeMap &attributes);
 
-Error ValidateCreatePixmapSurface(Display *display,
+bool ValidateCreatePixmapSurface(const ValidationContext *val,
+                                 Display *display,
                                  Config *config,
                                  EGLNativePixmapType pixmap,
                                  const AttributeMap &attributes);
 
-Error ValidateMakeCurrent(Display *display, Surface *draw, Surface *read, gl::Context *context);
+bool ValidateMakeCurrent(const ValidationContext *val,
+                         Display *display,
+                         Surface *draw,
+                         Surface *read,
+                         gl::Context *context);
 
-Error ValidateCreateImage(const Display *display,
+bool ValidateCreateImage(const ValidationContext *val,
+                         const Display *display,
                          gl::Context *context,
                          EGLenum target,
                          EGLClientBuffer buffer,
                          const AttributeMap &attributes);
-Error ValidateDestroyImage(const Display *display, const Image *image);
-Error ValidateCreateImageKHR(const Display *display,
+bool ValidateDestroyImage(const ValidationContext *val, const Display *display, const Image *image);
+bool ValidateCreateImageKHR(const ValidationContext *val,
+                            const Display *display,
                             gl::Context *context,
                             EGLenum target,
                             EGLClientBuffer buffer,
                             const AttributeMap &attributes);
-Error ValidateDestroyImageKHR(const Display *display, const Image *image);
+bool ValidateDestroyImageKHR(const ValidationContext *val,
+                             const Display *display,
+                             const Image *image);
 
-Error ValidateCreateDeviceANGLE(EGLint device_type,
+bool ValidateCreateDeviceANGLE(const ValidationContext *val,
+                               EGLint device_type,
                                void *native_device,
                                const EGLAttrib *attrib_list);
-Error ValidateReleaseDeviceANGLE(Device *device);
+bool ValidateReleaseDeviceANGLE(const ValidationContext *val, Device *device);
 
-Error ValidateCreateSyncBase(const Display *display,
+bool ValidateCreateSyncBase(const ValidationContext *val,
+                            const Display *display,
                             EGLenum type,
                             const AttributeMap &attribs,
                             const Display *currentDisplay,
                             const gl::Context *currentContext,
                             bool isExt);
-Error ValidateGetSyncAttribBase(const Display *display, const Sync *sync, EGLint attribute);
+bool ValidateGetSyncAttribBase(const ValidationContext *val,
+                               const Display *display,
+                               const Sync *sync,
+                               EGLint attribute);
 
-Error ValidateCreateSyncKHR(const Display *display,
+bool ValidateCreateSyncKHR(const ValidationContext *val,
+                           const Display *display,
                            EGLenum type,
                            const AttributeMap &attribs,
                            const Display *currentDisplay,
                            const gl::Context *currentContext);
-Error ValidateCreateSync(const Display *display,
+bool ValidateCreateSync(const ValidationContext *val,
+                        const Display *display,
                         EGLenum type,
                         const AttributeMap &attribs,
                         const Display *currentDisplay,
                         const gl::Context *currentContext);
-Error ValidateDestroySync(const Display *display, const Sync *sync);
-Error ValidateClientWaitSync(const Display *display,
+bool ValidateDestroySync(const ValidationContext *val, const Display *display, const Sync *sync);
+bool ValidateClientWaitSync(const ValidationContext *val,
+                            const Display *display,
                             const Sync *sync,
                             EGLint flags,
                             EGLTime timeout);
-Error ValidateWaitSync(const Display *display,
+bool ValidateWaitSync(const ValidationContext *val,
+                      const Display *display,
                       const gl::Context *context,
                       const Sync *sync,
                       EGLint flags);
-Error ValidateGetSyncAttribKHR(const Display *display,
+bool ValidateGetSyncAttribKHR(const ValidationContext *val,
+                              const Display *display,
                               const Sync *sync,
                               EGLint attribute,
                               EGLint *value);
-Error ValidateGetSyncAttrib(const Display *display,
+bool ValidateGetSyncAttrib(const ValidationContext *val,
+                           const Display *display,
                            const Sync *sync,
                            EGLint attribute,
                            EGLAttrib *value);
 
-Error ValidateCreateStreamKHR(const Display *display, const AttributeMap &attributes);
-Error ValidateDestroyStreamKHR(const Display *display, const Stream *stream);
-Error ValidateStreamAttribKHR(const Display *display,
+bool ValidateCreateStreamKHR(const ValidationContext *val,
+                             const Display *display,
+                             const AttributeMap &attributes);
+bool ValidateDestroyStreamKHR(const ValidationContext *val,
+                              const Display *display,
+                              const Stream *stream);
+bool ValidateStreamAttribKHR(const ValidationContext *val,
+                             const Display *display,
                              const Stream *stream,
                              EGLint attribute,
                              EGLint value);
-Error ValidateQueryStreamKHR(const Display *display,
+bool ValidateQueryStreamKHR(const ValidationContext *val,
+                            const Display *display,
                             const Stream *stream,
                             EGLenum attribute,
                             EGLint *value);
-Error ValidateQueryStreamu64KHR(const Display *display,
+bool ValidateQueryStreamu64KHR(const ValidationContext *val,
+                               const Display *display,
                                const Stream *stream,
                                EGLenum attribute,
                                EGLuint64KHR *value);
-Error ValidateStreamConsumerGLTextureExternalKHR(const Display *display,
+bool ValidateStreamConsumerGLTextureExternalKHR(const ValidationContext *val,
+                                                const Display *display,
                                                 gl::Context *context,
                                                 const Stream *stream);
-Error ValidateStreamConsumerAcquireKHR(const Display *display,
+bool ValidateStreamConsumerAcquireKHR(const ValidationContext *val,
+                                      const Display *display,
                                       gl::Context *context,
                                       const Stream *stream);
-Error ValidateStreamConsumerReleaseKHR(const Display *display,
+bool ValidateStreamConsumerReleaseKHR(const ValidationContext *val,
+                                      const Display *display,
                                       gl::Context *context,
                                       const Stream *stream);
-Error ValidateStreamConsumerGLTextureExternalAttribsNV(const Display *display,
+bool ValidateStreamConsumerGLTextureExternalAttribsNV(const ValidationContext *val,
+                                                      const Display *display,
                                                       gl::Context *context,
                                                       const Stream *stream,
                                                       const AttributeMap &attribs);
-Error ValidateCreateStreamProducerD3DTextureANGLE(const Display *display,
+bool ValidateCreateStreamProducerD3DTextureANGLE(const ValidationContext *val,
+                                                 const Display *display,
                                                  const Stream *stream,
                                                  const AttributeMap &attribs);
-Error ValidateStreamPostD3DTextureANGLE(const Display *display,
+bool ValidateStreamPostD3DTextureANGLE(const ValidationContext *val,
+                                       const Display *display,
                                        const Stream *stream,
                                        void *texture,
                                        const AttributeMap &attribs);
 
-Error ValidateGetMscRateANGLE(const Display *display,
+bool ValidateGetMscRateANGLE(const ValidationContext *val,
+                             const Display *display,
                              const Surface *surface,
                              const EGLint *numerator,
                              const EGLint *denominator);
-Error ValidateGetSyncValuesCHROMIUM(const Display *display,
+bool ValidateGetSyncValuesCHROMIUM(const ValidationContext *val,
+                                   const Display *display,
                                    const Surface *surface,
                                    const EGLuint64KHR *ust,
                                    const EGLuint64KHR *msc,
                                    const EGLuint64KHR *sbc);
 
-Error ValidateDestroySurface(const Display *display,
+bool ValidateDestroySurface(const ValidationContext *val,
+                            const Display *display,
                             const Surface *surface,
                             const EGLSurface eglSurface);
 
-Error ValidateDestroyContext(const Display *display,
+bool ValidateDestroyContext(const ValidationContext *val,
+                            const Display *display,
                             const gl::Context *glCtx,
                             const EGLContext eglCtx);
 
-Error ValidateSwapBuffers(Thread *thread, const Display *display, const Surface *surface);
+bool ValidateSwapBuffers(const ValidationContext *val,
+                         Thread *thread,
+                         const Display *display,
+                         const Surface *surface);
 
-Error ValidateWaitNative(const Display *display, const EGLint engine);
+bool ValidateWaitNative(const ValidationContext *val, const Display *display, const EGLint engine);
 
-Error ValidateCopyBuffers(Display *display, const Surface *surface);
+bool ValidateCopyBuffers(const ValidationContext *val, Display *display, const Surface *surface);
 
-Error ValidateSwapBuffersWithDamageKHR(const Display *display,
+bool ValidateSwapBuffersWithDamageKHR(const ValidationContext *val,
+                                      const Display *display,
                                       const Surface *surface,
                                       EGLint *rects,
                                       EGLint n_rects);
 
-Error ValidateBindTexImage(const Display *display,
+bool ValidateBindTexImage(const ValidationContext *val,
+                          const Display *display,
                           const Surface *surface,
                           const EGLSurface eglSurface,
                           const EGLint buffer,
                           const gl::Context *context,
                           gl::Texture **textureObject);
 
-Error ValidateReleaseTexImage(const Display *display,
+bool ValidateReleaseTexImage(const ValidationContext *val,
+                             const Display *display,
                              const Surface *surface,
                              const EGLSurface eglSurface,
                              const EGLint buffer);
 
-Error ValidateSwapInterval(const Display *display,
+bool ValidateSwapInterval(const ValidationContext *val,
+                          const Display *display,
                           const Surface *draw_surface,
                           const gl::Context *context);
 
-Error ValidateBindAPI(const EGLenum api);
+bool ValidateBindAPI(const ValidationContext *val, const EGLenum api);
 
-Error ValidatePresentationTimeANDROID(const Display *display,
+bool ValidatePresentationTimeANDROID(const ValidationContext *val,
+                                     const Display *display,
                                      const Surface *surface,
                                      EGLnsecsANDROID time);
 
-Error ValidateSetBlobCacheANDROID(const Display *display,
+bool ValidateSetBlobCacheANDROID(const ValidationContext *val,
+                                 const Display *display,
                                  EGLSetBlobFuncANDROID set,
                                  EGLGetBlobFuncANDROID get);
 
-Error ValidateGetConfigAttrib(const Display *display, const Config *config, EGLint attribute);
-Error ValidateChooseConfig(const Display *display,
+bool ValidateGetConfigAttrib(const ValidationContext *val,
+                             const Display *display,
+                             const Config *config,
+                             EGLint attribute);
+bool ValidateChooseConfig(const ValidationContext *val,
+                          const Display *display,
                           const AttributeMap &attribs,
                           EGLint configSize,
                           EGLint *numConfig);
-Error ValidateGetConfigs(const Display *display, EGLint configSize, EGLint *numConfig);
+bool ValidateGetConfigs(const ValidationContext *val,
+                        const Display *display,
+                        EGLint configSize,
+                        EGLint *numConfig);
 
 // Other validation
-Error ValidateCompatibleSurface(const Display *display,
+bool ValidateCompatibleSurface(const ValidationContext *val,
+                               const Display *display,
                                gl::Context *context,
                                const Surface *surface);
 
-Error ValidateGetPlatformDisplay(EGLenum platform,
+bool ValidateGetPlatformDisplay(const ValidationContext *val,
+                                EGLenum platform,
                                 void *native_display,
                                 const EGLAttrib *attrib_list);
-Error ValidateGetPlatformDisplayEXT(EGLenum platform,
+bool ValidateGetPlatformDisplayEXT(const ValidationContext *val,
+                                   EGLenum platform,
                                    void *native_display,
                                    const EGLint *attrib_list);
-Error ValidateCreatePlatformWindowSurfaceEXT(const Display *display,
+bool ValidateCreatePlatformWindowSurfaceEXT(const ValidationContext *val,
+                                            const Display *display,
                                             const Config *configuration,
                                             void *nativeWindow,
                                             const AttributeMap &attributes);
-Error ValidateCreatePlatformPixmapSurfaceEXT(const Display *display,
+bool ValidateCreatePlatformPixmapSurfaceEXT(const ValidationContext *val,
+                                            const Display *display,
                                             const Config *configuration,
                                             void *nativePixmap,
                                             const AttributeMap &attributes);
 
-Error ValidateProgramCacheGetAttribANGLE(const Display *display, EGLenum attrib);
+bool ValidateProgramCacheGetAttribANGLE(const ValidationContext *val,
+                                        const Display *display,
+                                        EGLenum attrib);
 
-Error ValidateProgramCacheQueryANGLE(const Display *display,
+bool ValidateProgramCacheQueryANGLE(const ValidationContext *val,
+                                    const Display *display,
                                     EGLint index,
                                     void *key,
                                     EGLint *keysize,
                                     void *binary,
                                     EGLint *binarysize);
 
-Error ValidateProgramCachePopulateANGLE(const Display *display,
+bool ValidateProgramCachePopulateANGLE(const ValidationContext *val,
+                                       const Display *display,
                                        const void *key,
                                        EGLint keysize,
                                        const void *binary,
                                        EGLint binarysize);
 
-Error ValidateProgramCacheResizeANGLE(const Display *display, EGLint limit, EGLenum mode);
+bool ValidateProgramCacheResizeANGLE(const ValidationContext *val,
+                                     const Display *display,
+                                     EGLint limit,
+                                     EGLenum mode);
 
-Error ValidateSurfaceAttrib(const Display *display,
+bool ValidateSurfaceAttrib(const ValidationContext *val,
+                           const Display *display,
                            const Surface *surface,
                            EGLint attribute,
                            EGLint value);
-Error ValidateQuerySurface(const Display *display,
+bool ValidateQuerySurface(const ValidationContext *val,
+                          const Display *display,
                           const Surface *surface,
                           EGLint attribute,
                           EGLint *value);
-Error ValidateQueryContext(const Display *display,
+bool ValidateQueryContext(const ValidationContext *val,
+                          const Display *display,
                           const gl::Context *context,
                           EGLint attribute,
                           EGLint *value);
 
 // EGL_KHR_debug
-Error ValidateDebugMessageControlKHR(EGLDEBUGPROCKHR callback, const AttributeMap &attribs);
+bool ValidateDebugMessageControlKHR(const ValidationContext *val,
+                                    EGLDEBUGPROCKHR callback,
+                                    const AttributeMap &attribs);
 
-Error ValidateQueryDebugKHR(EGLint attribute, EGLAttrib *value);
+bool ValidateQueryDebugKHR(const ValidationContext *val, EGLint attribute, EGLAttrib *value);
 
-Error ValidateLabelObjectKHR(Thread *thread,
+bool ValidateLabelObjectKHR(const ValidationContext *val,
+                            Thread *thread,
                             const Display *display,
                             ObjectType objectType,
                             EGLObjectKHR object,
                             EGLLabelKHR label);
 
 // ANDROID_get_frame_timestamps
-Error ValidateGetCompositorTimingSupportedANDROID(const Display *display,
+bool ValidateGetCompositorTimingSupportedANDROID(const ValidationContext *val,
+                                                 const Display *display,
                                                  const Surface *surface,
                                                  CompositorTiming name);
 
-Error ValidateGetCompositorTimingANDROID(const Display *display,
+bool ValidateGetCompositorTimingANDROID(const ValidationContext *val,
+                                        const Display *display,
                                         const Surface *surface,
                                         EGLint numTimestamps,
                                         const EGLint *names,
                                         EGLnsecsANDROID *values);
 
-Error ValidateGetNextFrameIdANDROID(const Display *display,
+bool ValidateGetNextFrameIdANDROID(const ValidationContext *val,
+                                   const Display *display,
                                    const Surface *surface,
                                    EGLuint64KHR *frameId);
 
-Error ValidateGetFrameTimestampSupportedANDROID(const Display *display,
+bool ValidateGetFrameTimestampSupportedANDROID(const ValidationContext *val,
+                                               const Display *display,
                                                const Surface *surface,
                                                Timestamp timestamp);
 
-Error ValidateGetFrameTimestampsANDROID(const Display *display,
+bool ValidateGetFrameTimestampsANDROID(const ValidationContext *val,
+                                       const Display *display,
                                        const Surface *surface,
                                        EGLuint64KHR frameId,
                                        EGLint numTimestamps,
                                        const EGLint *timestamps,
                                        EGLnsecsANDROID *values);
 
-Error ValidateQueryStringiANGLE(const Display *display, EGLint name, EGLint index);
+bool ValidateQueryStringiANGLE(const ValidationContext *val,
+                               const Display *display,
+                               EGLint name,
+                               EGLint index);
 
-Error ValidateQueryDisplayAttribEXT(const Display *display, const EGLint attribute);
-Error ValidateQueryDisplayAttribANGLE(const Display *display, const EGLint attribute);
+bool ValidateQueryDisplayAttribEXT(const ValidationContext *val,
+                                   const Display *display,
+                                   const EGLint attribute);
+bool ValidateQueryDisplayAttribANGLE(const ValidationContext *val,
+                                     const Display *display,
+                                     const EGLint attribute);
 
 // EGL_ANDROID_get_native_client_buffer
-Error ValidateGetNativeClientBufferANDROID(const struct AHardwareBuffer *buffer);
+bool ValidateGetNativeClientBufferANDROID(const ValidationContext *val,
+                                          const struct AHardwareBuffer *buffer);
 
 // EGL_ANDROID_create_native_client_buffer
-Error ValidateCreateNativeClientBufferANDROID(const egl::AttributeMap &attribMap);
+bool ValidateCreateNativeClientBufferANDROID(const ValidationContext *val,
+                                             const egl::AttributeMap &attribMap);
 
 // EGL_ANDROID_native_fence_sync
-Error ValidateDupNativeFenceFDANDROID(const Display *display, const Sync *sync);
+bool ValidateDupNativeFenceFDANDROID(const ValidationContext *val,
+                                     const Display *display,
+                                     const Sync *sync);
 
 // EGL_ANGLE_swap_with_frame_token
-Error ValidateSwapBuffersWithFrameTokenANGLE(const Display *display,
+bool ValidateSwapBuffersWithFrameTokenANGLE(const ValidationContext *val,
+                                            const Display *display,
                                             const Surface *surface,
                                             EGLFrameTokenANGLE frametoken);
 
 // EGL_KHR_reusable_sync
-Error ValidateSignalSyncKHR(const Display *display, const Sync *sync, EGLint mode);
+bool ValidateSignalSyncKHR(const ValidationContext *val,
+                           const Display *display,
+                           const Sync *sync,
+                           EGLint mode);
+
+// EGL_ANGLE_query_surface_pointer
+bool ValidateQuerySurfacePointerANGLE(const ValidationContext *val,
+                                      const Display *display,
+                                      Surface *eglSurface,
+                                      EGLint attribute,
+                                      void **value);
+
+// EGL_NV_post_sub_buffer
+bool ValidatePostSubBufferNV(const ValidationContext *val,
+                             Display *display,
+                             Surface *eglSurface,
+                             EGLint x,
+                             EGLint y,
+                             EGLint width,
+                             EGLint height);
+
+// EGL_EXT_device_query
+bool ValidateQueryDeviceAttribEXT(const ValidationContext *val,
+                                  Device *device,
+                                  EGLint attribute,
+                                  EGLAttrib *value);
+bool ValidateQueryDeviceStringEXT(const ValidationContext *val, Device *device, EGLint name);
+
+bool ValidateReleaseHighPowerGPUANGLE(const ValidationContext *val,
+                                      Display *display,
+                                      gl::Context *context);
+bool ValidateReacquireHighPowerGPUANGLE(const ValidationContext *val,
+                                        Display *display,
+                                        gl::Context *context);
+bool ValidateHandleGPUSwitchANGLE(const ValidationContext *val, Display *display);
 
 }  // namespace egl
 
+#define ANGLE_EGL_VALIDATE(THREAD, EP, OBJ, RETVAL, ...)           \
+    do                                                             \
+    {                                                              \
+        const char *epname = "egl" #EP;                            \
+        ValidationContext vctx(THREAD, epname, OBJ);               \
+        auto ANGLE_LOCAL_VAR = (Validate##EP(&vctx, __VA_ARGS__)); \
+        if (!ANGLE_LOCAL_VAR)                                      \
+        {                                                          \
+            return RETVAL;                                         \
+        }                                                          \
+    } while (0)
+
+#define ANGLE_EGL_VALIDATE_VOID(THREAD, EP, OBJ, ...)              \
+    do                                                             \
+    {                                                              \
+        const char *epname = "egl" #EP;                            \
+        ValidationContext vctx(THREAD, epname, OBJ);               \
+        auto ANGLE_LOCAL_VAR = (Validate##EP(&vctx, __VA_ARGS__)); \
+        if (!ANGLE_LOCAL_VAR)                                      \
+        {                                                          \
+            return;                                                \
+        }                                                          \
+    } while (0)
+
 #define ANGLE_EGL_TRY(THREAD, EXPR, FUNCNAME, LABELOBJECT)                   \
     do                                                                       \
     {                                                                        \
         auto ANGLE_LOCAL_VAR = (EXPR);                                       \
         if (ANGLE_LOCAL_VAR.isError())                                       \
-            return THREAD->setError(ANGLE_LOCAL_VAR, GetDebug(), FUNCNAME, LABELOBJECT); \
+            return THREAD->setError(ANGLE_LOCAL_VAR, FUNCNAME, LABELOBJECT); \
     } while (0)
 
 #define ANGLE_EGL_TRY_RETURN(THREAD, EXPR, FUNCNAME, LABELOBJECT, RETVAL) \
@@ -366,7 +533,7 @@ Error ValidateSignalSyncKHR(const Display *display, const Sync *sync, EGLint mod
         auto ANGLE_LOCAL_VAR = (EXPR);                                    \
         if (ANGLE_LOCAL_VAR.isError())                                    \
         {                                                                 \
-            THREAD->setError(ANGLE_LOCAL_VAR, GetDebug(), FUNCNAME, LABELOBJECT); \
+            THREAD->setError(ANGLE_LOCAL_VAR, FUNCNAME, LABELOBJECT);     \
             return RETVAL;                                                \
         }                                                                 \
     } while (0)

src/libANGLE/validationES.h

@@ -749,12 +749,6 @@ bool ValidateGetMultisamplefvBase(const Context *context,
                                   const GLfloat *val);
 bool ValidateSampleMaskiBase(const Context *context, GLuint maskNumber, GLbitfield mask);
 
-// Utility macro for handling implementation methods inside Validation.
-#define ANGLE_HANDLE_VALIDATION_ERR(X) \
-    (void)(X);                         \
-    return false
-#define ANGLE_VALIDATION_TRY(EXPR) ANGLE_TRY_TEMPLATE(EXPR, ANGLE_HANDLE_VALIDATION_ERR)
-
 // We should check with Khronos if returning INVALID_FRAMEBUFFER_OPERATION is OK when querying
 // implementation format info for incomplete framebuffers. It seems like these queries are
 // incongruent with the other errors.

src/libGLESv2/entry_points_egl.cpp

@@ -81,8 +81,7 @@ EGLBoolean EGLAPIENTRY EGL_Initialize(EGLDisplay dpy, EGLint *major, EGLint *min
     Thread *thread = egl::GetCurrentThread();
 
     egl::Display *display = static_cast<egl::Display *>(dpy);
-    ANGLE_EGL_TRY_RETURN(thread, ValidateInitialize(display), "eglInitialize",
-                         GetDisplayIfValid(display), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, Initialize, GetDisplayIfValid(display), EGL_FALSE, display);
 
     ANGLE_EGL_TRY_RETURN(thread, display->initialize(), "eglInitialize", GetDisplayIfValid(display),
                          EGL_FALSE);
@@ -103,8 +102,7 @@ EGLBoolean EGLAPIENTRY EGL_Terminate(EGLDisplay dpy)
     Thread *thread = egl::GetCurrentThread();
 
     egl::Display *display = static_cast<egl::Display *>(dpy);
-    ANGLE_EGL_TRY_RETURN(thread, ValidateTerminate(display), "eglTerminate",
-                         GetDisplayIfValid(display), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, Terminate, GetDisplayIfValid(display), EGL_FALSE, display);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglTerminate",
                          GetDisplayIfValid(display), EGL_FALSE);
     ANGLE_EGL_TRY_RETURN(thread,
@@ -127,8 +125,7 @@ const char *EGLAPIENTRY EGL_QueryString(EGLDisplay dpy, EGLint name)
     egl::Display *display = static_cast<egl::Display *>(dpy);
     if (!(display == EGL_NO_DISPLAY && name == EGL_EXTENSIONS))
     {
-        ANGLE_EGL_TRY_RETURN(thread, ValidateDisplay(display), "eglQueryString",
-                             GetDisplayIfValid(display), nullptr);
+        ANGLE_EGL_VALIDATE(thread, Display, GetDisplayIfValid(display), nullptr, display);
         ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryString",
                              GetDisplayIfValid(display), nullptr);
     }
@@ -156,8 +153,7 @@ const char *EGLAPIENTRY EGL_QueryString(EGLDisplay dpy, EGLint name)
             result = "1.5 (ANGLE " ANGLE_VERSION_STRING ")";
             break;
         default:
-            thread->setError(EglBadParameter(), GetDebug(), "eglQueryString",
-                             GetDisplayIfValid(display));
+            thread->setError(EglBadParameter(), "eglQueryString", GetDisplayIfValid(display));
             return nullptr;
     }
 
@@ -179,8 +175,8 @@ EGLBoolean EGLAPIENTRY EGL_GetConfigs(EGLDisplay dpy,
 
     egl::Display *display = static_cast<egl::Display *>(dpy);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateGetConfigs(display, config_size, num_config),
-                         "eglGetConfigs", GetDisplayIfValid(display), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, GetConfigs, GetDisplayIfValid(display), EGL_FALSE, display,
+                       config_size, num_config);
 
     ClipConfigs(display->getConfigs(AttributeMap()), configs, config_size, num_config);
 
@@ -206,8 +202,8 @@ EGLBoolean EGLAPIENTRY EGL_ChooseConfig(EGLDisplay dpy,
     egl::Display *display  = static_cast<egl::Display *>(dpy);
     AttributeMap attribMap = AttributeMap::CreateFromIntArray(attrib_list);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateChooseConfig(display, attribMap, config_size, num_config),
-                         "eglChooseConfig", GetDisplayIfValid(display), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, ChooseConfig, GetDisplayIfValid(display), EGL_FALSE, display,
+                       attribMap, config_size, num_config);
 
     ClipConfigs(display->chooseConfig(attribMap), configs, config_size, num_config);
 
@@ -230,8 +226,8 @@ EGLBoolean EGLAPIENTRY EGL_GetConfigAttrib(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Config *configuration = static_cast<Config *>(config);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateGetConfigAttrib(display, configuration, attribute),
-                         "eglGetConfigAttrib", GetDisplayIfValid(display), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, GetConfigAttrib, GetDisplayIfValid(display), EGL_FALSE, display,
+                       configuration, attribute);
 
     QueryConfigAttrib(configuration, attribute, value);
 
@@ -256,9 +252,8 @@ EGLSurface EGLAPIENTRY EGL_CreateWindowSurface(EGLDisplay dpy,
     Config *configuration   = static_cast<Config *>(config);
     AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
 
-    ANGLE_EGL_TRY_RETURN(thread,
-                         ValidateCreateWindowSurface(display, configuration, win, attributes),
-                         "eglCreateWindowSurface", GetDisplayIfValid(display), EGL_NO_SURFACE);
+    ANGLE_EGL_VALIDATE(thread, CreateWindowSurface, GetDisplayIfValid(display), EGL_NO_SURFACE,
+                       display, configuration, win, attributes);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateWindowSurface",
                          GetDisplayIfValid(display), EGL_NO_SURFACE);
 
@@ -285,8 +280,8 @@ EGLSurface EGLAPIENTRY EGL_CreatePbufferSurface(EGLDisplay dpy,
     Config *configuration   = static_cast<Config *>(config);
     AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateCreatePbufferSurface(display, configuration, attributes),
-                         "eglCreatePbufferSurface", GetDisplayIfValid(display), EGL_NO_SURFACE);
+    ANGLE_EGL_VALIDATE(thread, CreatePbufferSurface, GetDisplayIfValid(display), EGL_NO_SURFACE,
+                       display, configuration, attributes);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreatePbufferSurface",
                          GetDisplayIfValid(display), EGL_NO_SURFACE);
     egl::Surface *surface = nullptr;
@@ -314,9 +309,8 @@ EGLSurface EGLAPIENTRY EGL_CreatePixmapSurface(EGLDisplay dpy,
     Config *configuration   = static_cast<Config *>(config);
     AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
 
-    ANGLE_EGL_TRY_RETURN(thread,
-                         ValidateCreatePixmapSurface(display, configuration, pixmap, attributes),
-                         "eglCreatePixmapSurface", GetDisplayIfValid(display), EGL_NO_SURFACE);
+    ANGLE_EGL_VALIDATE(thread, CreatePixmapSurface, GetDisplayIfValid(display), EGL_NO_SURFACE,
+                       display, configuration, pixmap, attributes);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreatePixmapSurface",
                          GetDisplayIfValid(display), EGL_NO_SURFACE);
     egl::Surface *surface = nullptr;
@@ -338,8 +332,8 @@ EGLBoolean EGLAPIENTRY EGL_DestroySurface(EGLDisplay dpy, EGLSurface surface)
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Surface *eglSurface   = static_cast<Surface *>(surface);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateDestroySurface(display, eglSurface, surface),
-                         "eglDestroySurface", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, DestroySurface, GetSurfaceIfValid(display, eglSurface), EGL_FALSE,
+                       display, eglSurface, surface);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroySurface",
                          GetDisplayIfValid(display), EGL_FALSE);
     ANGLE_EGL_TRY_RETURN(thread, display->destroySurface(eglSurface), "eglDestroySurface",
@@ -364,8 +358,8 @@ EGLBoolean EGLAPIENTRY EGL_QuerySurface(EGLDisplay dpy,
     egl::Display *display     = static_cast<egl::Display *>(dpy);
     const Surface *eglSurface = static_cast<const Surface *>(surface);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateQuerySurface(display, eglSurface, attribute, value),
-                         "eglQuerySurface", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, QuerySurface, GetSurfaceIfValid(display, eglSurface), EGL_FALSE,
+                       display, eglSurface, attribute, value);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQuerySurface",
                          GetDisplayIfValid(display), EGL_FALSE);
     ANGLE_EGL_TRY_RETURN(thread, QuerySurfaceAttrib(display, eglSurface, attribute, value),
@@ -392,9 +386,8 @@ EGLContext EGLAPIENTRY EGL_CreateContext(EGLDisplay dpy,
     gl::Context *sharedGLContext = static_cast<gl::Context *>(share_context);
     AttributeMap attributes      = AttributeMap::CreateFromIntArray(attrib_list);
 
-    ANGLE_EGL_TRY_RETURN(thread,
-                         ValidateCreateContext(display, configuration, sharedGLContext, attributes),
-                         "eglCreateContext", GetDisplayIfValid(display), EGL_NO_CONTEXT);
+    ANGLE_EGL_VALIDATE(thread, CreateContext, GetDisplayIfValid(display), EGL_NO_CONTEXT, display,
+                       configuration, sharedGLContext, attributes);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateContext",
                          GetDisplayIfValid(display), EGL_NO_CONTEXT);
     gl::Context *context = nullptr;
@@ -417,8 +410,8 @@ EGLBoolean EGLAPIENTRY EGL_DestroyContext(EGLDisplay dpy, EGLContext ctx)
     egl::Display *display = static_cast<egl::Display *>(dpy);
     gl::Context *context  = static_cast<gl::Context *>(ctx);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateDestroyContext(display, context, ctx), "eglDestroyContext",
-                         GetContextIfValid(display, context), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, DestroyContext, GetContextIfValid(display, context), EGL_FALSE,
+                       display, context, ctx);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroyContext",
                          GetDisplayIfValid(display), EGL_FALSE);
     bool contextWasCurrent = context == thread->getContext();
@@ -455,8 +448,8 @@ EGLBoolean EGLAPIENTRY EGL_MakeCurrent(EGLDisplay dpy,
     Surface *readSurface  = static_cast<Surface *>(read);
     gl::Context *context  = static_cast<gl::Context *>(ctx);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateMakeCurrent(display, drawSurface, readSurface, context),
-                         "eglMakeCurrent", GetContextIfValid(display, context), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, MakeCurrent, GetContextIfValid(display, context), EGL_FALSE, display,
+                       drawSurface, readSurface, context);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglMakeCurrent",
                          GetDisplayIfValid(display), EGL_FALSE);
     Surface *previousDraw        = thread->getCurrentDrawSurface();
@@ -495,7 +488,7 @@ EGLSurface EGLAPIENTRY EGL_GetCurrentSurface(EGLint readdraw)
     }
     else
     {
-        thread->setError(EglBadParameter(), GetDebug(), "eglGetCurrentSurface", nullptr);
+        thread->setError(EglBadParameter(), "eglGetCurrentSurface", nullptr);
         return EGL_NO_SURFACE;
     }
 }
@@ -530,8 +523,8 @@ EGLBoolean EGLAPIENTRY EGL_QueryContext(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     gl::Context *context  = static_cast<gl::Context *>(ctx);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateQueryContext(display, context, attribute, value),
-                         "eglQueryContext", GetContextIfValid(display, context), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, QueryContext, GetContextIfValid(display, context), EGL_FALSE,
+                       display, context, attribute, value);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryContext",
                          GetDisplayIfValid(display), EGL_FALSE);
     QueryContextAttrib(context, attribute, value);
@@ -548,8 +541,7 @@ EGLBoolean EGLAPIENTRY EGL_WaitGL(void)
 
     egl::Display *display = thread->getDisplay();
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateDisplay(display), "eglWaitGL", GetDisplayIfValid(display),
-                         EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, Display, GetDisplayIfValid(display), EGL_FALSE, display);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglWaitGL", GetDisplayIfValid(display),
                          EGL_FALSE);
 
@@ -570,8 +562,7 @@ EGLBoolean EGLAPIENTRY EGL_WaitNative(EGLint engine)
 
     egl::Display *display = thread->getDisplay();
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateWaitNative(display, engine), "eglWaitNative",
-                         GetThreadIfValid(thread), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, WaitNative, GetThreadIfValid(thread), EGL_FALSE, display, engine);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglWaitNative",
                          GetDisplayIfValid(display), EGL_FALSE);
 
@@ -592,8 +583,8 @@ EGLBoolean EGLAPIENTRY EGL_SwapBuffers(EGLDisplay dpy, EGLSurface surface)
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Surface *eglSurface   = (Surface *)surface;
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateSwapBuffers(thread, display, eglSurface), "eglSwapBuffers",
-                         GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, SwapBuffers, GetSurfaceIfValid(display, eglSurface), EGL_FALSE,
+                       thread, display, eglSurface);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglSwapBuffers",
                          GetDisplayIfValid(display), EGL_FALSE);
 
@@ -618,8 +609,8 @@ EGLBoolean EGLAPIENTRY EGL_CopyBuffers(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Surface *eglSurface   = static_cast<Surface *>(surface);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateCopyBuffers(display, eglSurface), "eglCopyBuffers",
-                         GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, CopyBuffers, GetSurfaceIfValid(display, eglSurface), EGL_FALSE,
+                       display, eglSurface);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCopyBuffers",
                          GetDisplayIfValid(display), EGL_FALSE);
     UNIMPLEMENTED();  // FIXME
@@ -642,9 +633,8 @@ EGLBoolean EGLAPIENTRY EGL_BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLi
     gl::Context *context       = thread->getContext();
     gl::Texture *textureObject = nullptr;
 
-    ANGLE_EGL_TRY_RETURN(
-        thread, ValidateBindTexImage(display, eglSurface, surface, buffer, context, &textureObject),
-        "eglBindTexImage", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, BindTexImage, GetSurfaceIfValid(display, eglSurface), EGL_FALSE,
+                       display, eglSurface, surface, buffer, context, &textureObject);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglBindTexImage",
                          GetDisplayIfValid(display), EGL_FALSE);
     if (context)
@@ -672,8 +662,8 @@ EGLBoolean EGLAPIENTRY EGL_SurfaceAttrib(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Surface *eglSurface   = static_cast<Surface *>(surface);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateSurfaceAttrib(display, eglSurface, attribute, value),
-                         "eglSurfaceAttrib", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, SurfaceAttrib, GetSurfaceIfValid(display, eglSurface), EGL_FALSE,
+                       display, eglSurface, attribute, value);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglSurfaceAttrib",
                          GetDisplayIfValid(display), EGL_FALSE);
     SetSurfaceAttrib(eglSurface, attribute, value);
@@ -693,8 +683,8 @@ EGLBoolean EGLAPIENTRY EGL_ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, E
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Surface *eglSurface   = static_cast<Surface *>(surface);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateReleaseTexImage(display, eglSurface, surface, buffer),
-                         "eglReleaseTexImage", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, ReleaseTexImage, GetSurfaceIfValid(display, eglSurface), EGL_FALSE,
+                       display, eglSurface, surface, buffer);
 
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglReleaseTexImage",
                          GetDisplayIfValid(display), EGL_FALSE);
@@ -722,8 +712,8 @@ EGLBoolean EGLAPIENTRY EGL_SwapInterval(EGLDisplay dpy, EGLint interval)
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Surface *draw_surface = static_cast<Surface *>(thread->getCurrentDrawSurface());
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateSwapInterval(display, draw_surface, context),
-                         "eglSwapInterval", GetDisplayIfValid(display), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, SwapInterval, GetDisplayIfValid(display), EGL_FALSE, display,
+                       draw_surface, context);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglSwapInterval",
                          GetDisplayIfValid(display), EGL_FALSE);
     const egl::Config *surfaceConfig = draw_surface->getConfig();
@@ -743,8 +733,7 @@ EGLBoolean EGLAPIENTRY EGL_BindAPI(EGLenum api)
     FUNC_EVENT("EGLenum api = 0x%X", api);
     Thread *thread = egl::GetCurrentThread();
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateBindAPI(api), "eglBindAPI", GetThreadIfValid(thread),
-                         EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, BindAPI, GetThreadIfValid(thread), EGL_FALSE, api);
 
     thread->setAPI(api);
 
@@ -783,10 +772,8 @@ EGLSurface EGLAPIENTRY EGL_CreatePbufferFromClientBuffer(EGLDisplay dpy,
     Config *configuration   = static_cast<Config *>(config);
     AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
 
-    ANGLE_EGL_TRY_RETURN(
-        thread,
-        ValidateCreatePbufferFromClientBuffer(display, buftype, buffer, configuration, attributes),
-        "eglCreatePbufferFromClientBuffer", GetDisplayIfValid(display), EGL_NO_SURFACE);
+    ANGLE_EGL_VALIDATE(thread, CreatePbufferFromClientBuffer, GetDisplayIfValid(display),
+                       EGL_NO_SURFACE, display, buftype, buffer, configuration, attributes);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreatePbufferFromClientBuffer",
                          GetDisplayIfValid(display), EGL_NO_SURFACE);
     egl::Surface *surface = nullptr;
@@ -840,8 +827,7 @@ EGLBoolean EGLAPIENTRY EGL_WaitClient(void)
     egl::Display *display = thread->getDisplay();
     gl::Context *context  = thread->getContext();
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateDisplay(display), "eglWaitClient",
-                         GetContextIfValid(display, context), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, Display, GetContextIfValid(display, context), EGL_FALSE, display);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglWaitClient",
                          GetDisplayIfValid(display), EGL_FALSE);
     ANGLE_EGL_TRY_RETURN(thread, display->waitClient(context), "eglWaitClient",
@@ -879,9 +865,8 @@ EGLSync EGLAPIENTRY EGL_CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib
     gl::Context *currentContext  = thread->getContext();
     egl::Display *currentDisplay = currentContext ? currentContext->getDisplay() : nullptr;
 
-    ANGLE_EGL_TRY_RETURN(
-        thread, ValidateCreateSync(display, type, attributes, currentDisplay, currentContext),
-        "eglCreateSync", GetDisplayIfValid(display), EGL_NO_SYNC);
+    ANGLE_EGL_VALIDATE(thread, CreateSync, GetDisplayIfValid(display), EGL_NO_SYNC, display, type,
+                       attributes, currentDisplay, currentContext);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateSync",
                          GetDisplayIfValid(display), EGL_FALSE);
     egl::Sync *syncObject = nullptr;
@@ -902,8 +887,8 @@ EGLBoolean EGLAPIENTRY EGL_DestroySync(EGLDisplay dpy, EGLSync sync)
     egl::Display *display = static_cast<egl::Display *>(dpy);
     egl::Sync *syncObject = static_cast<Sync *>(sync);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateDestroySync(display, syncObject), "eglDestroySync",
-                         GetDisplayIfValid(display), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, DestroySync, GetDisplayIfValid(display), EGL_FALSE, display,
+                       syncObject);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroySync",
                          GetDisplayIfValid(display), EGL_FALSE);
     display->destroySync(syncObject);
@@ -924,8 +909,8 @@ EGLint EGLAPIENTRY EGL_ClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags
     egl::Display *display = static_cast<egl::Display *>(dpy);
     egl::Sync *syncObject = static_cast<Sync *>(sync);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateClientWaitSync(display, syncObject, flags, timeout),
-                         "eglClientWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, ClientWaitSync, GetSyncIfValid(display, syncObject), EGL_FALSE,
+                       display, syncObject, flags, timeout);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglClientWaitSync",
                          GetDisplayIfValid(display), EGL_FALSE);
     gl::Context *currentContext = thread->getContext();
@@ -953,8 +938,8 @@ EGLBoolean EGLAPIENTRY EGL_GetSyncAttrib(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     egl::Sync *syncObject = static_cast<Sync *>(sync);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateGetSyncAttrib(display, syncObject, attribute, value),
-                         "eglGetSyncAttrib", GetSyncIfValid(display, syncObject), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, GetSyncAttrib, GetSyncIfValid(display, syncObject), EGL_FALSE,
+                       display, syncObject, attribute, value);
 
     EGLint valueExt;
     ANGLE_EGL_TRY_RETURN(thread, GetSyncAttrib(display, syncObject, attribute, &valueExt),
@@ -984,20 +969,16 @@ EGLImage EGLAPIENTRY EGL_CreateImage(EGLDisplay dpy,
     gl::Context *context    = static_cast<gl::Context *>(ctx);
     AttributeMap attributes = AttributeMap::CreateFromIntArray((const EGLint *)attrib_list);
 
-    Error error = ValidateCreateImage(display, context, target, buffer, attributes);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglCreateImage", GetDisplayIfValid(display));
-        return EGL_NO_IMAGE;
-    }
+    ANGLE_EGL_VALIDATE(thread, CreateImage, GetDisplayIfValid(display), EGL_FALSE, display, context,
+                       target, buffer, attributes);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateImage",
                          GetDisplayIfValid(display), EGL_FALSE);
 
     Image *image = nullptr;
-    error        = display->createImage(context, target, buffer, attributes, &image);
+    Error error  = display->createImage(context, target, buffer, attributes, &image);
     if (error.isError())
     {
-        thread->setError(error, GetDebug(), "eglCreateImage", GetDisplayIfValid(display));
+        thread->setError(error, "eglCreateImage", GetDisplayIfValid(display));
         return EGL_NO_IMAGE;
     }
 
@@ -1014,12 +995,8 @@ EGLBoolean EGLAPIENTRY EGL_DestroyImage(EGLDisplay dpy, EGLImage image)
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Image *img            = static_cast<Image *>(image);
 
-    Error error = ValidateDestroyImage(display, img);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglDestroyImage", GetImageIfValid(display, img));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, DestroyImage, GetImageIfValid(display, img), EGL_FALSE, display,
+                       img);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroyImage",
                          GetDisplayIfValid(display), EGL_FALSE);
     display->destroyImage(img);
@@ -1039,8 +1016,8 @@ EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplay(EGLenum platform,
                platform, (uintptr_t)native_display, (uintptr_t)attrib_list);
     Thread *thread = egl::GetCurrentThread();
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateGetPlatformDisplay(platform, native_display, attrib_list),
-                         "eglGetPlatformDisplay", GetThreadIfValid(thread), EGL_NO_DISPLAY);
+    ANGLE_EGL_VALIDATE(thread, GetPlatformDisplay, GetThreadIfValid(thread), EGL_NO_DISPLAY,
+                       platform, native_display, attrib_list);
 
     const auto &attribMap = AttributeMap::CreateFromAttribArray(attrib_list);
     if (platform == EGL_PLATFORM_ANGLE_ANGLE)
@@ -1080,9 +1057,8 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurface(EGLDisplay dpy,
     EGLNativeWindowType win = reinterpret_cast<EGLNativeWindowType>(native_window);
     AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
 
-    ANGLE_EGL_TRY_RETURN(
-        thread, ValidateCreateWindowSurface(display, configuration, win, attributes),
-        "eglPlatformCreateWindowSurface", GetDisplayIfValid(display), EGL_NO_SURFACE);
+    ANGLE_EGL_VALIDATE(thread, CreateWindowSurface, GetDisplayIfValid(display), EGL_NO_SURFACE,
+                       display, configuration, win, attributes);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateWindowSurface",
                          GetDisplayIfValid(display), EGL_NO_SURFACE);
     egl::Surface *surface = nullptr;
@@ -1112,9 +1088,8 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurface(EGLDisplay dpy,
     EGLNativePixmapType pixmap = reinterpret_cast<EGLNativePixmapType>(native_pixmap);
     AttributeMap attributes    = AttributeMap::CreateFromAttribArray(attrib_list);
 
-    ANGLE_EGL_TRY_RETURN(
-        thread, ValidateCreatePixmapSurface(display, configuration, pixmap, attributes),
-        "eglCreatePlatformPixmapSurface", GetDisplayIfValid(display), EGL_NO_SURFACE);
+    ANGLE_EGL_VALIDATE(thread, CreatePixmapSurface, GetDisplayIfValid(display), EGL_NO_SURFACE,
+                       display, configuration, pixmap, attributes);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreatePlatformPixmapSurface",
                          GetDisplayIfValid(display), EGL_NO_SURFACE);
     egl::Surface *surface = nullptr;
@@ -1138,8 +1113,8 @@ EGLBoolean EGLAPIENTRY EGL_WaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags)
     gl::Context *context  = thread->getContext();
     egl::Sync *syncObject = static_cast<Sync *>(sync);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateWaitSync(display, context, syncObject, flags),
-                         "eglWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, WaitSync, GetSyncIfValid(display, syncObject), EGL_FALSE, display,
+                       context, syncObject, flags);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglWaitSync",
                          GetDisplayIfValid(display), EGL_FALSE);
     gl::Context *currentContext = thread->getContext();

src/libGLESv2/entry_points_egl_ext.cpp

@@ -41,57 +41,14 @@ EGLBoolean EGLAPIENTRY EGL_QuerySurfacePointerANGLE(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Surface *eglSurface   = static_cast<Surface *>(surface);
 
-    Error error = ValidateSurface(display, eglSurface);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglQuerySurfacePointerANGLE",
-                         GetSurfaceIfValid(display, eglSurface));
-        return EGL_FALSE;
-    }
-
-    if (!display->getExtensions().querySurfacePointer)
-    {
-        thread->setSuccess();
-        return EGL_FALSE;
-    }
-
-    if (surface == EGL_NO_SURFACE)
-    {
-        thread->setError(EglBadSurface(), GetDebug(), "eglQuerySurfacePointerANGLE",
-                         GetSurfaceIfValid(display, eglSurface));
-        return EGL_FALSE;
-    }
-
-    // validate the attribute parameter
-    switch (attribute)
-    {
-        case EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE:
-            if (!display->getExtensions().surfaceD3DTexture2DShareHandle)
-            {
-                thread->setError(EglBadAttribute(), GetDebug(), "eglQuerySurfacePointerANGLE",
-                                 GetSurfaceIfValid(display, eglSurface));
-                return EGL_FALSE;
-            }
-            break;
-        case EGL_DXGI_KEYED_MUTEX_ANGLE:
-            if (!display->getExtensions().keyedMutex)
-            {
-                thread->setError(EglBadAttribute(), GetDebug(), "eglQuerySurfacePointerANGLE",
-                                 GetSurfaceIfValid(display, eglSurface));
-                return EGL_FALSE;
-            }
-            break;
-        default:
-            thread->setError(EglBadAttribute(), GetDebug(), "eglQuerySurfacePointerANGLE",
-                             GetSurfaceIfValid(display, eglSurface));
-            return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, QuerySurfacePointerANGLE, GetDisplayIfValid(display), EGL_FALSE,
+                       display, eglSurface, attribute, value);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQuerySurfacePointerANGLE",
                          GetDisplayIfValid(display), EGL_FALSE);
-    error = eglSurface->querySurfacePointerANGLE(attribute, value);
+    Error error = eglSurface->querySurfacePointerANGLE(attribute, value);
     if (error.isError())
     {
-        thread->setError(error, GetDebug(), "eglQuerySurfacePointerANGLE",
+        thread->setError(error, "eglQuerySurfacePointerANGLE",
                          GetSurfaceIfValid(display, eglSurface));
         return EGL_FALSE;
     }
@@ -117,49 +74,14 @@ EGLBoolean EGLAPIENTRY EGL_PostSubBufferNV(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Surface *eglSurface   = static_cast<Surface *>(surface);
 
-    if (x < 0 || y < 0 || width < 0 || height < 0)
-    {
-        thread->setError(EglBadParameter(), GetDebug(), "eglPostSubBufferNV",
-                         GetSurfaceIfValid(display, eglSurface));
-        return EGL_FALSE;
-    }
-
-    Error error = ValidateSurface(display, eglSurface);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglPostSubBufferNV",
-                         GetSurfaceIfValid(display, eglSurface));
-        return EGL_FALSE;
-    }
-
-    if (display->testDeviceLost())
-    {
-        thread->setError(EglContextLost(), GetDebug(), "eglPostSubBufferNV",
-                         GetSurfaceIfValid(display, eglSurface));
-        return EGL_FALSE;
-    }
-
-    if (surface == EGL_NO_SURFACE)
-    {
-        thread->setError(EglBadSurface(), GetDebug(), "eglPostSubBufferNV",
-                         GetSurfaceIfValid(display, eglSurface));
-        return EGL_FALSE;
-    }
-
-    if (!display->getExtensions().postSubBuffer)
-    {
-        // Spec is not clear about how this should be handled.
-        thread->setSuccess();
-        return EGL_TRUE;
-    }
+    ANGLE_EGL_VALIDATE(thread, PostSubBufferNV, GetDisplayIfValid(display), EGL_FALSE, display,
+                       eglSurface, x, y, width, height);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglPostSubBufferNV",
                          GetDisplayIfValid(display), EGL_FALSE);
-    // TODO(jmadill): Validate Surface is bound to the thread.
-    error = eglSurface->postSubBuffer(thread->getContext(), x, y, width, height);
+    Error error = eglSurface->postSubBuffer(thread->getContext(), x, y, width, height);
     if (error.isError())
     {
-        thread->setError(error, GetDebug(), "eglPostSubBufferNV",
-                         GetSurfaceIfValid(display, eglSurface));
+        thread->setError(error, "eglPostSubBufferNV", GetSurfaceIfValid(display, eglSurface));
         return EGL_FALSE;
     }
 
@@ -179,12 +101,8 @@ EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplayEXT(EGLenum platform,
                platform, (uintptr_t)native_display, (uintptr_t)attrib_list);
     Thread *thread = egl::GetCurrentThread();
 
-    Error err = ValidateGetPlatformDisplayEXT(platform, native_display, attrib_list);
-    thread->setError(err, GetDebug(), "eglGetPlatformDisplayEXT", GetThreadIfValid(thread));
-    if (err.isError())
-    {
-        return EGL_NO_DISPLAY;
-    }
+    ANGLE_EGL_VALIDATE(thread, GetPlatformDisplayEXT, GetThreadIfValid(thread), EGL_NO_DISPLAY,
+                       platform, native_display, attrib_list);
 
     const auto &attribMap = AttributeMap::CreateFromIntArray(attrib_list);
     if (platform == EGL_PLATFORM_ANGLE_ANGLE)
@@ -221,13 +139,11 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurfaceEXT(EGLDisplay dpy,
     Config *configuration   = static_cast<Config *>(config);
     AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
 
-    ANGLE_EGL_TRY_RETURN(
-        thread,
-        ValidateCreatePlatformWindowSurfaceEXT(display, configuration, native_window, attributes),
-        "eglCreatePlatformWindowSurfaceEXT", GetDisplayIfValid(display), EGL_NO_SURFACE);
+    ANGLE_EGL_VALIDATE(thread, CreatePlatformWindowSurfaceEXT, GetDisplayIfValid(display),
+                       EGL_NO_SURFACE, display, configuration, native_window, attributes);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreatePlatformWindowSurfaceEXT",
                          GetDisplayIfValid(display), EGL_NO_SURFACE);
-    thread->setError(EglBadDisplay() << "CreatePlatformWindowSurfaceEXT unimplemented.", GetDebug(),
+    thread->setError(EglBadDisplay() << "CreatePlatformWindowSurfaceEXT unimplemented.",
                      "eglCreatePlatformWindowSurfaceEXT", GetDisplayIfValid(display));
     return EGL_NO_SURFACE;
 }
@@ -249,13 +165,11 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurfaceEXT(EGLDisplay dpy,
     Config *configuration   = static_cast<Config *>(config);
     AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
 
-    ANGLE_EGL_TRY_RETURN(
-        thread,
-        ValidateCreatePlatformPixmapSurfaceEXT(display, configuration, native_pixmap, attributes),
-        "eglCreatePlatformPixmapSurfaceEXT", GetDisplayIfValid(display), EGL_NO_SURFACE);
+    ANGLE_EGL_VALIDATE(thread, CreatePlatformPixmapSurfaceEXT, GetDisplayIfValid(display),
+                       EGL_NO_SURFACE, display, configuration, native_pixmap, attributes);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreatePlatformPixmapSurfaceEXT",
                          GetDisplayIfValid(display), EGL_NO_SURFACE);
-    thread->setError(EglBadDisplay() << "CreatePlatformPixmapSurfaceEXT unimplemented.", GetDebug(),
+    thread->setError(EglBadDisplay() << "CreatePlatformPixmapSurfaceEXT unimplemented.",
                      "eglCreatePlatformPixmapSurfaceEXT", GetDisplayIfValid(display));
     return EGL_NO_SURFACE;
 }
@@ -273,62 +187,11 @@ EGLBoolean EGLAPIENTRY EGL_QueryDeviceAttribEXT(EGLDeviceEXT device,
 
     Device *dev = static_cast<Device *>(device);
 
-    Error error = ValidateDevice(dev);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglQueryDeviceAttribEXT", GetDeviceIfValid(dev));
-        return EGL_FALSE;
-    }
-    if (!Display::GetClientExtensions().deviceQueryEXT)
-    {
-        thread->setError(EglBadAccess() << "EGL_EXT_device_query not supported.", GetDebug(),
-                         "eglQueryDeviceAttribEXT", GetDeviceIfValid(dev));
-        return EGL_FALSE;
-    }
-
-    // validate the attribute parameter
-    switch (attribute)
-    {
-        case EGL_D3D11_DEVICE_ANGLE:
-        case EGL_D3D9_DEVICE_ANGLE:
-            if (!dev->getExtensions().deviceD3D || dev->getType() != attribute)
-            {
-                thread->setError(EglBadAttribute(), GetDebug(), "eglQueryDeviceAttribEXT",
-                                 GetDeviceIfValid(dev));
-                return EGL_FALSE;
-            }
-            error = dev->getAttribute(attribute, value);
-            break;
-        case EGL_EAGL_CONTEXT_ANGLE:
-            if (!dev->getExtensions().deviceEAGL)
-            {
-                thread->setError(EglBadAttribute(), GetDebug(), "eglQueryDeviceAttribEXT",
-                                 GetDeviceIfValid(dev));
-                return EGL_FALSE;
-            }
-            error = dev->getAttribute(attribute, value);
-            break;
-        case EGL_CGL_CONTEXT_ANGLE:
-        case EGL_CGL_PIXEL_FORMAT_ANGLE:
-            if (!dev->getExtensions().deviceCGL)
-            {
-                thread->setError(EglBadAttribute(), GetDebug(), "eglQueryDeviceAttribEXT",
-                                 GetDeviceIfValid(dev));
-                return EGL_FALSE;
-            }
-            error = dev->getAttribute(attribute, value);
-            break;
-        default:
-            thread->setError(EglBadAttribute(), GetDebug(), "eglQueryDeviceAttribEXT",
-                             GetDeviceIfValid(dev));
-            return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, QueryDeviceAttribEXT, GetDeviceIfValid(dev), EGL_FALSE, dev,
+                       attribute, value);
+    ANGLE_EGL_TRY_RETURN(thread, dev->getAttribute(attribute, value), "eglQueryDeviceAttribEXT",
+                         GetDeviceIfValid(dev), EGL_FALSE);
 
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglQueryDeviceAttribEXT", GetDeviceIfValid(dev));
-        return EGL_FALSE;
-    }
     thread->setSuccess();
     return EGL_TRUE;
 }
@@ -343,12 +206,8 @@ const char *EGLAPIENTRY EGL_QueryDeviceStringEXT(EGLDeviceEXT device, EGLint nam
 
     Device *dev = static_cast<Device *>(device);
 
-    Error error = ValidateDevice(dev);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglQueryDeviceStringEXT", GetDeviceIfValid(dev));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, QueryDeviceStringEXT, GetDeviceIfValid(dev), EGL_FALSE, dev, name);
+
     egl::Display *owningDisplay = dev->getOwningDisplay();
     ANGLE_EGL_TRY_RETURN(thread, owningDisplay->prepareForCall(), "eglQueryDeviceStringEXT",
                          GetDisplayIfValid(owningDisplay), EGL_FALSE);
@@ -359,8 +218,7 @@ const char *EGLAPIENTRY EGL_QueryDeviceStringEXT(EGLDeviceEXT device, EGLint nam
             result = dev->getExtensionString().c_str();
             break;
         default:
-            thread->setError(EglBadDevice(), GetDebug(), "eglQueryDeviceStringEXT",
-                             GetDeviceIfValid(dev));
+            thread->setError(EglBadDevice(), "eglQueryDeviceStringEXT", GetDeviceIfValid(dev));
             return nullptr;
     }
 
@@ -379,8 +237,8 @@ EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribut
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Thread *thread        = egl::GetCurrentThread();
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateQueryDisplayAttribEXT(display, attribute),
-                         "eglQueryDisplayAttribEXT", GetDisplayIfValid(display), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, QueryDisplayAttribEXT, GetDisplayIfValid(display), EGL_FALSE,
+                       display, attribute);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryDisplayAttribEXT",
                          GetDisplayIfValid(display), EGL_FALSE);
     *value = display->queryAttrib(attribute);
@@ -401,8 +259,8 @@ EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribANGLE(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Thread *thread        = egl::GetCurrentThread();
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateQueryDisplayAttribANGLE(display, attribute),
-                         "eglQueryDisplayAttribANGLE", GetDisplayIfValid(display), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, QueryDisplayAttribANGLE, GetDisplayIfValid(display), EGL_FALSE,
+                       display, attribute);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryDisplayAttribANGLE",
                          GetDisplayIfValid(display), EGL_FALSE);
     *value = display->queryAttrib(attribute);
@@ -429,21 +287,13 @@ ANGLE_EXPORT EGLImageKHR EGLAPIENTRY EGL_CreateImageKHR(EGLDisplay dpy,
     gl::Context *context    = static_cast<gl::Context *>(ctx);
     AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
 
-    Error error = ValidateCreateImageKHR(display, context, target, buffer, attributes);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglCreateImageKHR", GetDisplayIfValid(display));
-        return EGL_NO_IMAGE;
-    }
+    ANGLE_EGL_VALIDATE(thread, CreateImageKHR, GetDisplayIfValid(display), EGL_NO_IMAGE, display,
+                       context, target, buffer, attributes);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateImageKHR",
                          GetDisplayIfValid(display), EGL_NO_IMAGE);
     Image *image = nullptr;
-    error        = display->createImage(context, target, buffer, attributes, &image);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglCreateImageKHR", GetDisplayIfValid(display));
-        return EGL_NO_IMAGE;
-    }
+    ANGLE_EGL_TRY_RETURN(thread, display->createImage(context, target, buffer, attributes, &image),
+                         "", GetDisplayIfValid(display), EGL_NO_IMAGE);
 
     thread->setSuccess();
     return static_cast<EGLImage>(image);
@@ -459,12 +309,8 @@ ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroyImageKHR(EGLDisplay dpy, EGLImage
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Image *img            = static_cast<Image *>(image);
 
-    Error error = ValidateDestroyImageKHR(display, img);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglDestroyImageKHR", GetImageIfValid(display, img));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, DestroyImageKHR, GetImageIfValid(display, img), EGL_FALSE, display,
+                       img);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroyImageKHR",
                          GetDisplayIfValid(display), EGL_FALSE);
     display->destroyImage(img);
@@ -484,21 +330,12 @@ ANGLE_EXPORT EGLDeviceEXT EGLAPIENTRY EGL_CreateDeviceANGLE(EGLint device_type,
                device_type, (uintptr_t)native_device, (uintptr_t)attrib_list);
     Thread *thread = egl::GetCurrentThread();
 
-    Error error = ValidateCreateDeviceANGLE(device_type, native_device, attrib_list);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglCreateDeviceANGLE", GetThreadIfValid(thread));
-        return EGL_NO_DEVICE_EXT;
-    }
+    ANGLE_EGL_VALIDATE(thread, CreateDeviceANGLE, GetThreadIfValid(thread), EGL_NO_DEVICE_EXT,
+                       device_type, native_device, attrib_list);
 
     Device *device = nullptr;
-    error          = Device::CreateDevice(device_type, native_device, &device);
-    if (error.isError())
-    {
-        ASSERT(device == nullptr);
-        thread->setError(error, GetDebug(), "eglCreateDeviceANGLE", GetThreadIfValid(thread));
-        return EGL_NO_DEVICE_EXT;
-    }
+    ANGLE_EGL_TRY_RETURN(thread, Device::CreateDevice(device_type, native_device, &device),
+                         "eglCreateDeviceANGLE", GetThreadIfValid(thread), EGL_NO_DEVICE_EXT);
 
     thread->setSuccess();
     return device;
@@ -512,13 +349,7 @@ ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_ReleaseDeviceANGLE(EGLDeviceEXT device)
 
     Device *dev = static_cast<Device *>(device);
 
-    Error error = ValidateReleaseDeviceANGLE(dev);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglReleaseDeviceANGLE", GetDeviceIfValid(dev));
-        return EGL_FALSE;
-    }
-
+    ANGLE_EGL_VALIDATE(thread, ReleaseDeviceANGLE, GetDeviceIfValid(dev), EGL_FALSE, dev);
     SafeDelete(dev);
 
     thread->setSuccess();
@@ -536,21 +367,13 @@ EGLStreamKHR EGLAPIENTRY EGL_CreateStreamKHR(EGLDisplay dpy, const EGLint *attri
     egl::Display *display   = static_cast<egl::Display *>(dpy);
     AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
 
-    Error error = ValidateCreateStreamKHR(display, attributes);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglCreateStreamKHR", GetDisplayIfValid(display));
-        return EGL_NO_STREAM_KHR;
-    }
+    ANGLE_EGL_VALIDATE(thread, CreateStreamKHR, GetDisplayIfValid(display), EGL_NO_STREAM_KHR,
+                       display, attributes);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateStreamKHR",
                          GetDisplayIfValid(display), EGL_NO_STREAM_KHR);
     Stream *stream;
-    error = display->createStream(attributes, &stream);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglCreateStreamKHR", GetDisplayIfValid(display));
-        return EGL_NO_STREAM_KHR;
-    }
+    ANGLE_EGL_TRY_RETURN(thread, display->createStream(attributes, &stream), "eglCreateStreamKHR",
+                         GetDisplayIfValid(display), EGL_NO_STREAM_KHR);
 
     thread->setSuccess();
     return static_cast<EGLStreamKHR>(stream);
@@ -566,13 +389,8 @@ EGLBoolean EGLAPIENTRY EGL_DestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream)
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Stream *streamObject  = static_cast<Stream *>(stream);
 
-    Error error = ValidateDestroyStreamKHR(display, streamObject);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglDestroyStreamKHR",
-                         GetStreamIfValid(display, streamObject));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, DestroyStreamKHR, GetStreamIfValid(display, streamObject), EGL_FALSE,
+                       display, streamObject);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroyStreamKHR",
                          GetDisplayIfValid(display), EGL_FALSE);
     display->destroyStream(streamObject);
@@ -596,13 +414,8 @@ EGLBoolean EGLAPIENTRY EGL_StreamAttribKHR(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Stream *streamObject  = static_cast<Stream *>(stream);
 
-    Error error = ValidateStreamAttribKHR(display, streamObject, attribute, value);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglStreamAttribKHR",
-                         GetStreamIfValid(display, streamObject));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, StreamAttribKHR, GetStreamIfValid(display, streamObject), EGL_FALSE,
+                       display, streamObject, attribute, value);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglStreamAttribKHR",
                          GetDisplayIfValid(display), EGL_FALSE);
     switch (attribute)
@@ -636,13 +449,8 @@ EGLBoolean EGLAPIENTRY EGL_QueryStreamKHR(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Stream *streamObject  = static_cast<Stream *>(stream);
 
-    Error error = ValidateQueryStreamKHR(display, streamObject, attribute, value);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglQueryStreamKHR",
-                         GetStreamIfValid(display, streamObject));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, QueryStreamKHR, GetStreamIfValid(display, streamObject), EGL_FALSE,
+                       display, streamObject, attribute, value);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryStreamKHR",
                          GetDisplayIfValid(display), EGL_FALSE);
     switch (attribute)
@@ -679,13 +487,8 @@ EGLBoolean EGLAPIENTRY EGL_QueryStreamu64KHR(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Stream *streamObject  = static_cast<Stream *>(stream);
 
-    Error error = ValidateQueryStreamu64KHR(display, streamObject, attribute, value);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglQueryStreamu64KHR",
-                         GetStreamIfValid(display, streamObject));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, QueryStreamu64KHR, GetStreamIfValid(display, streamObject),
+                       EGL_FALSE, display, streamObject, attribute, value);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryStreamu64KHR",
                          GetDisplayIfValid(display), EGL_FALSE);
     switch (attribute)
@@ -715,23 +518,15 @@ EGLBoolean EGLAPIENTRY EGL_StreamConsumerGLTextureExternalKHR(EGLDisplay dpy, EG
     Stream *streamObject  = static_cast<Stream *>(stream);
     gl::Context *context  = gl::GetValidGlobalContext();
 
-    Error error = ValidateStreamConsumerGLTextureExternalKHR(display, context, streamObject);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglStreamConsumerGLTextureExternalKHR",
-                         GetStreamIfValid(display, streamObject));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, StreamConsumerGLTextureExternalKHR,
+                       GetStreamIfValid(display, streamObject), EGL_FALSE, display, context,
+                       streamObject);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglStreamConsumerGLTextureExternalKHR",
                          GetDisplayIfValid(display), EGL_FALSE);
-    error = streamObject->createConsumerGLTextureExternal(AttributeMap(), context);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglStreamConsumerGLTextureExternalKHR",
-                         GetStreamIfValid(display, streamObject));
-        return EGL_FALSE;
-    }
-
+    ANGLE_EGL_TRY_RETURN(thread,
+                         streamObject->createConsumerGLTextureExternal(AttributeMap(), context),
+                         "eglStreamConsumerGLTextureExternalKHR",
+                         GetStreamIfValid(display, streamObject), EGL_FALSE);
     thread->setSuccess();
     return EGL_TRUE;
 }
@@ -747,23 +542,13 @@ EGLBoolean EGLAPIENTRY EGL_StreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR
     Stream *streamObject  = static_cast<Stream *>(stream);
     gl::Context *context  = gl::GetValidGlobalContext();
 
-    Error error = ValidateStreamConsumerAcquireKHR(display, context, streamObject);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglStreamConsumerAcquireKHR",
-                         GetStreamIfValid(display, streamObject));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, StreamConsumerAcquireKHR, GetStreamIfValid(display, streamObject),
+                       EGL_FALSE, display, context, streamObject);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglStreamConsumerAcquireKHR",
                          GetDisplayIfValid(display), EGL_FALSE);
-    error = streamObject->consumerAcquire(context);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglStreamConsumerAcquireKHR",
-                         GetStreamIfValid(display, streamObject));
-        return EGL_FALSE;
-    }
-
+    ANGLE_EGL_TRY_RETURN(thread, streamObject->consumerAcquire(context),
+                         "eglStreamConsumerAcquireKHR", GetStreamIfValid(display, streamObject),
+                         EGL_FALSE);
     thread->setSuccess();
     return EGL_TRUE;
 }
@@ -779,23 +564,13 @@ EGLBoolean EGLAPIENTRY EGL_StreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR
     Stream *streamObject  = static_cast<Stream *>(stream);
     gl::Context *context  = gl::GetValidGlobalContext();
 
-    Error error = ValidateStreamConsumerReleaseKHR(display, context, streamObject);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglSStreamConsumerReleaseKHR",
-                         GetStreamIfValid(display, streamObject));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, StreamConsumerReleaseKHR, GetStreamIfValid(display, streamObject),
+                       EGL_FALSE, display, context, streamObject);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglStreamConsumerReleaseKHR",
                          GetDisplayIfValid(display), EGL_FALSE);
-    error = streamObject->consumerRelease(context);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglStreamConsumerReleaseKHR",
-                         GetStreamIfValid(display, streamObject));
-        return EGL_FALSE;
-    }
-
+    ANGLE_EGL_TRY_RETURN(thread, streamObject->consumerRelease(context),
+                         "eglStreamConsumerReleaseKHR", GetStreamIfValid(display, streamObject),
+                         EGL_FALSE);
     thread->setSuccess();
     return EGL_TRUE;
 }
@@ -815,25 +590,15 @@ EGLBoolean EGLAPIENTRY EGL_StreamConsumerGLTextureExternalAttribsNV(EGLDisplay d
     gl::Context *context    = gl::GetValidGlobalContext();
     AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
 
-    Error error = ValidateStreamConsumerGLTextureExternalAttribsNV(display, context, streamObject,
-                                                                   attributes);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglStreamConsumerGLTextureExternalAttribsNV",
-                         GetStreamIfValid(display, streamObject));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, StreamConsumerGLTextureExternalAttribsNV,
+                       GetStreamIfValid(display, streamObject), EGL_FALSE, display, context,
+                       streamObject, attributes);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(),
                          "eglStreamConsumerGLTextureExternalAttribsNV", GetDisplayIfValid(display),
                          EGL_FALSE);
-    error = streamObject->createConsumerGLTextureExternal(attributes, context);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglStreamConsumerGLTextureExternalAttribsNV",
-                         GetStreamIfValid(display, streamObject));
-        return EGL_FALSE;
-    }
-
+    ANGLE_EGL_TRY_RETURN(thread, streamObject->createConsumerGLTextureExternal(attributes, context),
+                         "eglStreamConsumerGLTextureExternalAttribsNV",
+                         GetStreamIfValid(display, streamObject), EGL_FALSE);
     thread->setSuccess();
     return EGL_TRUE;
 }
@@ -852,24 +617,15 @@ EGLBoolean EGLAPIENTRY EGL_CreateStreamProducerD3DTextureANGLE(EGLDisplay dpy,
     Stream *streamObject    = static_cast<Stream *>(stream);
     AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
 
-    Error error = ValidateCreateStreamProducerD3DTextureANGLE(display, streamObject, attributes);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglCreateStreamProducerD3DTextureANGLE",
-                         GetStreamIfValid(display, streamObject));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, CreateStreamProducerD3DTextureANGLE,
+                       GetStreamIfValid(display, streamObject), EGL_FALSE, display, streamObject,
+                       attributes);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(),
                          "eglCreateStreamProducerD3DTextureANGLE", GetDisplayIfValid(display),
                          EGL_FALSE);
-    error = streamObject->createProducerD3D11Texture(attributes);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglCreateStreamProducerD3DTextureANGLE",
-                         GetStreamIfValid(display, streamObject));
-        return EGL_FALSE;
-    }
-
+    ANGLE_EGL_TRY_RETURN(thread, streamObject->createProducerD3D11Texture(attributes),
+                         "eglCreateStreamProducerD3DTextureANGLE",
+                         GetStreamIfValid(display, streamObject), EGL_FALSE);
     thread->setSuccess();
     return EGL_TRUE;
 }
@@ -891,23 +647,13 @@ EGLBoolean EGLAPIENTRY EGL_StreamPostD3DTextureANGLE(EGLDisplay dpy,
     Stream *streamObject    = static_cast<Stream *>(stream);
     AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
 
-    Error error = ValidateStreamPostD3DTextureANGLE(display, streamObject, texture, attributes);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglStreamPostD3DTextureANGLE",
-                         GetStreamIfValid(display, streamObject));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, StreamPostD3DTextureANGLE, GetStreamIfValid(display, streamObject),
+                       EGL_FALSE, display, streamObject, texture, attributes);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglStreamPostD3DTextureANGLE",
                          GetDisplayIfValid(display), EGL_FALSE);
-    error = streamObject->postD3D11Texture(texture, attributes);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglStreamPostD3DTextureANGLE",
-                         GetStreamIfValid(display, streamObject));
-        return EGL_FALSE;
-    }
-
+    ANGLE_EGL_TRY_RETURN(thread, streamObject->postD3D11Texture(texture, attributes),
+                         "eglStreamPostD3DTextureANGLE", GetStreamIfValid(display, streamObject),
+                         EGL_FALSE);
     thread->setSuccess();
     return EGL_TRUE;
 }
@@ -929,9 +675,8 @@ ANGLE_EXPORT EGLSync EGLAPIENTRY EGL_CreateSyncKHR(EGLDisplay dpy,
     gl::Context *currentContext  = thread->getContext();
     egl::Display *currentDisplay = currentContext ? currentContext->getDisplay() : nullptr;
 
-    ANGLE_EGL_TRY_RETURN(
-        thread, ValidateCreateSyncKHR(display, type, attributes, currentDisplay, currentContext),
-        "eglCreateSync", GetDisplayIfValid(display), EGL_NO_SYNC);
+    ANGLE_EGL_VALIDATE(thread, CreateSyncKHR, GetDisplayIfValid(display), EGL_NO_SYNC, display,
+                       type, attributes, currentDisplay, currentContext);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateSync",
                          GetDisplayIfValid(display), EGL_NO_SYNC);
     egl::Sync *syncObject = nullptr;
@@ -952,8 +697,8 @@ ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroySyncKHR(EGLDisplay dpy, EGLSync s
     egl::Display *display = static_cast<egl::Display *>(dpy);
     egl::Sync *syncObject = static_cast<Sync *>(sync);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateDestroySync(display, syncObject), "eglDestroySync",
-                         GetDisplayIfValid(display), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, DestroySync, GetDisplayIfValid(display), EGL_FALSE, display,
+                       syncObject);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroySync",
                          GetDisplayIfValid(display), EGL_FALSE);
     display->destroySync(syncObject);
@@ -977,8 +722,8 @@ ANGLE_EXPORT EGLint EGLAPIENTRY EGL_ClientWaitSyncKHR(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     egl::Sync *syncObject = static_cast<Sync *>(sync);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateClientWaitSync(display, syncObject, flags, timeout),
-                         "eglClientWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, ClientWaitSync, GetSyncIfValid(display, syncObject), EGL_FALSE,
+                       display, syncObject, flags, timeout);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglClientWaitSync",
                          GetDisplayIfValid(display), EGL_FALSE);
     gl::Context *currentContext = thread->getContext();
@@ -1006,8 +751,8 @@ ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetSyncAttribKHR(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     egl::Sync *syncObject = static_cast<Sync *>(sync);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateGetSyncAttribKHR(display, syncObject, attribute, value),
-                         "eglGetSyncAttrib", GetSyncIfValid(display, syncObject), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, GetSyncAttribKHR, GetSyncIfValid(display, syncObject), EGL_FALSE,
+                       display, syncObject, attribute, value);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglGetSyncAttrib",
                          GetDisplayIfValid(display), EGL_FALSE);
     ANGLE_EGL_TRY_RETURN(thread, GetSyncAttrib(display, syncObject, attribute, value),
@@ -1030,8 +775,8 @@ ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_WaitSyncKHR(EGLDisplay dpy, EGLSync sync
     gl::Context *context  = thread->getContext();
     egl::Sync *syncObject = static_cast<Sync *>(sync);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateWaitSync(display, context, syncObject, flags),
-                         "eglWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, WaitSync, GetSyncIfValid(display, syncObject), EGL_FALSE, display,
+                       context, syncObject, flags);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglWaitSync",
                          GetDisplayIfValid(display), EGL_FALSE);
     gl::Context *currentContext = thread->getContext();
@@ -1058,22 +803,12 @@ EGLBoolean EGLAPIENTRY EGL_GetMscRateANGLE(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Surface *eglSurface   = static_cast<Surface *>(surface);
 
-    Error error = ValidateGetMscRateANGLE(display, eglSurface, numerator, denominator);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglGetMscRateANGLE",
-                         GetSurfaceIfValid(display, eglSurface));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, GetMscRateANGLE, GetSurfaceIfValid(display, eglSurface), EGL_FALSE,
+                       display, eglSurface, numerator, denominator);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglGetMscRateANGLE",
                          GetDisplayIfValid(display), EGL_FALSE);
-    error = eglSurface->getMscRate(numerator, denominator);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglGetMscRateANGLE",
-                         GetSurfaceIfValid(display, eglSurface));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_TRY_RETURN(thread, eglSurface->getMscRate(numerator, denominator),
+                         "eglGetMscRateANGLE", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
 
     thread->setSuccess();
     return EGL_TRUE;
@@ -1096,22 +831,13 @@ EGLBoolean EGLAPIENTRY EGL_GetSyncValuesCHROMIUM(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Surface *eglSurface   = static_cast<Surface *>(surface);
 
-    Error error = ValidateGetSyncValuesCHROMIUM(display, eglSurface, ust, msc, sbc);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglGetSyncValuesCHROMIUM",
-                         GetSurfaceIfValid(display, eglSurface));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, GetSyncValuesCHROMIUM, GetSurfaceIfValid(display, eglSurface),
+                       EGL_FALSE, display, eglSurface, ust, msc, sbc);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglGetSyncValuesCHROMIUM",
                          GetDisplayIfValid(display), EGL_FALSE);
-    error = eglSurface->getSyncValues(ust, msc, sbc);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglGetSyncValuesCHROMIUM",
-                         GetSurfaceIfValid(display, eglSurface));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_TRY_RETURN(thread, eglSurface->getSyncValues(ust, msc, sbc),
+                         "eglGetSyncValuesCHROMIUM", GetSurfaceIfValid(display, eglSurface),
+                         EGL_FALSE);
 
     thread->setSuccess();
     return EGL_TRUE;
@@ -1133,22 +859,13 @@ EGLBoolean EGLAPIENTRY EGL_SwapBuffersWithDamageKHR(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Surface *eglSurface   = static_cast<Surface *>(surface);
 
-    Error error = ValidateSwapBuffersWithDamageKHR(display, eglSurface, rects, n_rects);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglSwapBuffersWithDamageEXT",
-                         GetSurfaceIfValid(display, eglSurface));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, SwapBuffersWithDamageKHR, GetSurfaceIfValid(display, eglSurface),
+                       EGL_FALSE, display, eglSurface, rects, n_rects);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglSwapBuffersWithDamageEXT",
                          GetDisplayIfValid(display), EGL_FALSE);
-    error = eglSurface->swapWithDamage(thread->getContext(), rects, n_rects);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglSwapBuffersWithDamageEXT",
-                         GetSurfaceIfValid(display, eglSurface));
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_TRY_RETURN(thread, eglSurface->swapWithDamage(thread->getContext(), rects, n_rects),
+                         "eglSwapBuffersWithDamageEXT", GetSurfaceIfValid(display, eglSurface),
+                         EGL_FALSE);
 
     thread->setSuccess();
     return EGL_TRUE;
@@ -1167,9 +884,8 @@ EGLBoolean EGLAPIENTRY EGL_PresentationTimeANDROID(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Surface *eglSurface   = static_cast<Surface *>(surface);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidatePresentationTimeANDROID(display, eglSurface, time),
-                         "eglPresentationTimeANDROID", GetSurfaceIfValid(display, eglSurface),
-                         EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, PresentationTimeANDROID, GetSurfaceIfValid(display, eglSurface),
+                       EGL_FALSE, display, eglSurface, time);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglPresentationTimeANDROID",
                          GetDisplayIfValid(display), EGL_FALSE);
     ANGLE_EGL_TRY_RETURN(thread, eglSurface->setPresentationTime(time),
@@ -1191,8 +907,8 @@ ANGLE_EXPORT void EGLAPIENTRY EGL_SetBlobCacheFuncsANDROID(EGLDisplay dpy,
 
     egl::Display *display = static_cast<egl::Display *>(dpy);
 
-    ANGLE_EGL_TRY(thread, ValidateSetBlobCacheANDROID(display, set, get),
-                  "eglSetBlobCacheFuncsANDROID", GetDisplayIfValid(display));
+    ANGLE_EGL_VALIDATE_VOID(thread, SetBlobCacheANDROID, GetDisplayIfValid(display), display, set,
+                            get);
     ANGLE_EGL_TRY(thread, display->prepareForCall(), "eglSetBlobCacheFuncsANDROID",
                   GetDisplayIfValid(display));
     thread->setSuccess();
@@ -1207,8 +923,8 @@ EGLint EGLAPIENTRY EGL_ProgramCacheGetAttribANGLE(EGLDisplay dpy, EGLenum attrib
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Thread *thread        = egl::GetCurrentThread();
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateProgramCacheGetAttribANGLE(display, attrib),
-                         "eglProgramCacheGetAttribANGLE", GetDisplayIfValid(display), 0);
+    ANGLE_EGL_VALIDATE(thread, ProgramCacheGetAttribANGLE, GetDisplayIfValid(display), 0, display,
+                       attrib);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglProgramCacheGetAttribANGLE",
                          GetDisplayIfValid(display), 0);
     thread->setSuccess();
@@ -1232,9 +948,8 @@ void EGLAPIENTRY EGL_ProgramCacheQueryANGLE(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Thread *thread        = egl::GetCurrentThread();
 
-    ANGLE_EGL_TRY(thread,
-                  ValidateProgramCacheQueryANGLE(display, index, key, keysize, binary, binarysize),
-                  "eglProgramCacheQueryANGLE", GetDisplayIfValid(display));
+    ANGLE_EGL_VALIDATE_VOID(thread, ProgramCacheQueryANGLE, GetDisplayIfValid(display), display,
+                            index, key, keysize, binary, binarysize);
     ANGLE_EGL_TRY(thread, display->prepareForCall(), "eglProgramCacheQueryANGLE",
                   GetDisplayIfValid(display));
     ANGLE_EGL_TRY(thread, display->programCacheQuery(index, key, keysize, binary, binarysize),
@@ -1258,9 +973,8 @@ void EGLAPIENTRY EGL_ProgramCachePopulateANGLE(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Thread *thread        = egl::GetCurrentThread();
 
-    ANGLE_EGL_TRY(thread,
-                  ValidateProgramCachePopulateANGLE(display, key, keysize, binary, binarysize),
-                  "eglProgramCachePopulateANGLE", GetDisplayIfValid(display));
+    ANGLE_EGL_VALIDATE_VOID(thread, ProgramCachePopulateANGLE, GetDisplayIfValid(display), display,
+                            key, keysize, binary, binarysize);
     ANGLE_EGL_TRY(thread, display->prepareForCall(), "eglProgramCachePopulateANGLE",
                   GetDisplayIfValid(display));
     ANGLE_EGL_TRY(thread, display->programCachePopulate(key, keysize, binary, binarysize),
@@ -1278,8 +992,8 @@ EGLint EGLAPIENTRY EGL_ProgramCacheResizeANGLE(EGLDisplay dpy, EGLint limit, EGL
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Thread *thread        = egl::GetCurrentThread();
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateProgramCacheResizeANGLE(display, limit, mode),
-                         "eglProgramCacheResizeANGLE", GetDisplayIfValid(display), 0);
+    ANGLE_EGL_VALIDATE(thread, ProgramCacheResizeANGLE, GetDisplayIfValid(display), 0, display,
+                       limit, mode);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglProgramCacheResizeANGLE",
                          GetDisplayIfValid(display), 0);
     thread->setSuccess();
@@ -1298,12 +1012,8 @@ EGLint EGLAPIENTRY EGL_DebugMessageControlKHR(EGLDEBUGPROCKHR callback,
 
     AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
 
-    Error error = ValidateDebugMessageControlKHR(callback, attributes);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglDebugMessageControlKHR", nullptr);
-        return error.getCode();
-    }
+    ANGLE_EGL_VALIDATE(thread, DebugMessageControlKHR, nullptr, thread->getError(), callback,
+                       attributes);
 
     Debug *debug = GetDebug();
     debug->setCallback(callback, attributes);
@@ -1320,12 +1030,7 @@ EGLBoolean EGLAPIENTRY EGL_QueryDebugKHR(EGLint attribute, EGLAttrib *value)
 
     Thread *thread = egl::GetCurrentThread();
 
-    Error error = ValidateQueryDebugKHR(attribute, value);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglQueryDebugKHR", nullptr);
-        return EGL_FALSE;
-    }
+    ANGLE_EGL_VALIDATE(thread, QueryDebugKHR, nullptr, EGL_FALSE, attribute, value);
 
     Debug *debug = GetDebug();
     switch (attribute)
@@ -1365,22 +1070,10 @@ EGLint EGLAPIENTRY EGL_LabelObjectKHR(EGLDisplay dpy,
     Thread *thread        = egl::GetCurrentThread();
 
     ObjectType objectTypePacked = FromEGLenum<ObjectType>(objectType);
-    Error error = ValidateLabelObjectKHR(thread, display, objectTypePacked, object, label);
-    if (error.isError())
-    {
-        thread->setError(error, GetDebug(), "eglLabelObjectKHR",
-                         GetLabeledObjectIfValid(thread, display, objectTypePacked, object));
-        return error.getCode();
-    }
-    if (display)
-    {
-        error = display->prepareForCall();
-        if (error.isError())
-        {
-            thread->setError(error, GetDebug(), "eglLabelObjectKHR", GetDisplayIfValid(display));
-            return error.getCode();
-        }
-    }
+    ANGLE_EGL_VALIDATE(thread, LabelObjectKHR,
+                       GetLabeledObjectIfValid(thread, display, objectTypePacked, object),
+                       thread->getError(), thread, display, objectTypePacked, object, label);
+
     LabeledObject *labeledObject =
         GetLabeledObjectIfValid(thread, display, objectTypePacked, object);
     ASSERT(labeledObject != nullptr);
@@ -1405,9 +1098,9 @@ ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingSupportedANDROID(EGLD
 
     CompositorTiming nameInternal = FromEGLenum<CompositorTiming>(name);
 
-    ANGLE_EGL_TRY_RETURN(
-        thread, ValidateGetCompositorTimingSupportedANDROID(display, eglSurface, nameInternal),
-        "eglQueryTimestampSupportedANDROID", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, GetCompositorTimingSupportedANDROID,
+                       GetSurfaceIfValid(display, eglSurface), EGL_FALSE, display, eglSurface,
+                       nameInternal);
 
     thread->setSuccess();
     return eglSurface->getSupportedCompositorTimings().test(nameInternal);
@@ -1430,10 +1123,8 @@ ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingANDROID(EGLDisplay dp
     Surface *eglSurface   = static_cast<Surface *>(surface);
     Thread *thread        = egl::GetCurrentThread();
 
-    ANGLE_EGL_TRY_RETURN(
-        thread,
-        ValidateGetCompositorTimingANDROID(display, eglSurface, numTimestamps, names, values),
-        "eglGetCompositorTimingANDROIDD", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, GetCompositorTimingANDROID, GetSurfaceIfValid(display, eglSurface),
+                       EGL_FALSE, display, eglSurface, numTimestamps, names, values);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglGetCompositorTimingANDROIDD",
                          GetDisplayIfValid(display), EGL_FALSE);
     ANGLE_EGL_TRY_RETURN(thread, eglSurface->getCompositorTiming(numTimestamps, names, values),
@@ -1457,9 +1148,8 @@ ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetNextFrameIdANDROID(EGLDisplay dpy,
     Surface *eglSurface   = static_cast<Surface *>(surface);
     Thread *thread        = egl::GetCurrentThread();
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateGetNextFrameIdANDROID(display, eglSurface, frameId),
-                         "eglGetNextFrameIdANDROID", GetSurfaceIfValid(display, eglSurface),
-                         EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, GetNextFrameIdANDROID, GetSurfaceIfValid(display, eglSurface),
+                       EGL_FALSE, display, eglSurface, frameId);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglGetNextFrameIdANDROID",
                          GetDisplayIfValid(display), EGL_FALSE);
     ANGLE_EGL_TRY_RETURN(thread, eglSurface->getNextFrameId(frameId), "eglGetNextFrameIdANDROID",
@@ -1484,9 +1174,9 @@ ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampSupportedANDROID(EGLDis
 
     Timestamp timestampInternal = FromEGLenum<Timestamp>(timestamp);
 
-    ANGLE_EGL_TRY_RETURN(
-        thread, ValidateGetFrameTimestampSupportedANDROID(display, eglSurface, timestampInternal),
-        "eglQueryTimestampSupportedANDROID", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, GetFrameTimestampSupportedANDROID,
+                       GetSurfaceIfValid(display, eglSurface), EGL_FALSE, display, eglSurface,
+                       timestampInternal);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryTimestampSupportedANDROID",
                          GetDisplayIfValid(display), EGL_FALSE);
     thread->setSuccess();
@@ -1512,11 +1202,8 @@ ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampsANDROID(EGLDisplay dpy
     Surface *eglSurface   = static_cast<Surface *>(surface);
     Thread *thread        = egl::GetCurrentThread();
 
-    ANGLE_EGL_TRY_RETURN(thread,
-                         ValidateGetFrameTimestampsANDROID(display, eglSurface, frameId,
-                                                           numTimestamps, timestamps, values),
-                         "eglGetFrameTimestampsANDROID", GetSurfaceIfValid(display, eglSurface),
-                         EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, GetFrameTimestampsANDROID, GetSurfaceIfValid(display, eglSurface),
+                       EGL_FALSE, display, eglSurface, frameId, numTimestamps, timestamps, values);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglGetFrameTimestampsANDROID",
                          GetDisplayIfValid(display), EGL_FALSE);
     ANGLE_EGL_TRY_RETURN(
@@ -1539,8 +1226,8 @@ ANGLE_EXPORT const char *EGLAPIENTRY EGL_QueryStringiANGLE(EGLDisplay dpy,
     egl::Display *display = static_cast<egl::Display *>(dpy);
     Thread *thread        = egl::GetCurrentThread();
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateQueryStringiANGLE(display, name, index),
-                         "eglQueryStringiANGLE", GetDisplayIfValid(display), nullptr);
+    ANGLE_EGL_VALIDATE(thread, QueryStringiANGLE, GetDisplayIfValid(display), nullptr, display,
+                       name, index);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryStringiANGLE",
                          GetDisplayIfValid(display), nullptr);
     thread->setSuccess();
@@ -1554,8 +1241,7 @@ EGLClientBuffer EGLAPIENTRY EGL_GetNativeClientBufferANDROID(const struct AHardw
 
     Thread *thread = egl::GetCurrentThread();
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateGetNativeClientBufferANDROID(buffer),
-                         "eglGetNativeClientBufferANDROID", nullptr, nullptr);
+    ANGLE_EGL_VALIDATE(thread, GetNativeClientBufferANDROID, nullptr, nullptr, buffer);
 
     thread->setSuccess();
     return egl::Display::GetNativeClientBuffer(buffer);
@@ -1574,8 +1260,7 @@ EGLClientBuffer EGLAPIENTRY EGL_CreateNativeClientBufferANDROID(const EGLint *at
                          "eglCreateNativeClientBufferANDROID", nullptr, nullptr);
 
     const AttributeMap &attribMap = AttributeMap::CreateFromIntArray(attrib_list);
-    ANGLE_EGL_TRY_RETURN(thread, ValidateCreateNativeClientBufferANDROID(attribMap),
-                         "eglCreateNativeClientBufferANDROID", nullptr, nullptr);
+    ANGLE_EGL_VALIDATE(thread, CreateNativeClientBufferANDROID, nullptr, nullptr, attribMap);
 
     EGLClientBuffer eglClientBuffer = nullptr;
     ANGLE_EGL_TRY_RETURN(thread,
@@ -1596,9 +1281,8 @@ EGLint EGLAPIENTRY EGL_DupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync)
     Sync *syncObject      = static_cast<Sync *>(sync);
     Thread *thread        = egl::GetCurrentThread();
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateDupNativeFenceFDANDROID(display, syncObject),
-                         "eglDupNativeFenceFDANDROID", GetSyncIfValid(display, syncObject),
-                         EGL_NO_NATIVE_FENCE_FD_ANDROID);
+    ANGLE_EGL_VALIDATE(thread, DupNativeFenceFDANDROID, GetSyncIfValid(display, syncObject),
+                       EGL_NO_NATIVE_FENCE_FD_ANDROID, display, syncObject);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDupNativeFenceFDANDROID",
                          GetDisplayIfValid(display), EGL_NO_NATIVE_FENCE_FD_ANDROID);
     EGLint result = EGL_NO_NATIVE_FENCE_FD_ANDROID;
@@ -1623,9 +1307,8 @@ EGLBoolean EGLAPIENTRY EGL_SwapBuffersWithFrameTokenANGLE(EGLDisplay dpy,
     egl::Surface *eglSurface = static_cast<egl::Surface *>(surface);
     Thread *thread           = egl::GetCurrentThread();
 
-    ANGLE_EGL_TRY_RETURN(
-        thread, ValidateSwapBuffersWithFrameTokenANGLE(display, eglSurface, frametoken),
-        "eglSwapBuffersWithFrameTokenANGLE", GetDisplayIfValid(display), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, SwapBuffersWithFrameTokenANGLE, GetDisplayIfValid(display),
+                       EGL_FALSE, display, eglSurface, frametoken);
     ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglSwapBuffersWithFrameTokenANGLE",
                          GetDisplayIfValid(display), EGL_FALSE);
     ANGLE_EGL_TRY_RETURN(thread, eglSurface->swapWithFrameToken(thread->getContext(), frametoken),
@@ -1646,8 +1329,8 @@ void EGLAPIENTRY EGL_ReleaseHighPowerGPUANGLE(EGLDisplay dpy, EGLContext ctx)
     egl::Display *display = static_cast<egl::Display *>(dpy);
     gl::Context *context  = static_cast<gl::Context *>(ctx);
 
-    ANGLE_EGL_TRY(thread, ValidateContext(display, context), "eglReleaseHighPowerGPUANGLE",
-                  GetDisplayIfValid(display));
+    ANGLE_EGL_VALIDATE_VOID(thread, ReleaseHighPowerGPUANGLE, GetDisplayIfValid(display), display,
+                            context);
     ANGLE_EGL_TRY(thread, display->prepareForCall(), "eglReleaseHighPowerGPUANGLE",
                   GetDisplayIfValid(display));
     ANGLE_EGL_TRY(thread, context->releaseHighPowerGPU(), "eglReleaseHighPowerGPUANGLE",
@@ -1666,8 +1349,8 @@ void EGLAPIENTRY EGL_ReacquireHighPowerGPUANGLE(EGLDisplay dpy, EGLContext ctx)
     egl::Display *display = static_cast<egl::Display *>(dpy);
     gl::Context *context  = static_cast<gl::Context *>(ctx);
 
-    ANGLE_EGL_TRY(thread, ValidateContext(display, context), "eglReacquireHighPowerGPUANGLE",
-                  GetDisplayIfValid(display));
+    ANGLE_EGL_VALIDATE_VOID(thread, ReacquireHighPowerGPUANGLE, GetDisplayIfValid(display), display,
+                            context);
     ANGLE_EGL_TRY(thread, display->prepareForCall(), "eglReacquireHighPowerGPUANGLE",
                   GetDisplayIfValid(display));
     ANGLE_EGL_TRY(thread, context->reacquireHighPowerGPU(), "eglReacquireHighPowerGPUANGLE",
@@ -1684,8 +1367,7 @@ void EGLAPIENTRY EGL_HandleGPUSwitchANGLE(EGLDisplay dpy)
 
     egl::Display *display = static_cast<egl::Display *>(dpy);
 
-    ANGLE_EGL_TRY(thread, ValidateDisplay(display), "eglHandleGPUSwitchANGLE",
-                  GetDisplayIfValid(display));
+    ANGLE_EGL_VALIDATE_VOID(thread, HandleGPUSwitchANGLE, GetDisplayIfValid(display), display);
     ANGLE_EGL_TRY(thread, display->prepareForCall(), "eglHandleGPUSwitchANGLE",
                   GetDisplayIfValid(display));
     ANGLE_EGL_TRY(thread, display->handleGPUSwitch(), "eglHandleGPUSwitchANGLE",
@@ -1706,8 +1388,8 @@ ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_SignalSyncKHR(EGLDisplay dpy, EGLSync sy
     egl::Display *display = static_cast<egl::Display *>(dpy);
     egl::Sync *syncObject = static_cast<Sync *>(sync);
 
-    ANGLE_EGL_TRY_RETURN(thread, ValidateSignalSyncKHR(display, syncObject, mode),
-                         "eglSignalSyncKHR", GetSyncIfValid(display, syncObject), EGL_FALSE);
+    ANGLE_EGL_VALIDATE(thread, SignalSyncKHR, GetSyncIfValid(display, syncObject), EGL_FALSE,
+                       display, syncObject, mode);
 
     gl::Context *currentContext = thread->getContext();
     ANGLE_EGL_TRY_RETURN(thread, syncObject->signal(display, currentContext, mode),

src/libGLESv2/global_state.cpp

@@ -12,6 +12,7 @@
 #include "common/platform.h"
 #include "common/system_utils.h"
 #include "libANGLE/ErrorStrings.h"
+#include "libANGLE/Thread.h"
 #include "libGLESv2/resource.h"
 
 #include <atomic>
@@ -20,8 +21,6 @@ namespace egl
 {
 namespace
 {
-Debug *g_Debug = nullptr;
-
 ANGLE_REQUIRE_CONSTANT_INIT std::atomic<angle::GlobalMutex *> g_Mutex(nullptr);
 static_assert(std::is_trivially_destructible<decltype(g_Mutex)>::value,
               "global mutex is not trivially destructible");
@@ -47,15 +46,6 @@ Thread *AllocateCurrentThread()
     return gCurrentThread;
 }
 
-void AllocateDebug()
-{
-    // All EGL calls use a global lock, this is thread safe
-    if (g_Debug == nullptr)
-    {
-        g_Debug = new Debug();
-    }
-}
-
 void AllocateMutex()
 {
     if (g_Mutex == nullptr)
@@ -85,12 +75,6 @@ Thread *GetCurrentThread()
     return (current ? current : AllocateCurrentThread());
 }
 
-Debug *GetDebug()
-{
-    AllocateDebug();
-    return g_Debug;
-}
-
 void SetContextCurrent(Thread *thread, gl::Context *context)
 {
     ASSERT(gCurrentThread);
@@ -122,17 +106,11 @@ namespace egl
 
 namespace
 {
-
 void DeallocateCurrentThread()
 {
     SafeDelete(gCurrentThread);
 }
 
-void DeallocateDebug()
-{
-    SafeDelete(g_Debug);
-}
-
 void DeallocateMutex()
 {
     angle::GlobalMutex *mutex = g_Mutex.exchange(nullptr);
@@ -145,8 +123,7 @@ void DeallocateMutex()
 
 bool InitializeProcess()
 {
-    ASSERT(g_Debug == nullptr);
-    AllocateDebug();
+    EnsureDebugAllocated();
     AllocateMutex();
     return AllocateCurrentThread() != nullptr;
 }