From 846cdbdbf965fc50478bcc4c6436e3dc6a489f3f Mon Sep 17 00:00:00 2001 From: Chris Xiong Date: Thu, 14 Oct 2021 19:01:18 -0400 Subject: Initial commit. --- .../chromium/files/chromium-89-angle-display.patch | 1747 ++++++++++++++++++++ 1 file changed, 1747 insertions(+) create mode 100644 www-client/chromium/files/chromium-89-angle-display.patch (limited to 'www-client/chromium/files/chromium-89-angle-display.patch') diff --git a/www-client/chromium/files/chromium-89-angle-display.patch b/www-client/chromium/files/chromium-89-angle-display.patch new file mode 100644 index 0000000..d467ce9 --- /dev/null +++ b/www-client/chromium/files/chromium-89-angle-display.patch @@ -0,0 +1,1747 @@ +diff --git a/third_party/angle/scripts/code_generation_hashes/GL_EGL_entry_points.json b/third_party/angle/scripts/code_generation_hashes/GL_EGL_entry_points.json +index c506d31fb..df8758d30 100644 +--- a/third_party/angle/scripts/code_generation_hashes/GL_EGL_entry_points.json ++++ b/third_party/angle/scripts/code_generation_hashes/GL_EGL_entry_points.json +@@ -8,7 +8,7 @@ + "scripts/entry_point_packed_gl_enums.json": + "846be5dc8cb36076207699b025633fcc", + "scripts/generate_entry_points.py": +- "95fc7635243122e679e82e1757816ab3", ++ "d15fcd0f5e3296787753ff507f7051d9", + "scripts/gl.xml": + "f66967f3f3d696b5d8306fd80bbd49a8", + "scripts/gl_angle_ext.xml": +@@ -102,7 +102,7 @@ + "src/libANGLE/frame_capture_utils_autogen.h": + "652b821a877d6eb2c62ba8d151157eea", + "src/libANGLE/validationEGL_autogen.h": +- "b3c0eae46748da68d6833cc40e4bb486", ++ "3927fa260ad183fd9193d65b3f8d82c5", + "src/libANGLE/validationES1_autogen.h": + "c8edb0a5b26303bf7c4692b9d0b05c1f", + "src/libANGLE/validationES2_autogen.h": +@@ -238,17 +238,17 @@ + "src/libGL/libGL_autogen.def": + "2789d87b05eea9f53d52e2aff499b785", + "src/libGLESv2/egl_ext_stubs_autogen.h": +- "03de6401c1695f8ca4acbde9c3ae1ba2", ++ "aeb007419aaab7b5e52b084d83dda77c", + "src/libGLESv2/egl_get_labeled_object_data.json": + "2f4148b2ddf34e62670e32c5e6da4937", + "src/libGLESv2/egl_stubs_autogen.h": +- "1c9d160acb1ed9bf5e7c26918d4a039e", ++ "6439daa350c1663e71dd0af37dcc91df", + "src/libGLESv2/entry_points_egl_autogen.cpp": +- "9fd1b2d1e0dbab804e854e33e5bc9ef2", ++ "ba9796b20452dbbe4180480aae02b8a3", + "src/libGLESv2/entry_points_egl_autogen.h": + "3bc7a8df9deadd7cfd615d0cfad0c6a8", + "src/libGLESv2/entry_points_egl_ext_autogen.cpp": +- "f52756d7a31ce136ea04a67e0ea1b447", ++ "5397ab40e9cbe1d7aa3faf91154a837a", + "src/libGLESv2/entry_points_egl_ext_autogen.h": + "9154781afd9bd6354ec6fc201b43c790", + "src/libGLESv2/entry_points_gles_1_0_autogen.cpp": +@@ -283,4 +283,4 @@ + "f93450c1f787f3da53f2525865568989", + "src/libGLESv2/libGLESv2_with_capture_autogen.def": + "7b78ab59dd1fe360a5d3c1f513c7ce55" +-} +\ No newline at end of file ++} +diff --git a/third_party/angle/scripts/generate_entry_points.py b/third_party/angle/scripts/generate_entry_points.py +index de26a60ad..0e99f6bf2 100755 +--- a/third_party/angle/scripts/generate_entry_points.py ++++ b/third_party/angle/scripts/generate_entry_points.py +@@ -1010,7 +1010,8 @@ EGL_PACKED_TYPES = { + "EGLContext": "gl::Context *", + "EGLConfig": "Config *", + "EGLDeviceEXT": "Device *", +- "EGLDisplay": "Display *", ++ # Needs an explicit namespace to avoid an X11 namespace collision. ++ "EGLDisplay": "egl::Display *", + "EGLImage": "Image *", + "EGLImageKHR": "Image *", + "EGLStreamKHR": "Stream *", +@@ -2085,7 +2086,7 @@ def get_egl_entry_point_labeled_object(ep_to_object, cmd_stripped, params, packe + return just_the_name_packed(param, packed_enums) + return None + +- display_param = find_param(params, "Display", packed_enums) ++ display_param = find_param(params, "egl::Display", packed_enums) + + # For entry points not listed in the JSON file, they default to an EGLDisplay or nothing. + if cmd_stripped not in ep_to_object: +diff --git a/third_party/angle/src/libANGLE/validationEGL_autogen.h b/third_party/angle/src/libANGLE/validationEGL_autogen.h +index aa43ab156..869bd86e5 100644 +--- a/third_party/angle/src/libANGLE/validationEGL_autogen.h ++++ b/third_party/angle/src/libANGLE/validationEGL_autogen.h +@@ -18,47 +18,47 @@ namespace egl + + // EGL 1.0 + bool ValidateChooseConfig(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const AttributeMap &attrib_listPacked, + const EGLConfig *configs, + EGLint config_size, + const EGLint *num_config); + bool ValidateCopyBuffers(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked, + EGLNativePixmapType target); + bool ValidateCreateContext(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Config *configPacked, + const gl::Context *share_contextPacked, + const AttributeMap &attrib_listPacked); + bool ValidateCreatePbufferSurface(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Config *configPacked, + const AttributeMap &attrib_listPacked); + bool ValidateCreatePixmapSurface(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Config *configPacked, + EGLNativePixmapType pixmap, + const AttributeMap &attrib_listPacked); + bool ValidateCreateWindowSurface(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Config *configPacked, + EGLNativeWindowType win, + const AttributeMap &attrib_listPacked); + bool ValidateDestroyContext(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const gl::Context *ctxPacked); + bool ValidateDestroySurface(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked); + bool ValidateGetConfigAttrib(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Config *configPacked, + EGLint attribute, + const EGLint *value); + bool ValidateGetConfigs(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const EGLConfig *configs, + EGLint config_size, + const EGLint *num_config); +@@ -68,52 +68,54 @@ bool ValidateGetDisplay(const ValidationContext *val, EGLNativeDisplayType displ + bool ValidateGetError(const ValidationContext *val); + bool ValidateGetProcAddress(const ValidationContext *val, const char *procname); + bool ValidateInitialize(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const EGLint *major, + const EGLint *minor); + bool ValidateMakeCurrent(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *drawPacked, + const Surface *readPacked, + const gl::Context *ctxPacked); + bool ValidateQueryContext(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const gl::Context *ctxPacked, + EGLint attribute, + const EGLint *value); +-bool ValidateQueryString(const ValidationContext *val, const Display *dpyPacked, EGLint name); ++bool ValidateQueryString(const ValidationContext *val, const egl::Display *dpyPacked, EGLint name); + bool ValidateQuerySurface(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked, + EGLint attribute, + const EGLint *value); + bool ValidateSwapBuffers(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked); +-bool ValidateTerminate(const ValidationContext *val, const Display *dpyPacked); ++bool ValidateTerminate(const ValidationContext *val, const egl::Display *dpyPacked); + bool ValidateWaitGL(const ValidationContext *val); + bool ValidateWaitNative(const ValidationContext *val, EGLint engine); + + // EGL 1.1 + bool ValidateBindTexImage(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked, + EGLint buffer); + bool ValidateReleaseTexImage(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked, + EGLint buffer); + bool ValidateSurfaceAttrib(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked, + EGLint attribute, + EGLint value); +-bool ValidateSwapInterval(const ValidationContext *val, const Display *dpyPacked, EGLint interval); ++bool ValidateSwapInterval(const ValidationContext *val, ++ const egl::Display *dpyPacked, ++ EGLint interval); + + // EGL 1.2 + bool ValidateBindAPI(const ValidationContext *val, EGLenum api); + bool ValidateCreatePbufferFromClientBuffer(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + EGLenum buftype, + EGLClientBuffer buffer, + const Config *configPacked, +@@ -127,53 +129,53 @@ bool ValidateGetCurrentContext(const ValidationContext *val); + + // EGL 1.5 + bool ValidateClientWaitSync(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Sync *syncPacked, + EGLint flags, + EGLTime timeout); + bool ValidateCreateImage(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const gl::Context *ctxPacked, + EGLenum target, + EGLClientBuffer buffer, + const AttributeMap &attrib_listPacked); + bool ValidateCreatePlatformPixmapSurface(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Config *configPacked, + const void *native_pixmap, + const AttributeMap &attrib_listPacked); + bool ValidateCreatePlatformWindowSurface(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Config *configPacked, + const void *native_window, + const AttributeMap &attrib_listPacked); + bool ValidateCreateSync(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + EGLenum type, + const AttributeMap &attrib_listPacked); + bool ValidateDestroyImage(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Image *imagePacked); + bool ValidateDestroySync(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Sync *syncPacked); + bool ValidateGetPlatformDisplay(const ValidationContext *val, + EGLenum platform, + const void *native_display, + const AttributeMap &attrib_listPacked); + bool ValidateGetSyncAttrib(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Sync *syncPacked, + EGLint attribute, + const EGLAttrib *value); + bool ValidateWaitSync(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Sync *syncPacked, + EGLint flags); + + // EGL_ANDROID_blob_cache + bool ValidateSetBlobCacheFuncsANDROID(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + EGLSetBlobFuncANDROID set, + EGLGetBlobFuncANDROID get); + +@@ -183,25 +185,25 @@ bool ValidateCreateNativeClientBufferANDROID(const ValidationContext *val, + + // EGL_ANDROID_get_frame_timestamps + bool ValidateGetCompositorTimingSupportedANDROID(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked, + CompositorTiming namePacked); + bool ValidateGetCompositorTimingANDROID(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked, + EGLint numTimestamps, + const EGLint *names, + const EGLnsecsANDROID *values); + bool ValidateGetNextFrameIdANDROID(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked, + const EGLuint64KHR *frameId); + bool ValidateGetFrameTimestampSupportedANDROID(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked, + Timestamp timestampPacked); + bool ValidateGetFrameTimestampsANDROID(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked, + EGLuint64KHR frameId, + EGLint numTimestamps, +@@ -214,12 +216,12 @@ bool ValidateGetNativeClientBufferANDROID(const ValidationContext *val, + + // EGL_ANDROID_native_fence_sync + bool ValidateDupNativeFenceFDANDROID(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Sync *syncPacked); + + // EGL_ANDROID_presentation_time + bool ValidatePresentationTimeANDROID(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked, + EGLnsecsANDROID time); + +@@ -232,79 +234,79 @@ bool ValidateReleaseDeviceANGLE(const ValidationContext *val, const Device *devi + + // EGL_ANGLE_feature_control + bool ValidateQueryStringiANGLE(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + EGLint name, + EGLint index); + bool ValidateQueryDisplayAttribANGLE(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + EGLint attribute, + const EGLAttrib *value); + + // EGL_ANGLE_power_preference + bool ValidateReleaseHighPowerGPUANGLE(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const gl::Context *ctxPacked); + bool ValidateReacquireHighPowerGPUANGLE(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const gl::Context *ctxPacked); +-bool ValidateHandleGPUSwitchANGLE(const ValidationContext *val, const Display *dpyPacked); ++bool ValidateHandleGPUSwitchANGLE(const ValidationContext *val, const egl::Display *dpyPacked); + + // EGL_ANGLE_program_cache_control + bool ValidateProgramCacheGetAttribANGLE(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + EGLenum attrib); + bool ValidateProgramCacheQueryANGLE(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + EGLint index, + const void *key, + const EGLint *keysize, + const void *binary, + const EGLint *binarysize); + bool ValidateProgramCachePopulateANGLE(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const void *key, + EGLint keysize, + const void *binary, + EGLint binarysize); + bool ValidateProgramCacheResizeANGLE(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + EGLint limit, + EGLint mode); + + // EGL_ANGLE_query_surface_pointer + bool ValidateQuerySurfacePointerANGLE(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked, + EGLint attribute, + void *const *value); + + // EGL_ANGLE_stream_producer_d3d_texture + bool ValidateCreateStreamProducerD3DTextureANGLE(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Stream *streamPacked, + const AttributeMap &attrib_listPacked); + bool ValidateStreamPostD3DTextureANGLE(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Stream *streamPacked, + const void *texture, + const AttributeMap &attrib_listPacked); + + // EGL_ANGLE_swap_with_frame_token + bool ValidateSwapBuffersWithFrameTokenANGLE(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked, + EGLFrameTokenANGLE frametoken); + + // EGL_ANGLE_sync_control_rate + bool ValidateGetMscRateANGLE(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked, + const EGLint *numerator, + const EGLint *denominator); + + // EGL_CHROMIUM_sync_control + bool ValidateGetSyncValuesCHROMIUM(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked, + const EGLuint64KHR *ust, + const EGLuint64KHR *msc, +@@ -319,18 +321,18 @@ bool ValidateQueryDeviceStringEXT(const ValidationContext *val, + const Device *devicePacked, + EGLint name); + bool ValidateQueryDisplayAttribEXT(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + EGLint attribute, + const EGLAttrib *value); + + // EGL_EXT_platform_base + bool ValidateCreatePlatformPixmapSurfaceEXT(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Config *configPacked, + const void *native_pixmap, + const AttributeMap &attrib_listPacked); + bool ValidateCreatePlatformWindowSurfaceEXT(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Config *configPacked, + const void *native_window, + const AttributeMap &attrib_listPacked); +@@ -344,7 +346,7 @@ bool ValidateDebugMessageControlKHR(const ValidationContext *val, + EGLDEBUGPROCKHR callback, + const AttributeMap &attrib_listPacked); + bool ValidateLabelObjectKHR(const ValidationContext *val, +- const Display *displayPacked, ++ const egl::Display *displayPacked, + ObjectType objectTypePacked, + EGLObjectKHR object, + EGLLabelKHR label); +@@ -352,90 +354,90 @@ bool ValidateQueryDebugKHR(const ValidationContext *val, EGLint attribute, const + + // EGL_KHR_fence_sync + bool ValidateClientWaitSyncKHR(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Sync *syncPacked, + EGLint flags, + EGLTimeKHR timeout); + bool ValidateCreateSyncKHR(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + EGLenum type, + const AttributeMap &attrib_listPacked); + bool ValidateDestroySyncKHR(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Sync *syncPacked); + bool ValidateGetSyncAttribKHR(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Sync *syncPacked, + EGLint attribute, + const EGLint *value); + + // EGL_KHR_image + bool ValidateCreateImageKHR(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const gl::Context *ctxPacked, + EGLenum target, + EGLClientBuffer buffer, + const AttributeMap &attrib_listPacked); + bool ValidateDestroyImageKHR(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Image *imagePacked); + + // EGL_KHR_reusable_sync + bool ValidateSignalSyncKHR(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Sync *syncPacked, + EGLenum mode); + + // EGL_KHR_stream + bool ValidateCreateStreamKHR(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const AttributeMap &attrib_listPacked); + bool ValidateDestroyStreamKHR(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Stream *streamPacked); + bool ValidateQueryStreamKHR(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Stream *streamPacked, + EGLenum attribute, + const EGLint *value); + bool ValidateQueryStreamu64KHR(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Stream *streamPacked, + EGLenum attribute, + const EGLuint64KHR *value); + bool ValidateStreamAttribKHR(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Stream *streamPacked, + EGLenum attribute, + EGLint value); + + // EGL_KHR_stream_consumer_gltexture + bool ValidateStreamConsumerAcquireKHR(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Stream *streamPacked); + bool ValidateStreamConsumerGLTextureExternalKHR(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Stream *streamPacked); + bool ValidateStreamConsumerReleaseKHR(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Stream *streamPacked); + + // EGL_KHR_swap_buffers_with_damage + bool ValidateSwapBuffersWithDamageKHR(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked, + const EGLint *rects, + EGLint n_rects); + + // EGL_KHR_wait_sync + bool ValidateWaitSyncKHR(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Sync *syncPacked, + EGLint flags); + + // EGL_NV_post_sub_buffer + bool ValidatePostSubBufferNV(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Surface *surfacePacked, + EGLint x, + EGLint y, +@@ -444,7 +446,7 @@ bool ValidatePostSubBufferNV(const ValidationContext *val, + + // EGL_NV_stream_consumer_gltexture_yuv + bool ValidateStreamConsumerGLTextureExternalAttribsNV(const ValidationContext *val, +- const Display *dpyPacked, ++ const egl::Display *dpyPacked, + const Stream *streamPacked, + const AttributeMap &attrib_listPacked); + } // namespace egl +diff --git a/third_party/angle/src/libGLESv2/egl_ext_stubs_autogen.h b/third_party/angle/src/libGLESv2/egl_ext_stubs_autogen.h +index aecd051d9..404717bde 100644 +--- a/third_party/angle/src/libGLESv2/egl_ext_stubs_autogen.h ++++ b/third_party/angle/src/libGLESv2/egl_ext_stubs_autogen.h +@@ -33,12 +33,12 @@ class Thread; + struct Config; + + EGLint ClientWaitSyncKHR(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Sync *syncPacked, + EGLint flags, + EGLTimeKHR timeout); + EGLImageKHR CreateImageKHR(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + gl::Context *ctxPacked, + EGLenum target, + EGLClientBuffer buffer, +@@ -46,75 +46,75 @@ EGLImageKHR CreateImageKHR(Thread *thread, + EGLClientBuffer CreateNativeClientBufferANDROID(Thread *thread, + const AttributeMap &attrib_listPacked); + EGLSurface CreatePlatformPixmapSurfaceEXT(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Config *configPacked, + void *native_pixmap, + const AttributeMap &attrib_listPacked); + EGLSurface CreatePlatformWindowSurfaceEXT(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Config *configPacked, + void *native_window, + const AttributeMap &attrib_listPacked); + EGLStreamKHR CreateStreamKHR(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + const AttributeMap &attrib_listPacked); + EGLSyncKHR CreateSyncKHR(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + EGLenum type, + const AttributeMap &attrib_listPacked); + EGLint DebugMessageControlKHR(Thread *thread, + EGLDEBUGPROCKHR callback, + const AttributeMap &attrib_listPacked); +-EGLBoolean DestroyImageKHR(Thread *thread, Display *dpyPacked, Image *imagePacked); +-EGLBoolean DestroyStreamKHR(Thread *thread, Display *dpyPacked, Stream *streamPacked); +-EGLBoolean DestroySyncKHR(Thread *thread, Display *dpyPacked, Sync *syncPacked); +-EGLint DupNativeFenceFDANDROID(Thread *thread, Display *dpyPacked, Sync *syncPacked); ++EGLBoolean DestroyImageKHR(Thread *thread, egl::Display *dpyPacked, Image *imagePacked); ++EGLBoolean DestroyStreamKHR(Thread *thread, egl::Display *dpyPacked, Stream *streamPacked); ++EGLBoolean DestroySyncKHR(Thread *thread, egl::Display *dpyPacked, Sync *syncPacked); ++EGLint DupNativeFenceFDANDROID(Thread *thread, egl::Display *dpyPacked, Sync *syncPacked); + EGLClientBuffer GetNativeClientBufferANDROID(Thread *thread, const struct AHardwareBuffer *buffer); + EGLDisplay GetPlatformDisplayEXT(Thread *thread, + EGLenum platform, + void *native_display, + const AttributeMap &attrib_listPacked); + EGLBoolean GetSyncAttribKHR(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Sync *syncPacked, + EGLint attribute, + EGLint *value); + EGLint LabelObjectKHR(Thread *thread, +- Display *displayPacked, ++ egl::Display *displayPacked, + ObjectType objectTypePacked, + EGLObjectKHR object, + EGLLabelKHR label); + EGLBoolean PostSubBufferNV(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint x, + EGLint y, + EGLint width, + EGLint height); + EGLBoolean PresentationTimeANDROID(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Surface *surfacePacked, + EGLnsecsANDROID time); + EGLBoolean GetCompositorTimingSupportedANDROID(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Surface *surfacePacked, + CompositorTiming namePacked); + EGLBoolean GetCompositorTimingANDROID(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint numTimestamps, + const EGLint *names, + EGLnsecsANDROID *values); + EGLBoolean GetNextFrameIdANDROID(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Surface *surfacePacked, + EGLuint64KHR *frameId); + EGLBoolean GetFrameTimestampSupportedANDROID(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Surface *surfacePacked, + Timestamp timestampPacked); + EGLBoolean GetFrameTimestampsANDROID(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Surface *surfacePacked, + EGLuint64KHR frameId, + EGLint numTimestamps, +@@ -127,99 +127,99 @@ EGLBoolean QueryDeviceAttribEXT(Thread *thread, + EGLAttrib *value); + const char *QueryDeviceStringEXT(Thread *thread, Device *devicePacked, EGLint name); + EGLBoolean QueryDisplayAttribEXT(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + EGLint attribute, + EGLAttrib *value); + EGLBoolean QueryStreamKHR(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Stream *streamPacked, + EGLenum attribute, + EGLint *value); + EGLBoolean QueryStreamu64KHR(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Stream *streamPacked, + EGLenum attribute, + EGLuint64KHR *value); + EGLBoolean QuerySurfacePointerANGLE(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint attribute, + void **value); + void SetBlobCacheFuncsANDROID(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + EGLSetBlobFuncANDROID set, + EGLGetBlobFuncANDROID get); +-EGLBoolean SignalSyncKHR(Thread *thread, Display *dpyPacked, Sync *syncPacked, EGLenum mode); ++EGLBoolean SignalSyncKHR(Thread *thread, egl::Display *dpyPacked, Sync *syncPacked, EGLenum mode); + EGLBoolean StreamAttribKHR(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Stream *streamPacked, + EGLenum attribute, + EGLint value); +-EGLBoolean StreamConsumerAcquireKHR(Thread *thread, Display *dpyPacked, Stream *streamPacked); ++EGLBoolean StreamConsumerAcquireKHR(Thread *thread, egl::Display *dpyPacked, Stream *streamPacked); + EGLBoolean StreamConsumerGLTextureExternalKHR(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Stream *streamPacked); + EGLBoolean StreamConsumerGLTextureExternalAttribsNV(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Stream *streamPacked, + const AttributeMap &attrib_listPacked); +-EGLBoolean StreamConsumerReleaseKHR(Thread *thread, Display *dpyPacked, Stream *streamPacked); ++EGLBoolean StreamConsumerReleaseKHR(Thread *thread, egl::Display *dpyPacked, Stream *streamPacked); + EGLBoolean SwapBuffersWithDamageKHR(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint *rects, + EGLint n_rects); +-EGLint WaitSyncKHR(Thread *thread, Display *dpyPacked, Sync *syncPacked, EGLint flags); ++EGLint WaitSyncKHR(Thread *thread, egl::Display *dpyPacked, Sync *syncPacked, EGLint flags); + EGLDeviceEXT CreateDeviceANGLE(Thread *thread, + EGLint device_type, + void *native_device, + const EGLAttrib *attrib_list); + EGLBoolean ReleaseDeviceANGLE(Thread *thread, Device *devicePacked); + EGLBoolean CreateStreamProducerD3DTextureANGLE(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Stream *streamPacked, + const AttributeMap &attrib_listPacked); + EGLBoolean StreamPostD3DTextureANGLE(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Stream *streamPacked, + void *texture, + const AttributeMap &attrib_listPacked); + EGLBoolean GetMscRateANGLE(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint *numerator, + EGLint *denominator); + EGLBoolean GetSyncValuesCHROMIUM(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Surface *surfacePacked, + EGLuint64KHR *ust, + EGLuint64KHR *msc, + EGLuint64KHR *sbc); +-EGLint ProgramCacheGetAttribANGLE(Thread *thread, Display *dpyPacked, EGLenum attrib); ++EGLint ProgramCacheGetAttribANGLE(Thread *thread, egl::Display *dpyPacked, EGLenum attrib); + void ProgramCacheQueryANGLE(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + EGLint index, + void *key, + EGLint *keysize, + void *binary, + EGLint *binarysize); + void ProgramCachePopulateANGLE(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + const void *key, + EGLint keysize, + const void *binary, + EGLint binarysize); +-EGLint ProgramCacheResizeANGLE(Thread *thread, Display *dpyPacked, EGLint limit, EGLint mode); +-const char *QueryStringiANGLE(Thread *thread, Display *dpyPacked, EGLint name, EGLint index); ++EGLint ProgramCacheResizeANGLE(Thread *thread, egl::Display *dpyPacked, EGLint limit, EGLint mode); ++const char *QueryStringiANGLE(Thread *thread, egl::Display *dpyPacked, EGLint name, EGLint index); + EGLBoolean SwapBuffersWithFrameTokenANGLE(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Surface *surfacePacked, + EGLFrameTokenANGLE frametoken); +-void ReleaseHighPowerGPUANGLE(Thread *thread, Display *dpyPacked, gl::Context *ctxPacked); +-void ReacquireHighPowerGPUANGLE(Thread *thread, Display *dpyPacked, gl::Context *ctxPacked); +-void HandleGPUSwitchANGLE(Thread *thread, Display *dpyPacked); ++void ReleaseHighPowerGPUANGLE(Thread *thread, egl::Display *dpyPacked, gl::Context *ctxPacked); ++void ReacquireHighPowerGPUANGLE(Thread *thread, egl::Display *dpyPacked, gl::Context *ctxPacked); ++void HandleGPUSwitchANGLE(Thread *thread, egl::Display *dpyPacked); + EGLBoolean QueryDisplayAttribANGLE(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + EGLint attribute, + EGLAttrib *value); + } // namespace egl +diff --git a/third_party/angle/src/libGLESv2/egl_stubs_autogen.h b/third_party/angle/src/libGLESv2/egl_stubs_autogen.h +index 9118495ed..6d7d210d9 100644 +--- a/third_party/angle/src/libGLESv2/egl_stubs_autogen.h ++++ b/third_party/angle/src/libGLESv2/egl_stubs_autogen.h +@@ -33,78 +33,81 @@ class Thread; + struct Config; + + EGLBoolean BindAPI(Thread *thread, EGLenum api); +-EGLBoolean BindTexImage(Thread *thread, Display *dpyPacked, Surface *surfacePacked, EGLint buffer); ++EGLBoolean BindTexImage(Thread *thread, ++ egl::Display *dpyPacked, ++ Surface *surfacePacked, ++ EGLint buffer); + EGLBoolean ChooseConfig(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + const AttributeMap &attrib_listPacked, + EGLConfig *configs, + EGLint config_size, + EGLint *num_config); + EGLint ClientWaitSync(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Sync *syncPacked, + EGLint flags, + EGLTime timeout); + EGLBoolean CopyBuffers(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Surface *surfacePacked, + EGLNativePixmapType target); + EGLContext CreateContext(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Config *configPacked, + gl::Context *share_contextPacked, + const AttributeMap &attrib_listPacked); + EGLImage CreateImage(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + gl::Context *ctxPacked, + EGLenum target, + EGLClientBuffer buffer, + const AttributeMap &attrib_listPacked); + EGLSurface CreatePbufferFromClientBuffer(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + EGLenum buftype, + EGLClientBuffer buffer, + Config *configPacked, + const AttributeMap &attrib_listPacked); + EGLSurface CreatePbufferSurface(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Config *configPacked, + const AttributeMap &attrib_listPacked); + EGLSurface CreatePixmapSurface(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Config *configPacked, + EGLNativePixmapType pixmap, + const AttributeMap &attrib_listPacked); + EGLSurface CreatePlatformPixmapSurface(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Config *configPacked, + void *native_pixmap, + const AttributeMap &attrib_listPacked); + EGLSurface CreatePlatformWindowSurface(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Config *configPacked, + void *native_window, + const AttributeMap &attrib_listPacked); + EGLSync CreateSync(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + EGLenum type, + const AttributeMap &attrib_listPacked); + EGLSurface CreateWindowSurface(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Config *configPacked, + EGLNativeWindowType win, + const AttributeMap &attrib_listPacked); +-EGLBoolean DestroyContext(Thread *thread, Display *dpyPacked, gl::Context *ctxPacked); +-EGLBoolean DestroyImage(Thread *thread, Display *dpyPacked, Image *imagePacked); +-EGLBoolean DestroySurface(Thread *thread, Display *dpyPacked, Surface *surfacePacked); +-EGLBoolean DestroySync(Thread *thread, Display *dpyPacked, Sync *syncPacked); ++EGLBoolean DestroyContext(Thread *thread, egl::Display *dpyPacked, gl::Context *ctxPacked); ++EGLBoolean DestroyImage(Thread *thread, egl::Display *dpyPacked, Image *imagePacked); ++EGLBoolean DestroySurface(Thread *thread, egl::Display *dpyPacked, Surface *surfacePacked); ++EGLBoolean DestroySync(Thread *thread, egl::Display *dpyPacked, Sync *syncPacked); + EGLBoolean GetConfigAttrib(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Config *configPacked, + EGLint attribute, + EGLint *value); + EGLBoolean GetConfigs(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + EGLConfig *configs, + EGLint config_size, + EGLint *num_config); +@@ -119,44 +122,44 @@ EGLDisplay GetPlatformDisplay(Thread *thread, + const AttributeMap &attrib_listPacked); + __eglMustCastToProperFunctionPointerType GetProcAddress(Thread *thread, const char *procname); + EGLBoolean GetSyncAttrib(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Sync *syncPacked, + EGLint attribute, + EGLAttrib *value); +-EGLBoolean Initialize(Thread *thread, Display *dpyPacked, EGLint *major, EGLint *minor); ++EGLBoolean Initialize(Thread *thread, egl::Display *dpyPacked, EGLint *major, EGLint *minor); + EGLBoolean MakeCurrent(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Surface *drawPacked, + Surface *readPacked, + gl::Context *ctxPacked); + EGLenum QueryAPI(Thread *thread); + EGLBoolean QueryContext(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + gl::Context *ctxPacked, + EGLint attribute, + EGLint *value); +-const char *QueryString(Thread *thread, Display *dpyPacked, EGLint name); ++const char *QueryString(Thread *thread, egl::Display *dpyPacked, EGLint name); + EGLBoolean QuerySurface(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint attribute, + EGLint *value); + EGLBoolean ReleaseTexImage(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint buffer); + EGLBoolean ReleaseThread(Thread *thread); + EGLBoolean SurfaceAttrib(Thread *thread, +- Display *dpyPacked, ++ egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint attribute, + EGLint value); +-EGLBoolean SwapBuffers(Thread *thread, Display *dpyPacked, Surface *surfacePacked); +-EGLBoolean SwapInterval(Thread *thread, Display *dpyPacked, EGLint interval); +-EGLBoolean Terminate(Thread *thread, Display *dpyPacked); ++EGLBoolean SwapBuffers(Thread *thread, egl::Display *dpyPacked, Surface *surfacePacked); ++EGLBoolean SwapInterval(Thread *thread, egl::Display *dpyPacked, EGLint interval); ++EGLBoolean Terminate(Thread *thread, egl::Display *dpyPacked); + EGLBoolean WaitClient(Thread *thread); + EGLBoolean WaitGL(Thread *thread); + EGLBoolean WaitNative(Thread *thread, EGLint engine); +-EGLBoolean WaitSync(Thread *thread, Display *dpyPacked, Sync *syncPacked, EGLint flags); ++EGLBoolean WaitSync(Thread *thread, egl::Display *dpyPacked, Sync *syncPacked, EGLint flags); + } // namespace egl + #endif // LIBGLESV2_EGL_STUBS_AUTOGEN_H_ +diff --git a/third_party/angle/src/libGLESv2/entry_points_egl_autogen.cpp b/third_party/angle/src/libGLESv2/entry_points_egl_autogen.cpp +index 3e127ee9d..7671cc7ab 100644 +--- a/third_party/angle/src/libGLESv2/entry_points_egl_autogen.cpp ++++ b/third_party/angle/src/libGLESv2/entry_points_egl_autogen.cpp +@@ -35,7 +35,7 @@ EGLBoolean EGLAPIENTRY EGL_ChooseConfig(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); + + ANGLE_EGL_VALIDATE(thread, ChooseConfig, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, +@@ -55,8 +55,8 @@ EGLBoolean EGLAPIENTRY EGL_CopyBuffers(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *surfacePacked = PackParam(surface); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *surfacePacked = PackParam(surface); + + ANGLE_EGL_VALIDATE(thread, CopyBuffers, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked, target); +@@ -77,7 +77,7 @@ EGLContext EGLAPIENTRY EGL_CreateContext(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + Config *configPacked = PackParam(config); + gl::Context *share_contextPacked = PackParam(share_context); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); +@@ -100,7 +100,7 @@ EGLSurface EGLAPIENTRY EGL_CreatePbufferSurface(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + Config *configPacked = PackParam(config); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); + +@@ -123,7 +123,7 @@ EGLSurface EGLAPIENTRY EGL_CreatePixmapSurface(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + Config *configPacked = PackParam(config); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); + +@@ -146,7 +146,7 @@ EGLSurface EGLAPIENTRY EGL_CreateWindowSurface(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + Config *configPacked = PackParam(config); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); + +@@ -164,8 +164,8 @@ EGLBoolean EGLAPIENTRY EGL_DestroyContext(EGLDisplay dpy, EGLContext ctx) + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- gl::Context *ctxPacked = PackParam(ctx); ++ egl::Display *dpyPacked = PackParam(dpy); ++ gl::Context *ctxPacked = PackParam(ctx); + + ANGLE_EGL_VALIDATE(thread, DestroyContext, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + ctxPacked); +@@ -181,8 +181,8 @@ EGLBoolean EGLAPIENTRY EGL_DestroySurface(EGLDisplay dpy, EGLSurface surface) + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *surfacePacked = PackParam(surface); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *surfacePacked = PackParam(surface); + + ANGLE_EGL_VALIDATE(thread, DestroySurface, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked); +@@ -203,8 +203,8 @@ EGLBoolean EGLAPIENTRY EGL_GetConfigAttrib(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Config *configPacked = PackParam(config); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Config *configPacked = PackParam(config); + + ANGLE_EGL_VALIDATE(thread, GetConfigAttrib, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + configPacked, attribute, value); +@@ -225,7 +225,7 @@ EGLBoolean EGLAPIENTRY EGL_GetConfigs(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + + ANGLE_EGL_VALIDATE(thread, GetConfigs, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + configs, config_size, num_config); +@@ -303,7 +303,7 @@ EGLBoolean EGLAPIENTRY EGL_Initialize(EGLDisplay dpy, EGLint *major, EGLint *min + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + + ANGLE_EGL_VALIDATE(thread, Initialize, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + major, minor); +@@ -324,10 +324,10 @@ EGLBoolean EGLAPIENTRY EGL_MakeCurrent(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *drawPacked = PackParam(draw); +- Surface *readPacked = PackParam(read); +- gl::Context *ctxPacked = PackParam(ctx); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *drawPacked = PackParam(draw); ++ Surface *readPacked = PackParam(read); ++ gl::Context *ctxPacked = PackParam(ctx); + + ANGLE_EGL_VALIDATE(thread, MakeCurrent, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + drawPacked, readPacked, ctxPacked); +@@ -348,8 +348,8 @@ EGLBoolean EGLAPIENTRY EGL_QueryContext(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- gl::Context *ctxPacked = PackParam(ctx); ++ egl::Display *dpyPacked = PackParam(dpy); ++ gl::Context *ctxPacked = PackParam(ctx); + + ANGLE_EGL_VALIDATE(thread, QueryContext, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + ctxPacked, attribute, value); +@@ -364,7 +364,7 @@ const char *EGLAPIENTRY EGL_QueryString(EGLDisplay dpy, EGLint name) + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + + ANGLE_EGL_VALIDATE(thread, QueryString, GetDisplayIfValid(dpyPacked), const char *, dpyPacked, + name); +@@ -385,8 +385,8 @@ EGLBoolean EGLAPIENTRY EGL_QuerySurface(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *surfacePacked = PackParam(surface); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *surfacePacked = PackParam(surface); + + ANGLE_EGL_VALIDATE(thread, QuerySurface, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked, attribute, value); +@@ -402,8 +402,8 @@ EGLBoolean EGLAPIENTRY EGL_SwapBuffers(EGLDisplay dpy, EGLSurface surface) + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *surfacePacked = PackParam(surface); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *surfacePacked = PackParam(surface); + + ANGLE_EGL_VALIDATE(thread, SwapBuffers, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked); +@@ -418,7 +418,7 @@ EGLBoolean EGLAPIENTRY EGL_Terminate(EGLDisplay dpy) + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + + ANGLE_EGL_VALIDATE(thread, Terminate, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked); + +@@ -458,8 +458,8 @@ EGLBoolean EGLAPIENTRY EGL_BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLi + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *surfacePacked = PackParam(surface); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *surfacePacked = PackParam(surface); + + ANGLE_EGL_VALIDATE(thread, BindTexImage, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked, buffer); +@@ -475,8 +475,8 @@ EGLBoolean EGLAPIENTRY EGL_ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, E + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *surfacePacked = PackParam(surface); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *surfacePacked = PackParam(surface); + + ANGLE_EGL_VALIDATE(thread, ReleaseTexImage, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked, buffer); +@@ -496,8 +496,8 @@ EGLBoolean EGLAPIENTRY EGL_SurfaceAttrib(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *surfacePacked = PackParam(surface); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *surfacePacked = PackParam(surface); + + ANGLE_EGL_VALIDATE(thread, SurfaceAttrib, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked, attribute, value); +@@ -512,7 +512,7 @@ EGLBoolean EGLAPIENTRY EGL_SwapInterval(EGLDisplay dpy, EGLint interval) + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + + ANGLE_EGL_VALIDATE(thread, SwapInterval, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + interval); +@@ -548,7 +548,7 @@ EGLSurface EGLAPIENTRY EGL_CreatePbufferFromClientBuffer(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + Config *configPacked = PackParam(config); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); + +@@ -618,8 +618,8 @@ EGLint EGLAPIENTRY EGL_ClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Sync *syncPacked = PackParam(sync); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Sync *syncPacked = PackParam(sync); + + ANGLE_EGL_VALIDATE(thread, ClientWaitSync, GetDisplayIfValid(dpyPacked), EGLint, dpyPacked, + syncPacked, flags, timeout); +@@ -641,7 +641,7 @@ EGLImage EGLAPIENTRY EGL_CreateImage(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + gl::Context *ctxPacked = PackParam(ctx); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); + +@@ -664,7 +664,7 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurface(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + Config *configPacked = PackParam(config); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); + +@@ -688,7 +688,7 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurface(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + Config *configPacked = PackParam(config); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); + +@@ -707,7 +707,7 @@ EGLSync EGLAPIENTRY EGL_CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreateSync, GetDisplayIfValid(dpyPacked), EGLSync, dpyPacked, type, +@@ -724,8 +724,8 @@ EGLBoolean EGLAPIENTRY EGL_DestroyImage(EGLDisplay dpy, EGLImage image) + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Image *imagePacked = PackParam(image); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Image *imagePacked = PackParam(image); + + ANGLE_EGL_VALIDATE(thread, DestroyImage, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + imagePacked); +@@ -741,8 +741,8 @@ EGLBoolean EGLAPIENTRY EGL_DestroySync(EGLDisplay dpy, EGLSync sync) + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Sync *syncPacked = PackParam(sync); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Sync *syncPacked = PackParam(sync); + + ANGLE_EGL_VALIDATE(thread, DestroySync, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + syncPacked); +@@ -783,8 +783,8 @@ EGLBoolean EGLAPIENTRY EGL_GetSyncAttrib(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Sync *syncPacked = PackParam(sync); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Sync *syncPacked = PackParam(sync); + + ANGLE_EGL_VALIDATE(thread, GetSyncAttrib, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + syncPacked, attribute, value); +@@ -800,8 +800,8 @@ EGLBoolean EGLAPIENTRY EGL_WaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags) + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Sync *syncPacked = PackParam(sync); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Sync *syncPacked = PackParam(sync); + + ANGLE_EGL_VALIDATE(thread, WaitSync, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + syncPacked, flags); +diff --git a/third_party/angle/src/libGLESv2/entry_points_egl_ext_autogen.cpp b/third_party/angle/src/libGLESv2/entry_points_egl_ext_autogen.cpp +index d9f4b76ea..76fcf8c17 100644 +--- a/third_party/angle/src/libGLESv2/entry_points_egl_ext_autogen.cpp ++++ b/third_party/angle/src/libGLESv2/entry_points_egl_ext_autogen.cpp +@@ -31,7 +31,7 @@ void EGLAPIENTRY EGL_SetBlobCacheFuncsANDROID(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + + ANGLE_EGL_VALIDATE_VOID(thread, SetBlobCacheFuncsANDROID, GetDisplayIfValid(dpyPacked), + dpyPacked, set, get); +@@ -68,7 +68,7 @@ EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingSupportedANDROID(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + Surface *surfacePacked = PackParam(surface); + CompositorTiming namePacked = PackParam(name); + +@@ -93,8 +93,8 @@ EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingANDROID(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *surfacePacked = PackParam(surface); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *surfacePacked = PackParam(surface); + + ANGLE_EGL_VALIDATE(thread, GetCompositorTimingANDROID, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, surfacePacked, numTimestamps, names, values); +@@ -114,8 +114,8 @@ EGLBoolean EGLAPIENTRY EGL_GetNextFrameIdANDROID(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *surfacePacked = PackParam(surface); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *surfacePacked = PackParam(surface); + + ANGLE_EGL_VALIDATE(thread, GetNextFrameIdANDROID, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, surfacePacked, frameId); +@@ -134,7 +134,7 @@ EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampSupportedANDROID(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + Surface *surfacePacked = PackParam(surface); + Timestamp timestampPacked = PackParam(timestamp); + +@@ -161,8 +161,8 @@ EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampsANDROID(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *surfacePacked = PackParam(surface); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *surfacePacked = PackParam(surface); + + ANGLE_EGL_VALIDATE(thread, GetFrameTimestampsANDROID, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, surfacePacked, frameId, numTimestamps, timestamps, values); +@@ -193,8 +193,8 @@ EGLint EGLAPIENTRY EGL_DupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync) + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Sync *syncPacked = PackParam(sync); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Sync *syncPacked = PackParam(sync); + + ANGLE_EGL_VALIDATE(thread, DupNativeFenceFDANDROID, GetDisplayIfValid(dpyPacked), EGLint, + dpyPacked, syncPacked); +@@ -214,8 +214,8 @@ EGLBoolean EGLAPIENTRY EGL_PresentationTimeANDROID(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *surfacePacked = PackParam(surface); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *surfacePacked = PackParam(surface); + + ANGLE_EGL_VALIDATE(thread, PresentationTimeANDROID, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, surfacePacked, time); +@@ -265,7 +265,7 @@ const char *EGLAPIENTRY EGL_QueryStringiANGLE(EGLDisplay dpy, EGLint name, EGLin + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + + ANGLE_EGL_VALIDATE(thread, QueryStringiANGLE, GetDisplayIfValid(dpyPacked), const char *, + dpyPacked, name, index); +@@ -284,7 +284,7 @@ EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribANGLE(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + + ANGLE_EGL_VALIDATE(thread, QueryDisplayAttribANGLE, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, attribute, value); +@@ -301,8 +301,8 @@ void EGLAPIENTRY EGL_ReleaseHighPowerGPUANGLE(EGLDisplay dpy, EGLContext ctx) + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- gl::Context *ctxPacked = PackParam(ctx); ++ egl::Display *dpyPacked = PackParam(dpy); ++ gl::Context *ctxPacked = PackParam(ctx); + + ANGLE_EGL_VALIDATE_VOID(thread, ReleaseHighPowerGPUANGLE, GetDisplayIfValid(dpyPacked), + dpyPacked, ctxPacked); +@@ -318,8 +318,8 @@ void EGLAPIENTRY EGL_ReacquireHighPowerGPUANGLE(EGLDisplay dpy, EGLContext ctx) + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- gl::Context *ctxPacked = PackParam(ctx); ++ egl::Display *dpyPacked = PackParam(dpy); ++ gl::Context *ctxPacked = PackParam(ctx); + + ANGLE_EGL_VALIDATE_VOID(thread, ReacquireHighPowerGPUANGLE, GetDisplayIfValid(dpyPacked), + dpyPacked, ctxPacked); +@@ -334,7 +334,7 @@ void EGLAPIENTRY EGL_HandleGPUSwitchANGLE(EGLDisplay dpy) + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + + ANGLE_EGL_VALIDATE_VOID(thread, HandleGPUSwitchANGLE, GetDisplayIfValid(dpyPacked), dpyPacked); + +@@ -350,7 +350,7 @@ EGLint EGLAPIENTRY EGL_ProgramCacheGetAttribANGLE(EGLDisplay dpy, EGLenum attrib + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + + ANGLE_EGL_VALIDATE(thread, ProgramCacheGetAttribANGLE, GetDisplayIfValid(dpyPacked), EGLint, + dpyPacked, attrib); +@@ -375,7 +375,7 @@ void EGLAPIENTRY EGL_ProgramCacheQueryANGLE(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + + ANGLE_EGL_VALIDATE_VOID(thread, ProgramCacheQueryANGLE, GetDisplayIfValid(dpyPacked), dpyPacked, + index, key, keysize, binary, binarysize); +@@ -397,7 +397,7 @@ void EGLAPIENTRY EGL_ProgramCachePopulateANGLE(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + + ANGLE_EGL_VALIDATE_VOID(thread, ProgramCachePopulateANGLE, GetDisplayIfValid(dpyPacked), + dpyPacked, key, keysize, binary, binarysize); +@@ -413,7 +413,7 @@ EGLint EGLAPIENTRY EGL_ProgramCacheResizeANGLE(EGLDisplay dpy, EGLint limit, EGL + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + + ANGLE_EGL_VALIDATE(thread, ProgramCacheResizeANGLE, GetDisplayIfValid(dpyPacked), EGLint, + dpyPacked, limit, mode); +@@ -435,8 +435,8 @@ EGLBoolean EGLAPIENTRY EGL_QuerySurfacePointerANGLE(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *surfacePacked = PackParam(surface); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *surfacePacked = PackParam(surface); + + ANGLE_EGL_VALIDATE(thread, QuerySurfacePointerANGLE, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, surfacePacked, attribute, value); +@@ -457,7 +457,7 @@ EGLBoolean EGLAPIENTRY EGL_CreateStreamProducerD3DTextureANGLE(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + Stream *streamPacked = PackParam(stream); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); + +@@ -480,7 +480,7 @@ EGLBoolean EGLAPIENTRY EGL_StreamPostD3DTextureANGLE(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + Stream *streamPacked = PackParam(stream); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); + +@@ -502,8 +502,8 @@ EGLBoolean EGLAPIENTRY EGL_SwapBuffersWithFrameTokenANGLE(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *surfacePacked = PackParam(surface); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *surfacePacked = PackParam(surface); + + ANGLE_EGL_VALIDATE(thread, SwapBuffersWithFrameTokenANGLE, GetDisplayIfValid(dpyPacked), + EGLBoolean, dpyPacked, surfacePacked, frametoken); +@@ -525,8 +525,8 @@ EGLBoolean EGLAPIENTRY EGL_GetMscRateANGLE(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *surfacePacked = PackParam(surface); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *surfacePacked = PackParam(surface); + + ANGLE_EGL_VALIDATE(thread, GetMscRateANGLE, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked, numerator, denominator); +@@ -549,8 +549,8 @@ EGLBoolean EGLAPIENTRY EGL_GetSyncValuesCHROMIUM(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *surfacePacked = PackParam(surface); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *surfacePacked = PackParam(surface); + + ANGLE_EGL_VALIDATE(thread, GetSyncValuesCHROMIUM, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, surfacePacked, ust, msc, sbc); +@@ -602,7 +602,7 @@ EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribut + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + + ANGLE_EGL_VALIDATE(thread, QueryDisplayAttribEXT, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, attribute, value); +@@ -624,7 +624,7 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurfaceEXT(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + Config *configPacked = PackParam(config); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); + +@@ -648,7 +648,7 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurfaceEXT(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + Config *configPacked = PackParam(config); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); + +@@ -711,7 +711,7 @@ EGLint EGLAPIENTRY EGL_LabelObjectKHR(EGLDisplay display, + + Thread *thread = egl::GetCurrentThread(); + +- Display *displayPacked = PackParam(display); ++ egl::Display *displayPacked = PackParam(display); + ObjectType objectTypePacked = PackParam(objectType); + + ANGLE_EGL_VALIDATE(thread, LabelObjectKHR, GetDisplayIfValid(displayPacked), EGLint, +@@ -746,8 +746,8 @@ EGLint EGLAPIENTRY EGL_ClientWaitSyncKHR(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Sync *syncPacked = PackParam(sync); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Sync *syncPacked = PackParam(sync); + + ANGLE_EGL_VALIDATE(thread, ClientWaitSyncKHR, GetDisplayIfValid(dpyPacked), EGLint, dpyPacked, + syncPacked, flags, timeout); +@@ -764,7 +764,7 @@ EGLSyncKHR EGLAPIENTRY EGL_CreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGL + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreateSyncKHR, GetDisplayIfValid(dpyPacked), EGLSyncKHR, dpyPacked, +@@ -781,8 +781,8 @@ EGLBoolean EGLAPIENTRY EGL_DestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync) + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Sync *syncPacked = PackParam(sync); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Sync *syncPacked = PackParam(sync); + + ANGLE_EGL_VALIDATE(thread, DestroySyncKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + syncPacked); +@@ -803,8 +803,8 @@ EGLBoolean EGLAPIENTRY EGL_GetSyncAttribKHR(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Sync *syncPacked = PackParam(sync); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Sync *syncPacked = PackParam(sync); + + ANGLE_EGL_VALIDATE(thread, GetSyncAttribKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, syncPacked, attribute, value); +@@ -827,7 +827,7 @@ EGLImageKHR EGLAPIENTRY EGL_CreateImageKHR(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + gl::Context *ctxPacked = PackParam(ctx); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); + +@@ -845,8 +845,8 @@ EGLBoolean EGLAPIENTRY EGL_DestroyImageKHR(EGLDisplay dpy, EGLImageKHR image) + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Image *imagePacked = PackParam(image); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Image *imagePacked = PackParam(image); + + ANGLE_EGL_VALIDATE(thread, DestroyImageKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + imagePacked); +@@ -863,8 +863,8 @@ EGLBoolean EGLAPIENTRY EGL_SignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenu + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Sync *syncPacked = PackParam(sync); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Sync *syncPacked = PackParam(sync); + + ANGLE_EGL_VALIDATE(thread, SignalSyncKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + syncPacked, mode); +@@ -889,7 +889,7 @@ EGLStreamKHR EGLAPIENTRY EGL_CreateStreamKHR(EGLDisplay dpy, const EGLint *attri + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreateStreamKHR, GetDisplayIfValid(dpyPacked), EGLStreamKHR, +@@ -906,8 +906,8 @@ EGLBoolean EGLAPIENTRY EGL_DestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream) + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Stream *streamPacked = PackParam(stream); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Stream *streamPacked = PackParam(stream); + + ANGLE_EGL_VALIDATE(thread, DestroyStreamKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, streamPacked); +@@ -928,8 +928,8 @@ EGLBoolean EGLAPIENTRY EGL_QueryStreamKHR(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Stream *streamPacked = PackParam(stream); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Stream *streamPacked = PackParam(stream); + + ANGLE_EGL_VALIDATE(thread, QueryStreamKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + streamPacked, attribute, value); +@@ -950,8 +950,8 @@ EGLBoolean EGLAPIENTRY EGL_QueryStreamu64KHR(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Stream *streamPacked = PackParam(stream); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Stream *streamPacked = PackParam(stream); + + ANGLE_EGL_VALIDATE(thread, QueryStreamu64KHR, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, streamPacked, attribute, value); +@@ -971,8 +971,8 @@ EGLBoolean EGLAPIENTRY EGL_StreamAttribKHR(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Stream *streamPacked = PackParam(stream); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Stream *streamPacked = PackParam(stream); + + ANGLE_EGL_VALIDATE(thread, StreamAttribKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + streamPacked, attribute, value); +@@ -989,8 +989,8 @@ EGLBoolean EGLAPIENTRY EGL_StreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Stream *streamPacked = PackParam(stream); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Stream *streamPacked = PackParam(stream); + + ANGLE_EGL_VALIDATE(thread, StreamConsumerAcquireKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, streamPacked); +@@ -1007,8 +1007,8 @@ EGLBoolean EGLAPIENTRY EGL_StreamConsumerGLTextureExternalKHR(EGLDisplay dpy, EG + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Stream *streamPacked = PackParam(stream); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Stream *streamPacked = PackParam(stream); + + ANGLE_EGL_VALIDATE(thread, StreamConsumerGLTextureExternalKHR, GetDisplayIfValid(dpyPacked), + EGLBoolean, dpyPacked, streamPacked); +@@ -1024,8 +1024,8 @@ EGLBoolean EGLAPIENTRY EGL_StreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Stream *streamPacked = PackParam(stream); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Stream *streamPacked = PackParam(stream); + + ANGLE_EGL_VALIDATE(thread, StreamConsumerReleaseKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, streamPacked); +@@ -1047,8 +1047,8 @@ EGLBoolean EGLAPIENTRY EGL_SwapBuffersWithDamageKHR(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *surfacePacked = PackParam(surface); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *surfacePacked = PackParam(surface); + + ANGLE_EGL_VALIDATE(thread, SwapBuffersWithDamageKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, surfacePacked, rects, n_rects); +@@ -1065,8 +1065,8 @@ EGLint EGLAPIENTRY EGL_WaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Sync *syncPacked = PackParam(sync); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Sync *syncPacked = PackParam(sync); + + ANGLE_EGL_VALIDATE(thread, WaitSyncKHR, GetDisplayIfValid(dpyPacked), EGLint, dpyPacked, + syncPacked, flags); +@@ -1090,8 +1090,8 @@ EGLBoolean EGLAPIENTRY EGL_PostSubBufferNV(EGLDisplay dpy, + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); +- Surface *surfacePacked = PackParam(surface); ++ egl::Display *dpyPacked = PackParam(dpy); ++ Surface *surfacePacked = PackParam(surface); + + ANGLE_EGL_VALIDATE(thread, PostSubBufferNV, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked, x, y, width, height); +@@ -1112,7 +1112,7 @@ EGLBoolean EGLAPIENTRY EGL_StreamConsumerGLTextureExternalAttribsNV(EGLDisplay d + + Thread *thread = egl::GetCurrentThread(); + +- Display *dpyPacked = PackParam(dpy); ++ egl::Display *dpyPacked = PackParam(dpy); + Stream *streamPacked = PackParam(stream); + const AttributeMap &attrib_listPacked = PackParam(attrib_list); + -- cgit v1.2.3