path: root/www-client/chromium/files/chromium-89-angle-display.patch

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<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(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<Display *>(dpy);
-    Surface *surfacePacked = PackParam<Surface *>(surface);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *surfacePacked  = PackParam<Surface *>(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<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     Config *configPacked                  = PackParam<Config *>(config);
     gl::Context *share_contextPacked      = PackParam<gl::Context *>(share_context);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list);
@@ -100,7 +100,7 @@ EGLSurface EGLAPIENTRY EGL_CreatePbufferSurface(EGLDisplay dpy,
 
     Thread *thread = egl::GetCurrentThread();
 
-    Display *dpyPacked                    = PackParam<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     Config *configPacked                  = PackParam<Config *>(config);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list);
 
@@ -123,7 +123,7 @@ EGLSurface EGLAPIENTRY EGL_CreatePixmapSurface(EGLDisplay dpy,
 
     Thread *thread = egl::GetCurrentThread();
 
-    Display *dpyPacked                    = PackParam<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     Config *configPacked                  = PackParam<Config *>(config);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list);
 
@@ -146,7 +146,7 @@ EGLSurface EGLAPIENTRY EGL_CreateWindowSurface(EGLDisplay dpy,
 
     Thread *thread = egl::GetCurrentThread();
 
-    Display *dpyPacked                    = PackParam<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     Config *configPacked                  = PackParam<Config *>(config);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list);
 
@@ -164,8 +164,8 @@ EGLBoolean EGLAPIENTRY EGL_DestroyContext(EGLDisplay dpy, EGLContext ctx)
 
     Thread *thread = egl::GetCurrentThread();
 
-    Display *dpyPacked     = PackParam<Display *>(dpy);
-    gl::Context *ctxPacked = PackParam<gl::Context *>(ctx);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    gl::Context *ctxPacked  = PackParam<gl::Context *>(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<Display *>(dpy);
-    Surface *surfacePacked = PackParam<Surface *>(surface);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *surfacePacked  = PackParam<Surface *>(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<Display *>(dpy);
-    Config *configPacked = PackParam<Config *>(config);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Config *configPacked    = PackParam<Config *>(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<Display *>(dpy);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(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<Display *>(dpy);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(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<Display *>(dpy);
-    Surface *drawPacked    = PackParam<Surface *>(draw);
-    Surface *readPacked    = PackParam<Surface *>(read);
-    gl::Context *ctxPacked = PackParam<gl::Context *>(ctx);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *drawPacked     = PackParam<Surface *>(draw);
+    Surface *readPacked     = PackParam<Surface *>(read);
+    gl::Context *ctxPacked  = PackParam<gl::Context *>(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<Display *>(dpy);
-    gl::Context *ctxPacked = PackParam<gl::Context *>(ctx);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    gl::Context *ctxPacked  = PackParam<gl::Context *>(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<Display *>(dpy);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(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<Display *>(dpy);
-    Surface *surfacePacked = PackParam<Surface *>(surface);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *surfacePacked  = PackParam<Surface *>(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<Display *>(dpy);
-    Surface *surfacePacked = PackParam<Surface *>(surface);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *surfacePacked  = PackParam<Surface *>(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<Display *>(dpy);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(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<Display *>(dpy);
-    Surface *surfacePacked = PackParam<Surface *>(surface);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *surfacePacked  = PackParam<Surface *>(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<Display *>(dpy);
-    Surface *surfacePacked = PackParam<Surface *>(surface);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *surfacePacked  = PackParam<Surface *>(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<Display *>(dpy);
-    Surface *surfacePacked = PackParam<Surface *>(surface);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *surfacePacked  = PackParam<Surface *>(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<Display *>(dpy);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(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<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     Config *configPacked                  = PackParam<Config *>(config);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list);
 
@@ -618,8 +618,8 @@ EGLint EGLAPIENTRY EGL_ClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags
 
     Thread *thread = egl::GetCurrentThread();
 
-    Display *dpyPacked = PackParam<Display *>(dpy);
-    Sync *syncPacked   = PackParam<Sync *>(sync);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Sync *syncPacked        = PackParam<Sync *>(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<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     gl::Context *ctxPacked                = PackParam<gl::Context *>(ctx);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list);
 
@@ -664,7 +664,7 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurface(EGLDisplay dpy,
 
     Thread *thread = egl::GetCurrentThread();
 
-    Display *dpyPacked                    = PackParam<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     Config *configPacked                  = PackParam<Config *>(config);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list);
 
@@ -688,7 +688,7 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurface(EGLDisplay dpy,
 
     Thread *thread = egl::GetCurrentThread();
 
-    Display *dpyPacked                    = PackParam<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     Config *configPacked                  = PackParam<Config *>(config);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list);
 
@@ -707,7 +707,7 @@ EGLSync EGLAPIENTRY EGL_CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib
 
     Thread *thread = egl::GetCurrentThread();
 
-    Display *dpyPacked                    = PackParam<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(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<Display *>(dpy);
-    Image *imagePacked = PackParam<Image *>(image);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Image *imagePacked      = PackParam<Image *>(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<Display *>(dpy);
-    Sync *syncPacked   = PackParam<Sync *>(sync);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Sync *syncPacked        = PackParam<Sync *>(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<Display *>(dpy);
-    Sync *syncPacked   = PackParam<Sync *>(sync);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Sync *syncPacked        = PackParam<Sync *>(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<Display *>(dpy);
-    Sync *syncPacked   = PackParam<Sync *>(sync);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Sync *syncPacked        = PackParam<Sync *>(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<Display *>(dpy);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(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<Display *>(dpy);
+    egl::Display *dpyPacked     = PackParam<egl::Display *>(dpy);
     Surface *surfacePacked      = PackParam<Surface *>(surface);
     CompositorTiming namePacked = PackParam<CompositorTiming>(name);
 
@@ -93,8 +93,8 @@ EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingANDROID(EGLDisplay dpy,
 
     Thread *thread = egl::GetCurrentThread();
 
-    Display *dpyPacked     = PackParam<Display *>(dpy);
-    Surface *surfacePacked = PackParam<Surface *>(surface);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *surfacePacked  = PackParam<Surface *>(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<Display *>(dpy);
-    Surface *surfacePacked = PackParam<Surface *>(surface);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *surfacePacked  = PackParam<Surface *>(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<Display *>(dpy);
+    egl::Display *dpyPacked   = PackParam<egl::Display *>(dpy);
     Surface *surfacePacked    = PackParam<Surface *>(surface);
     Timestamp timestampPacked = PackParam<Timestamp>(timestamp);
 
@@ -161,8 +161,8 @@ EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampsANDROID(EGLDisplay dpy,
 
     Thread *thread = egl::GetCurrentThread();
 
-    Display *dpyPacked     = PackParam<Display *>(dpy);
-    Surface *surfacePacked = PackParam<Surface *>(surface);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *surfacePacked  = PackParam<Surface *>(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<Display *>(dpy);
-    Sync *syncPacked   = PackParam<Sync *>(sync);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Sync *syncPacked        = PackParam<Sync *>(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<Display *>(dpy);
-    Surface *surfacePacked = PackParam<Surface *>(surface);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *surfacePacked  = PackParam<Surface *>(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<Display *>(dpy);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(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<Display *>(dpy);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(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<Display *>(dpy);
-    gl::Context *ctxPacked = PackParam<gl::Context *>(ctx);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    gl::Context *ctxPacked  = PackParam<gl::Context *>(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<Display *>(dpy);
-    gl::Context *ctxPacked = PackParam<gl::Context *>(ctx);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    gl::Context *ctxPacked  = PackParam<gl::Context *>(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<Display *>(dpy);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(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<Display *>(dpy);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(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<Display *>(dpy);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(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<Display *>(dpy);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(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<Display *>(dpy);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(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<Display *>(dpy);
-    Surface *surfacePacked = PackParam<Surface *>(surface);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *surfacePacked  = PackParam<Surface *>(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<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     Stream *streamPacked                  = PackParam<Stream *>(stream);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list);
 
@@ -480,7 +480,7 @@ EGLBoolean EGLAPIENTRY EGL_StreamPostD3DTextureANGLE(EGLDisplay dpy,
 
     Thread *thread = egl::GetCurrentThread();
 
-    Display *dpyPacked                    = PackParam<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     Stream *streamPacked                  = PackParam<Stream *>(stream);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list);
 
@@ -502,8 +502,8 @@ EGLBoolean EGLAPIENTRY EGL_SwapBuffersWithFrameTokenANGLE(EGLDisplay dpy,
 
     Thread *thread = egl::GetCurrentThread();
 
-    Display *dpyPacked     = PackParam<Display *>(dpy);
-    Surface *surfacePacked = PackParam<Surface *>(surface);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *surfacePacked  = PackParam<Surface *>(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<Display *>(dpy);
-    Surface *surfacePacked = PackParam<Surface *>(surface);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *surfacePacked  = PackParam<Surface *>(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<Display *>(dpy);
-    Surface *surfacePacked = PackParam<Surface *>(surface);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *surfacePacked  = PackParam<Surface *>(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<Display *>(dpy);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(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<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     Config *configPacked                  = PackParam<Config *>(config);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list);
 
@@ -648,7 +648,7 @@ EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurfaceEXT(EGLDisplay dpy,
 
     Thread *thread = egl::GetCurrentThread();
 
-    Display *dpyPacked                    = PackParam<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     Config *configPacked                  = PackParam<Config *>(config);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list);
 
@@ -711,7 +711,7 @@ EGLint EGLAPIENTRY EGL_LabelObjectKHR(EGLDisplay display,
 
     Thread *thread = egl::GetCurrentThread();
 
-    Display *displayPacked      = PackParam<Display *>(display);
+    egl::Display *displayPacked = PackParam<egl::Display *>(display);
     ObjectType objectTypePacked = PackParam<ObjectType>(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<Display *>(dpy);
-    Sync *syncPacked   = PackParam<Sync *>(sync);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Sync *syncPacked        = PackParam<Sync *>(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<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(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<Display *>(dpy);
-    Sync *syncPacked   = PackParam<Sync *>(sync);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Sync *syncPacked        = PackParam<Sync *>(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<Display *>(dpy);
-    Sync *syncPacked   = PackParam<Sync *>(sync);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Sync *syncPacked        = PackParam<Sync *>(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<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     gl::Context *ctxPacked                = PackParam<gl::Context *>(ctx);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list);
 
@@ -845,8 +845,8 @@ EGLBoolean EGLAPIENTRY EGL_DestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
 
     Thread *thread = egl::GetCurrentThread();
 
-    Display *dpyPacked = PackParam<Display *>(dpy);
-    Image *imagePacked = PackParam<Image *>(image);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Image *imagePacked      = PackParam<Image *>(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<Display *>(dpy);
-    Sync *syncPacked   = PackParam<Sync *>(sync);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Sync *syncPacked        = PackParam<Sync *>(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<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(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<Display *>(dpy);
-    Stream *streamPacked = PackParam<Stream *>(stream);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Stream *streamPacked    = PackParam<Stream *>(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<Display *>(dpy);
-    Stream *streamPacked = PackParam<Stream *>(stream);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Stream *streamPacked    = PackParam<Stream *>(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<Display *>(dpy);
-    Stream *streamPacked = PackParam<Stream *>(stream);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Stream *streamPacked    = PackParam<Stream *>(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<Display *>(dpy);
-    Stream *streamPacked = PackParam<Stream *>(stream);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Stream *streamPacked    = PackParam<Stream *>(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<Display *>(dpy);
-    Stream *streamPacked = PackParam<Stream *>(stream);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Stream *streamPacked    = PackParam<Stream *>(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<Display *>(dpy);
-    Stream *streamPacked = PackParam<Stream *>(stream);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Stream *streamPacked    = PackParam<Stream *>(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<Display *>(dpy);
-    Stream *streamPacked = PackParam<Stream *>(stream);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Stream *streamPacked    = PackParam<Stream *>(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<Display *>(dpy);
-    Surface *surfacePacked = PackParam<Surface *>(surface);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *surfacePacked  = PackParam<Surface *>(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<Display *>(dpy);
-    Sync *syncPacked   = PackParam<Sync *>(sync);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Sync *syncPacked        = PackParam<Sync *>(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<Display *>(dpy);
-    Surface *surfacePacked = PackParam<Surface *>(surface);
+    egl::Display *dpyPacked = PackParam<egl::Display *>(dpy);
+    Surface *surfacePacked  = PackParam<Surface *>(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<Display *>(dpy);
+    egl::Display *dpyPacked               = PackParam<egl::Display *>(dpy);
     Stream *streamPacked                  = PackParam<Stream *>(stream);
     const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list);