Skip to content

A
angle
Commit cfe14e28 by Jamie Madill Committed by Commit Bot
Options

EGL: Remove egl::Error from validation code.

Instead of using an egl::Error return value, errors are recorded on the egl::Thread immediately at the call site. This makes the code work the same way as in the GL entry points. Updates the EGL "try" macros to include a special handler for the EGL validation entry points. Uses a special ValidationContext helper class to preserve the existing info. Bug: angleproject:5378 Change-Id: I897f221a41fe406676950600e4ac559081b9f541 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2551790 Commit-Queue: Jamie Madill <jmadill@chromium.org> Reviewed-by: 's avatarCody Northrop <cnorthrop@google.com> Reviewed-by: 's avatarTim Van Patten <timvp@google.com>
parent 56663dbf
Showing with 718 additions and 864 deletions
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.cpp
This source diff could not be displayed because it is too large. You can view the blob instead.
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,315 +77,465 @@ 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,
Config *configuration,
gl::Context *shareContext,
const AttributeMap &attributes);
Error ValidateCreateWindowSurface(Display *display,
Config *config,
EGLNativeWindowType window,
const AttributeMap &attributes);
bool ValidateCreateContext(const ValidationContext *val,
Display *display,
Config *configuration,
gl::Context *shareContext,
const AttributeMap &attributes);
Error ValidateCreatePbufferSurface(Display *display,
Config *config,
const AttributeMap &attributes);
Error ValidateCreatePbufferFromClientBuffer(Display *display,
EGLenum buftype,
EGLClientBuffer buffer,
Config *config,
const AttributeMap &attributes);
bool ValidateCreateWindowSurface(const ValidationContext *val,
Display *display,
Config *config,
EGLNativeWindowType window,
const AttributeMap &attributes);
Error ValidateCreatePixmapSurface(Display *display,
bool ValidateCreatePbufferSurface(const ValidationContext *val,
Display *display,
Config *config,
EGLNativePixmapType pixmap,
const AttributeMap &attributes);
bool ValidateCreatePbufferFromClientBuffer(const ValidationContext *val,
Display *display,
EGLenum buftype,
EGLClientBuffer buffer,
Config *config,
const AttributeMap &attributes);
bool ValidateCreatePixmapSurface(const ValidationContext *val,
Display *display,
Config *config,
EGLNativePixmapType pixmap,
const AttributeMap &attributes);
bool ValidateMakeCurrent(const ValidationContext *val,
Display *display,
Surface *draw,
Surface *read,
gl::Context *context);
bool ValidateCreateImage(const ValidationContext *val,
const Display *display,
gl::Context *context,
EGLenum target,
EGLClientBuffer buffer,
const AttributeMap &attributes);
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);
bool ValidateDestroyImageKHR(const ValidationContext *val,
const Display *display,
const Image *image);
Error ValidateMakeCurrent(Display *display, Surface *draw, Surface *read, gl::Context *context);
Error ValidateCreateImage(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,
gl::Context *context,
EGLenum target,
EGLClientBuffer buffer,
const AttributeMap &attributes);
Error ValidateDestroyImageKHR(const Display *display, const Image *image);
Error ValidateCreateDeviceANGLE(EGLint device_type,
void *native_device,
const EGLAttrib *attrib_list);
Error ValidateReleaseDeviceANGLE(Device *device);
Error ValidateCreateSyncBase(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 ValidateCreateDeviceANGLE(const ValidationContext *val,
EGLint device_type,
void *native_device,
const EGLAttrib *attrib_list);
bool ValidateReleaseDeviceANGLE(const ValidationContext *val, Device *device);
Error ValidateCreateSyncKHR(const Display *display,
bool ValidateCreateSyncBase(const ValidationContext *val,
const Display *display,
EGLenum type,
const AttributeMap &attribs,
const Display *currentDisplay,
const gl::Context *currentContext);
Error ValidateCreateSync(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,
const Sync *sync,
EGLint flags,
EGLTime timeout);
Error ValidateWaitSync(const Display *display,
const gl::Context *context,
const Sync *sync,
EGLint flags);
Error ValidateGetSyncAttribKHR(const Display *display,
const gl::Context *currentContext,
bool isExt);
bool ValidateGetSyncAttribBase(const ValidationContext *val,
const Display *display,
const Sync *sync,
EGLint attribute,
EGLint *value);
Error ValidateGetSyncAttrib(const Display *display,
const Sync *sync,
EGLint attribute,
EGLAttrib *value);
EGLint attribute);
Error ValidateCreateStreamKHR(const Display *display, const AttributeMap &attributes);
Error ValidateDestroyStreamKHR(const Display *display, const Stream *stream);
Error ValidateStreamAttribKHR(const Display *display,
const Stream *stream,
bool ValidateCreateSyncKHR(const ValidationContext *val,
const Display *display,
EGLenum type,
const AttributeMap &attribs,
const Display *currentDisplay,
const gl::Context *currentContext);
bool ValidateCreateSync(const ValidationContext *val,
const Display *display,
EGLenum type,
const AttributeMap &attribs,
const Display *currentDisplay,
const gl::Context *currentContext);
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);
bool ValidateWaitSync(const ValidationContext *val,
const Display *display,
const gl::Context *context,
const Sync *sync,
EGLint flags);
bool ValidateGetSyncAttribKHR(const ValidationContext *val,
const Display *display,
const Sync *sync,
EGLint attribute,
EGLint value);
Error ValidateQueryStreamKHR(const Display *display,
EGLint *value);
bool ValidateGetSyncAttrib(const ValidationContext *val,
const Display *display,
const Sync *sync,
EGLint attribute,
EGLAttrib *value);
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,
EGLenum attribute,
EGLint *value);
Error ValidateQueryStreamu64KHR(const Display *display,
const Stream *stream,
EGLenum attribute,
EGLuint64KHR *value);
Error ValidateStreamConsumerGLTextureExternalKHR(const Display *display,
gl::Context *context,
const Stream *stream);
Error ValidateStreamConsumerAcquireKHR(const Display *display,
gl::Context *context,
const Stream *stream);
Error ValidateStreamConsumerReleaseKHR(const Display *display,
gl::Context *context,
const Stream *stream);
Error ValidateStreamConsumerGLTextureExternalAttribsNV(const Display *display,
gl::Context *context,
const Stream *stream,
const AttributeMap &attribs);
Error ValidateCreateStreamProducerD3DTextureANGLE(const Display *display,
const Stream *stream,
const AttributeMap &attribs);
Error ValidateStreamPostD3DTextureANGLE(const Display *display,
const Stream *stream,
void *texture,
const AttributeMap &attribs);
Error ValidateGetMscRateANGLE(const Display *display,
const Surface *surface,
const EGLint *numerator,
const EGLint *denominator);
Error ValidateGetSyncValuesCHROMIUM(const Display *display,
const Surface *surface,
const EGLuint64KHR *ust,
const EGLuint64KHR *msc,
const EGLuint64KHR *sbc);
Error ValidateDestroySurface(const Display *display,
EGLint attribute,
EGLint value);
bool ValidateQueryStreamKHR(const ValidationContext *val,
const Display *display,
const Stream *stream,
EGLenum attribute,
EGLint *value);
bool ValidateQueryStreamu64KHR(const ValidationContext *val,
const Display *display,
const Stream *stream,
EGLenum attribute,
EGLuint64KHR *value);
bool ValidateStreamConsumerGLTextureExternalKHR(const ValidationContext *val,
const Display *display,
gl::Context *context,
const Stream *stream);
bool ValidateStreamConsumerAcquireKHR(const ValidationContext *val,
const Display *display,
gl::Context *context,
const Stream *stream);
bool ValidateStreamConsumerReleaseKHR(const ValidationContext *val,
const Display *display,
gl::Context *context,
const Stream *stream);
bool ValidateStreamConsumerGLTextureExternalAttribsNV(const ValidationContext *val,
const Display *display,
gl::Context *context,
const Stream *stream,
const AttributeMap &attribs);
bool ValidateCreateStreamProducerD3DTextureANGLE(const ValidationContext *val,
const Display *display,
const Stream *stream,
const AttributeMap &attribs);
bool ValidateStreamPostD3DTextureANGLE(const ValidationContext *val,
const Display *display,
const Stream *stream,
void *texture,
const AttributeMap &attribs);
bool ValidateGetMscRateANGLE(const ValidationContext *val,
const Display *display,
const Surface *surface,
const EGLSurface eglSurface);
const EGLint *numerator,
const EGLint *denominator);
bool ValidateGetSyncValuesCHROMIUM(const ValidationContext *val,
const Display *display,
const Surface *surface,
const EGLuint64KHR *ust,
const EGLuint64KHR *msc,
const EGLuint64KHR *sbc);
bool ValidateDestroySurface(const ValidationContext *val,
const Display *display,
const Surface *surface,
const EGLSurface eglSurface);
Error ValidateDestroyContext(const Display *display,
const gl::Context *glCtx,
const EGLContext eglCtx);
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,
const Surface *surface,
EGLint *rects,
EGLint n_rects);
bool ValidateSwapBuffersWithDamageKHR(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLint *rects,
EGLint n_rects);
bool ValidateBindTexImage(const ValidationContext *val,
const Display *display,
const Surface *surface,
const EGLSurface eglSurface,
const EGLint buffer,
const gl::Context *context,
gl::Texture **textureObject);
bool ValidateReleaseTexImage(const ValidationContext *val,
const Display *display,
const Surface *surface,
const EGLSurface eglSurface,
const EGLint buffer);
Error ValidateBindTexImage(const Display *display,
const Surface *surface,
const EGLSurface eglSurface,
const EGLint buffer,
const gl::Context *context,
gl::Texture **textureObject);
bool ValidateSwapInterval(const ValidationContext *val,
const Display *display,
const Surface *draw_surface,
const gl::Context *context);
Error ValidateReleaseTexImage(const Display *display,
const Surface *surface,
const EGLSurface eglSurface,
const EGLint buffer);
bool ValidateBindAPI(const ValidationContext *val, const EGLenum api);
Error ValidateSwapInterval(const Display *display,
const Surface *draw_surface,
const gl::Context *context);
bool ValidatePresentationTimeANDROID(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLnsecsANDROID time);
Error ValidateBindAPI(const EGLenum api);
bool ValidateSetBlobCacheANDROID(const ValidationContext *val,
const Display *display,
EGLSetBlobFuncANDROID set,
EGLGetBlobFuncANDROID get);
Error ValidatePresentationTimeANDROID(const Display *display,
const Surface *surface,
EGLnsecsANDROID time);
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);
bool ValidateGetConfigs(const ValidationContext *val,
const Display *display,
EGLint configSize,
EGLint *numConfig);
// Other validation
bool ValidateCompatibleSurface(const ValidationContext *val,
const Display *display,
gl::Context *context,
const Surface *surface);
bool ValidateGetPlatformDisplay(const ValidationContext *val,
EGLenum platform,
void *native_display,
const EGLAttrib *attrib_list);
bool ValidateGetPlatformDisplayEXT(const ValidationContext *val,
EGLenum platform,
void *native_display,
const EGLint *attrib_list);
bool ValidateCreatePlatformWindowSurfaceEXT(const ValidationContext *val,
const Display *display,
const Config *configuration,
void *nativeWindow,
const AttributeMap &attributes);
bool ValidateCreatePlatformPixmapSurfaceEXT(const ValidationContext *val,
const Display *display,
const Config *configuration,
void *nativePixmap,
const AttributeMap &attributes);
Error ValidateSetBlobCacheANDROID(const Display *display,
EGLSetBlobFuncANDROID set,
EGLGetBlobFuncANDROID get);
bool ValidateProgramCacheGetAttribANGLE(const ValidationContext *val,
const Display *display,
EGLenum attrib);
Error ValidateGetConfigAttrib(const Display *display, const Config *config, EGLint attribute);
Error ValidateChooseConfig(const Display *display,
const AttributeMap &attribs,
EGLint configSize,
EGLint *numConfig);
Error ValidateGetConfigs(const Display *display, EGLint configSize, EGLint *numConfig);
bool ValidateProgramCacheQueryANGLE(const ValidationContext *val,
const Display *display,
EGLint index,
void *key,
EGLint *keysize,
void *binary,
EGLint *binarysize);
// Other validation
Error ValidateCompatibleSurface(const Display *display,
gl::Context *context,
const Surface *surface);
Error ValidateGetPlatformDisplay(EGLenum platform,
void *native_display,
const EGLAttrib *attrib_list);
Error ValidateGetPlatformDisplayEXT(EGLenum platform,
void *native_display,
const EGLint *attrib_list);
Error ValidateCreatePlatformWindowSurfaceEXT(const Display *display,
const Config *configuration,
void *nativeWindow,
const AttributeMap &attributes);
Error ValidateCreatePlatformPixmapSurfaceEXT(const Display *display,
const Config *configuration,
void *nativePixmap,
const AttributeMap &attributes);
Error ValidateProgramCacheGetAttribANGLE(const Display *display, EGLenum attrib);
Error ValidateProgramCacheQueryANGLE(const Display *display,
EGLint index,
void *key,
EGLint *keysize,
void *binary,
EGLint *binarysize);
Error ValidateProgramCachePopulateANGLE(const Display *display,
const void *key,
EGLint keysize,
const void *binary,
EGLint binarysize);
Error ValidateProgramCacheResizeANGLE(const Display *display, EGLint limit, EGLenum mode);
Error ValidateSurfaceAttrib(const Display *display,
const Surface *surface,
EGLint attribute,
EGLint value);
Error ValidateQuerySurface(const Display *display,
bool ValidateProgramCachePopulateANGLE(const ValidationContext *val,
const Display *display,
const void *key,
EGLint keysize,
const void *binary,
EGLint binarysize);
bool ValidateProgramCacheResizeANGLE(const ValidationContext *val,
const Display *display,
EGLint limit,
EGLenum mode);
bool ValidateSurfaceAttrib(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLint attribute,
EGLint *value);
Error ValidateQueryContext(const Display *display,
const gl::Context *context,
EGLint attribute,
EGLint *value);
EGLint value);
bool ValidateQuerySurface(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLint attribute,
EGLint *value);
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,
const Display *display,
ObjectType objectType,
EGLObjectKHR object,
EGLLabelKHR label);
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,
const Surface *surface,
CompositorTiming name);
Error ValidateGetCompositorTimingANDROID(const Display *display,
const Surface *surface,
EGLint numTimestamps,
const EGLint *names,
EGLnsecsANDROID *values);
bool ValidateGetCompositorTimingSupportedANDROID(const ValidationContext *val,
const Display *display,
const Surface *surface,
CompositorTiming name);
Error ValidateGetNextFrameIdANDROID(const Display *display,
const Surface *surface,
EGLuint64KHR *frameId);
Error ValidateGetFrameTimestampSupportedANDROID(const Display *display,
const Surface *surface,
Timestamp timestamp);
Error ValidateGetFrameTimestampsANDROID(const Display *display,
bool ValidateGetCompositorTimingANDROID(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLuint64KHR frameId,
EGLint numTimestamps,
const EGLint *timestamps,
const EGLint *names,
EGLnsecsANDROID *values);
Error ValidateQueryStringiANGLE(const Display *display, EGLint name, EGLint index);
bool ValidateGetNextFrameIdANDROID(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLuint64KHR *frameId);
Error ValidateQueryDisplayAttribEXT(const Display *display, const EGLint attribute);
Error ValidateQueryDisplayAttribANGLE(const Display *display, const EGLint attribute);
bool ValidateGetFrameTimestampSupportedANDROID(const ValidationContext *val,
const Display *display,
const Surface *surface,
Timestamp timestamp);
bool ValidateGetFrameTimestampsANDROID(const ValidationContext *val,
const Display *display,
const Surface *surface,
EGLuint64KHR frameId,
EGLint numTimestamps,
const EGLint *timestamps,
EGLnsecsANDROID *values);
bool ValidateQueryStringiANGLE(const ValidationContext *val,
const Display *display,
EGLint name,
EGLint index);
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,
const Surface *surface,
EGLFrameTokenANGLE frametoken);
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_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); \
#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, FUNCNAME, LABELOBJECT); \
} while (0)
#define ANGLE_EGL_TRY_RETURN(THREAD, EXPR, FUNCNAME, LABELOBJECT, RETVAL) \
do \
{ \
auto ANGLE_LOCAL_VAR = (EXPR); \
if (ANGLE_LOCAL_VAR.isError()) \
{ \
THREAD->setError(ANGLE_LOCAL_VAR, GetDebug(), FUNCNAME, LABELOBJECT); \
return RETVAL; \
} \
#define ANGLE_EGL_TRY_RETURN(THREAD, EXPR, FUNCNAME, LABELOBJECT, RETVAL) \
do \
{ \
auto ANGLE_LOCAL_VAR = (EXPR); \
if (ANGLE_LOCAL_VAR.isError()) \
{ \
THREAD->setError(ANGLE_LOCAL_VAR, FUNCNAME, LABELOBJECT); \
return RETVAL; \
} \
} while (0)
#endif // LIBANGLE_VALIDATIONEGL_H_
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;
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment