chromium/third_party/angle/src/libANGLE/capture/capture_egl_autogen.cpp

// GENERATED FILE - DO NOT EDIT.
// Generated by generate_entry_points.py using data from egl.xml and egl_angle_ext.xml.
//
// Copyright 2020 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// capture_egl_autogen.cpp:
//   Capture functions for the OpenGL ES all entry points.

#include "libANGLE/capture/capture_egl_autogen.h"

#include "common/gl_enum_utils.h"
#include "libANGLE/Context.h"
#include "libANGLE/capture/FrameCapture.h"
#include "libANGLE/validationEGL.h"

usingnamespaceangle;

namespace egl
{
CallCapture CaptureChooseConfig(egl::Thread *thread,
                                bool isCallValid,
                                egl::Display *dpyPacked,
                                const AttributeMap &attrib_listPacked,
                                EGLConfig *configs,
                                EGLint config_size,
                                EGLint *num_config,
                                EGLBoolean returnValue)
{ … }

CallCapture CaptureCopyBuffers(egl::Thread *thread,
                               bool isCallValid,
                               egl::Display *dpyPacked,
                               SurfaceID surfacePacked,
                               EGLNativePixmapType target,
                               EGLBoolean returnValue)
{ … }

CallCapture CaptureCreateContext(egl::Thread *thread,
                                 bool isCallValid,
                                 egl::Display *dpyPacked,
                                 egl::Config *configPacked,
                                 gl::ContextID share_contextPacked,
                                 const AttributeMap &attrib_listPacked,
                                 EGLContext returnValue)
{ … }

CallCapture CaptureCreatePbufferSurface(egl::Thread *thread,
                                        bool isCallValid,
                                        egl::Display *dpyPacked,
                                        egl::Config *configPacked,
                                        const AttributeMap &attrib_listPacked,
                                        EGLSurface returnValue)
{ … }

CallCapture CaptureCreatePixmapSurface(egl::Thread *thread,
                                       bool isCallValid,
                                       egl::Display *dpyPacked,
                                       egl::Config *configPacked,
                                       EGLNativePixmapType pixmap,
                                       const AttributeMap &attrib_listPacked,
                                       EGLSurface returnValue)
{ … }

CallCapture CaptureCreateWindowSurface(egl::Thread *thread,
                                       bool isCallValid,
                                       egl::Display *dpyPacked,
                                       egl::Config *configPacked,
                                       EGLNativeWindowType win,
                                       const AttributeMap &attrib_listPacked,
                                       EGLSurface returnValue)
{ … }

CallCapture CaptureDestroyContext(egl::Thread *thread,
                                  bool isCallValid,
                                  egl::Display *dpyPacked,
                                  gl::ContextID ctxPacked,
                                  EGLBoolean returnValue)
{ … }

CallCapture CaptureDestroySurface(egl::Thread *thread,
                                  bool isCallValid,
                                  egl::Display *dpyPacked,
                                  SurfaceID surfacePacked,
                                  EGLBoolean returnValue)
{ … }

CallCapture CaptureGetConfigAttrib(egl::Thread *thread,
                                   bool isCallValid,
                                   egl::Display *dpyPacked,
                                   egl::Config *configPacked,
                                   EGLint attribute,
                                   EGLint *value,
                                   EGLBoolean returnValue)
{ … }

CallCapture CaptureGetConfigs(egl::Thread *thread,
                              bool isCallValid,
                              egl::Display *dpyPacked,
                              EGLConfig *configs,
                              EGLint config_size,
                              EGLint *num_config,
                              EGLBoolean returnValue)
{ … }

CallCapture CaptureGetCurrentDisplay(egl::Thread *thread, bool isCallValid, EGLDisplay returnValue)
{ … }

CallCapture CaptureGetCurrentSurface(egl::Thread *thread,
                                     bool isCallValid,
                                     EGLint readdraw,
                                     EGLSurface returnValue)
{ … }

CallCapture CaptureGetDisplay(egl::Thread *thread,
                              bool isCallValid,
                              EGLNativeDisplayType display_id,
                              EGLDisplay returnValue)
{ … }

CallCapture CaptureGetError(egl::Thread *thread, bool isCallValid, EGLint returnValue)
{ … }

CallCapture CaptureGetProcAddress(egl::Thread *thread,
                                  bool isCallValid,
                                  const char *procname,
                                  __eglMustCastToProperFunctionPointerType returnValue)
{ … }

CallCapture CaptureInitialize(egl::Thread *thread,
                              bool isCallValid,
                              egl::Display *dpyPacked,
                              EGLint *major,
                              EGLint *minor,
                              EGLBoolean returnValue)
{ … }

CallCapture CaptureMakeCurrent(egl::Thread *thread,
                               bool isCallValid,
                               egl::Display *dpyPacked,
                               SurfaceID drawPacked,
                               SurfaceID readPacked,
                               gl::ContextID ctxPacked,
                               EGLBoolean returnValue)
{ … }

CallCapture CaptureQueryContext(egl::Thread *thread,
                                bool isCallValid,
                                egl::Display *dpyPacked,
                                gl::ContextID ctxPacked,
                                EGLint attribute,
                                EGLint *value,
                                EGLBoolean returnValue)
{ … }

CallCapture CaptureQueryString(egl::Thread *thread,
                               bool isCallValid,
                               egl::Display *dpyPacked,
                               EGLint name,
                               const char *returnValue)
{ … }

CallCapture CaptureQuerySurface(egl::Thread *thread,
                                bool isCallValid,
                                egl::Display *dpyPacked,
                                SurfaceID surfacePacked,
                                EGLint attribute,
                                EGLint *value,
                                EGLBoolean returnValue)
{ … }

CallCapture CaptureSwapBuffers(egl::Thread *thread,
                               bool isCallValid,
                               egl::Display *dpyPacked,
                               SurfaceID surfacePacked,
                               EGLBoolean returnValue)
{ … }

CallCapture CaptureTerminate(egl::Thread *thread,
                             bool isCallValid,
                             egl::Display *dpyPacked,
                             EGLBoolean returnValue)
{ … }

CallCapture CaptureWaitGL(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue)
{ … }

CallCapture CaptureWaitNative(egl::Thread *thread,
                              bool isCallValid,
                              EGLint engine,
                              EGLBoolean returnValue)
{ … }

CallCapture CaptureBindTexImage(egl::Thread *thread,
                                bool isCallValid,
                                egl::Display *dpyPacked,
                                SurfaceID surfacePacked,
                                EGLint buffer,
                                EGLBoolean returnValue)
{ … }

CallCapture CaptureReleaseTexImage(egl::Thread *thread,
                                   bool isCallValid,
                                   egl::Display *dpyPacked,
                                   SurfaceID surfacePacked,
                                   EGLint buffer,
                                   EGLBoolean returnValue)
{ … }

CallCapture CaptureSurfaceAttrib(egl::Thread *thread,
                                 bool isCallValid,
                                 egl::Display *dpyPacked,
                                 SurfaceID surfacePacked,
                                 EGLint attribute,
                                 EGLint value,
                                 EGLBoolean returnValue)
{ … }

CallCapture CaptureSwapInterval(egl::Thread *thread,
                                bool isCallValid,
                                egl::Display *dpyPacked,
                                EGLint interval,
                                EGLBoolean returnValue)
{ … }

CallCapture CaptureBindAPI(egl::Thread *thread,
                           bool isCallValid,
                           EGLenum api,
                           EGLBoolean returnValue)
{ … }

CallCapture CaptureCreatePbufferFromClientBuffer(egl::Thread *thread,
                                                 bool isCallValid,
                                                 egl::Display *dpyPacked,
                                                 EGLenum buftype,
                                                 EGLClientBuffer buffer,
                                                 egl::Config *configPacked,
                                                 const AttributeMap &attrib_listPacked,
                                                 EGLSurface returnValue)
{ … }

CallCapture CaptureQueryAPI(egl::Thread *thread, bool isCallValid, EGLenum returnValue)
{ … }

CallCapture CaptureReleaseThread(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue)
{ … }

CallCapture CaptureWaitClient(egl::Thread *thread, bool isCallValid, EGLBoolean returnValue)
{ … }

CallCapture CaptureGetCurrentContext(egl::Thread *thread, bool isCallValid, EGLContext returnValue)
{ … }

CallCapture CaptureClientWaitSync(egl::Thread *thread,
                                  bool isCallValid,
                                  egl::Display *dpyPacked,
                                  egl::SyncID syncPacked,
                                  EGLint flags,
                                  EGLTime timeout,
                                  EGLint returnValue)
{ … }

CallCapture CaptureCreateImage(egl::Thread *thread,
                               bool isCallValid,
                               egl::Display *dpyPacked,
                               gl::ContextID ctxPacked,
                               EGLenum target,
                               EGLClientBuffer buffer,
                               const AttributeMap &attrib_listPacked,
                               EGLImage returnValue)
{ … }

CallCapture CaptureCreatePlatformPixmapSurface(egl::Thread *thread,
                                               bool isCallValid,
                                               egl::Display *dpyPacked,
                                               egl::Config *configPacked,
                                               void *native_pixmap,
                                               const AttributeMap &attrib_listPacked,
                                               EGLSurface returnValue)
{ … }

CallCapture CaptureCreatePlatformWindowSurface(egl::Thread *thread,
                                               bool isCallValid,
                                               egl::Display *dpyPacked,
                                               egl::Config *configPacked,
                                               void *native_window,
                                               const AttributeMap &attrib_listPacked,
                                               EGLSurface returnValue)
{ … }

CallCapture CaptureCreateSync(egl::Thread *thread,
                              bool isCallValid,
                              egl::Display *dpyPacked,
                              EGLenum type,
                              const AttributeMap &attrib_listPacked,
                              EGLSync returnValue)
{ … }

CallCapture CaptureDestroyImage(egl::Thread *thread,
                                bool isCallValid,
                                egl::Display *dpyPacked,
                                ImageID imagePacked,
                                EGLBoolean returnValue)
{ … }

CallCapture CaptureDestroySync(egl::Thread *thread,
                               bool isCallValid,
                               egl::Display *dpyPacked,
                               egl::SyncID syncPacked,
                               EGLBoolean returnValue)
{ … }

CallCapture CaptureGetPlatformDisplay(egl::Thread *thread,
                                      bool isCallValid,
                                      EGLenum platform,
                                      void *native_display,
                                      const AttributeMap &attrib_listPacked,
                                      EGLDisplay returnValue)
{ … }

CallCapture CaptureGetSyncAttrib(egl::Thread *thread,
                                 bool isCallValid,
                                 egl::Display *dpyPacked,
                                 egl::SyncID syncPacked,
                                 EGLint attribute,
                                 EGLAttrib *value,
                                 EGLBoolean returnValue)
{ … }

CallCapture CaptureWaitSync(egl::Thread *thread,
                            bool isCallValid,
                            egl::Display *dpyPacked,
                            egl::SyncID syncPacked,
                            EGLint flags,
                            EGLBoolean returnValue)
{ … }

CallCapture CaptureSetBlobCacheFuncsANDROID(egl::Thread *thread,
                                            bool isCallValid,
                                            egl::Display *dpyPacked,
                                            EGLSetBlobFuncANDROID set,
                                            EGLGetBlobFuncANDROID get)
{ … }

CallCapture CaptureCreateNativeClientBufferANDROID(egl::Thread *thread,
                                                   bool isCallValid,
                                                   const AttributeMap &attrib_listPacked,
                                                   EGLClientBuffer returnValue)
{ … }

CallCapture CaptureGetCompositorTimingSupportedANDROID(egl::Thread *thread,
                                                       bool isCallValid,
                                                       egl::Display *dpyPacked,
                                                       SurfaceID surfacePacked,
                                                       CompositorTiming namePacked,
                                                       EGLBoolean returnValue)
{ … }

CallCapture CaptureGetCompositorTimingANDROID(egl::Thread *thread,
                                              bool isCallValid,
                                              egl::Display *dpyPacked,
                                              SurfaceID surfacePacked,
                                              EGLint numTimestamps,
                                              const EGLint *names,
                                              EGLnsecsANDROID *values,
                                              EGLBoolean returnValue)
{ … }

CallCapture CaptureGetNextFrameIdANDROID(egl::Thread *thread,
                                         bool isCallValid,
                                         egl::Display *dpyPacked,
                                         SurfaceID surfacePacked,
                                         EGLuint64KHR *frameId,
                                         EGLBoolean returnValue)
{ … }

CallCapture CaptureGetFrameTimestampSupportedANDROID(egl::Thread *thread,
                                                     bool isCallValid,
                                                     egl::Display *dpyPacked,
                                                     SurfaceID surfacePacked,
                                                     Timestamp timestampPacked,
                                                     EGLBoolean returnValue)
{ … }

CallCapture CaptureGetFrameTimestampsANDROID(egl::Thread *thread,
                                             bool isCallValid,
                                             egl::Display *dpyPacked,
                                             SurfaceID surfacePacked,
                                             EGLuint64KHR frameId,
                                             EGLint numTimestamps,
                                             const EGLint *timestamps,
                                             EGLnsecsANDROID *values,
                                             EGLBoolean returnValue)
{ … }

CallCapture CaptureGetNativeClientBufferANDROID(egl::Thread *thread,
                                                bool isCallValid,
                                                const struct AHardwareBuffer *buffer,
                                                EGLClientBuffer returnValue)
{ … }

CallCapture CaptureDupNativeFenceFDANDROID(egl::Thread *thread,
                                           bool isCallValid,
                                           egl::Display *dpyPacked,
                                           egl::SyncID syncPacked,
                                           EGLint returnValue)
{ … }

CallCapture CapturePresentationTimeANDROID(egl::Thread *thread,
                                           bool isCallValid,
                                           egl::Display *dpyPacked,
                                           SurfaceID surfacePacked,
                                           EGLnsecsANDROID time,
                                           EGLBoolean returnValue)
{ … }

CallCapture CaptureCreateDeviceANGLE(egl::Thread *thread,
                                     bool isCallValid,
                                     EGLint device_type,
                                     void *native_device,
                                     const EGLAttrib *attrib_list,
                                     EGLDeviceEXT returnValue)
{ … }

CallCapture CaptureReleaseDeviceANGLE(egl::Thread *thread,
                                      bool isCallValid,
                                      egl::Device *devicePacked,
                                      EGLBoolean returnValue)
{ … }

CallCapture CaptureAcquireExternalContextANGLE(egl::Thread *thread,
                                               bool isCallValid,
                                               egl::Display *dpyPacked,
                                               SurfaceID drawAndReadPacked)
{ … }

CallCapture CaptureReleaseExternalContextANGLE(egl::Thread *thread,
                                               bool isCallValid,
                                               egl::Display *dpyPacked)
{ … }

CallCapture CaptureQueryStringiANGLE(egl::Thread *thread,
                                     bool isCallValid,
                                     egl::Display *dpyPacked,
                                     EGLint name,
                                     EGLint index,
                                     const char *returnValue)
{ … }

CallCapture CaptureQueryDisplayAttribANGLE(egl::Thread *thread,
                                           bool isCallValid,
                                           egl::Display *dpyPacked,
                                           EGLint attribute,
                                           EGLAttrib *value,
                                           EGLBoolean returnValue)
{ … }

CallCapture CaptureCopyMetalSharedEventANGLE(egl::Thread *thread,
                                             bool isCallValid,
                                             egl::Display *dpyPacked,
                                             egl::SyncID syncPacked,
                                             void *returnValue)
{ … }

CallCapture CaptureSetValidationEnabledANGLE(egl::Thread *thread,
                                             bool isCallValid,
                                             EGLBoolean validationState)
{ … }

CallCapture CaptureReleaseHighPowerGPUANGLE(egl::Thread *thread,
                                            bool isCallValid,
                                            egl::Display *dpyPacked,
                                            gl::ContextID ctxPacked)
{ … }

CallCapture CaptureReacquireHighPowerGPUANGLE(egl::Thread *thread,
                                              bool isCallValid,
                                              egl::Display *dpyPacked,
                                              gl::ContextID ctxPacked)
{ … }

CallCapture CaptureHandleGPUSwitchANGLE(egl::Thread *thread,
                                        bool isCallValid,
                                        egl::Display *dpyPacked)
{ … }

CallCapture CaptureForceGPUSwitchANGLE(egl::Thread *thread,
                                       bool isCallValid,
                                       egl::Display *dpyPacked,
                                       EGLint gpuIDHigh,
                                       EGLint gpuIDLow)
{ … }

CallCapture CapturePrepareSwapBuffersANGLE(egl::Thread *thread,
                                           bool isCallValid,
                                           egl::Display *dpyPacked,
                                           SurfaceID surfacePacked,
                                           EGLBoolean returnValue)
{ … }

CallCapture CaptureProgramCacheGetAttribANGLE(egl::Thread *thread,
                                              bool isCallValid,
                                              egl::Display *dpyPacked,
                                              EGLenum attrib,
                                              EGLint returnValue)
{ … }

CallCapture CaptureProgramCacheQueryANGLE(egl::Thread *thread,
                                          bool isCallValid,
                                          egl::Display *dpyPacked,
                                          EGLint index,
                                          void *key,
                                          EGLint *keysize,
                                          void *binary,
                                          EGLint *binarysize)
{ … }

CallCapture CaptureProgramCachePopulateANGLE(egl::Thread *thread,
                                             bool isCallValid,
                                             egl::Display *dpyPacked,
                                             const void *key,
                                             EGLint keysize,
                                             const void *binary,
                                             EGLint binarysize)
{ … }

CallCapture CaptureProgramCacheResizeANGLE(egl::Thread *thread,
                                           bool isCallValid,
                                           egl::Display *dpyPacked,
                                           EGLint limit,
                                           EGLint mode,
                                           EGLint returnValue)
{ … }

CallCapture CaptureQuerySurfacePointerANGLE(egl::Thread *thread,
                                            bool isCallValid,
                                            egl::Display *dpyPacked,
                                            SurfaceID surfacePacked,
                                            EGLint attribute,
                                            void **value,
                                            EGLBoolean returnValue)
{ … }

CallCapture CaptureCreateStreamProducerD3DTextureANGLE(egl::Thread *thread,
                                                       bool isCallValid,
                                                       egl::Display *dpyPacked,
                                                       egl::Stream *streamPacked,
                                                       const AttributeMap &attrib_listPacked,
                                                       EGLBoolean returnValue)
{ … }

CallCapture CaptureStreamPostD3DTextureANGLE(egl::Thread *thread,
                                             bool isCallValid,
                                             egl::Display *dpyPacked,
                                             egl::Stream *streamPacked,
                                             void *texture,
                                             const AttributeMap &attrib_listPacked,
                                             EGLBoolean returnValue)
{ … }

CallCapture CaptureSwapBuffersWithFrameTokenANGLE(egl::Thread *thread,
                                                  bool isCallValid,
                                                  egl::Display *dpyPacked,
                                                  SurfaceID surfacePacked,
                                                  EGLFrameTokenANGLE frametoken,
                                                  EGLBoolean returnValue)
{ … }

CallCapture CaptureGetMscRateANGLE(egl::Thread *thread,
                                   bool isCallValid,
                                   egl::Display *dpyPacked,
                                   SurfaceID surfacePacked,
                                   EGLint *numerator,
                                   EGLint *denominator,
                                   EGLBoolean returnValue)
{ … }

CallCapture CaptureExportVkImageANGLE(egl::Thread *thread,
                                      bool isCallValid,
                                      egl::Display *dpyPacked,
                                      ImageID imagePacked,
                                      void *vk_image,
                                      void *vk_image_create_info,
                                      EGLBoolean returnValue)
{ … }

CallCapture CaptureWaitUntilWorkScheduledANGLE(egl::Thread *thread,
                                               bool isCallValid,
                                               egl::Display *dpyPacked)
{ … }

CallCapture CaptureGetSyncValuesCHROMIUM(egl::Thread *thread,
                                         bool isCallValid,
                                         egl::Display *dpyPacked,
                                         SurfaceID surfacePacked,
                                         EGLuint64KHR *ust,
                                         EGLuint64KHR *msc,
                                         EGLuint64KHR *sbc,
                                         EGLBoolean returnValue)
{ … }

CallCapture CaptureQueryDeviceAttribEXT(egl::Thread *thread,
                                        bool isCallValid,
                                        egl::Device *devicePacked,
                                        EGLint attribute,
                                        EGLAttrib *value,
                                        EGLBoolean returnValue)
{ … }

CallCapture CaptureQueryDeviceStringEXT(egl::Thread *thread,
                                        bool isCallValid,
                                        egl::Device *devicePacked,
                                        EGLint name,
                                        const char *returnValue)
{ … }

CallCapture CaptureQueryDisplayAttribEXT(egl::Thread *thread,
                                         bool isCallValid,
                                         egl::Display *dpyPacked,
                                         EGLint attribute,
                                         EGLAttrib *value,
                                         EGLBoolean returnValue)
{ … }

CallCapture CaptureQueryDmaBufFormatsEXT(egl::Thread *thread,
                                         bool isCallValid,
                                         egl::Display *dpyPacked,
                                         EGLint max_formats,
                                         EGLint *formats,
                                         EGLint *num_formats,
                                         EGLBoolean returnValue)
{ … }

CallCapture CaptureQueryDmaBufModifiersEXT(egl::Thread *thread,
                                           bool isCallValid,
                                           egl::Display *dpyPacked,
                                           EGLint format,
                                           EGLint max_modifiers,
                                           EGLuint64KHR *modifiers,
                                           EGLBoolean *external_only,
                                           EGLint *num_modifiers,
                                           EGLBoolean returnValue)
{ … }

CallCapture CaptureCreatePlatformPixmapSurfaceEXT(egl::Thread *thread,
                                                  bool isCallValid,
                                                  egl::Display *dpyPacked,
                                                  egl::Config *configPacked,
                                                  void *native_pixmap,
                                                  const AttributeMap &attrib_listPacked,
                                                  EGLSurface returnValue)
{ … }

CallCapture CaptureCreatePlatformWindowSurfaceEXT(egl::Thread *thread,
                                                  bool isCallValid,
                                                  egl::Display *dpyPacked,
                                                  egl::Config *configPacked,
                                                  void *native_window,
                                                  const AttributeMap &attrib_listPacked,
                                                  EGLSurface returnValue)
{ … }

CallCapture CaptureGetPlatformDisplayEXT(egl::Thread *thread,
                                         bool isCallValid,
                                         EGLenum platform,
                                         void *native_display,
                                         const AttributeMap &attrib_listPacked,
                                         EGLDisplay returnValue)
{ … }

CallCapture CaptureDebugMessageControlKHR(egl::Thread *thread,
                                          bool isCallValid,
                                          EGLDEBUGPROCKHR callback,
                                          const AttributeMap &attrib_listPacked,
                                          EGLint returnValue)
{ … }

CallCapture CaptureLabelObjectKHR(egl::Thread *thread,
                                  bool isCallValid,
                                  egl::Display *displayPacked,
                                  ObjectType objectTypePacked,
                                  EGLObjectKHR object,
                                  EGLLabelKHR label,
                                  EGLint returnValue)
{ … }

CallCapture CaptureQueryDebugKHR(egl::Thread *thread,
                                 bool isCallValid,
                                 EGLint attribute,
                                 EGLAttrib *value,
                                 EGLBoolean returnValue)
{ … }

CallCapture CaptureClientWaitSyncKHR(egl::Thread *thread,
                                     bool isCallValid,
                                     egl::Display *dpyPacked,
                                     egl::SyncID syncPacked,
                                     EGLint flags,
                                     EGLTimeKHR timeout,
                                     EGLint returnValue)
{ … }

CallCapture CaptureCreateSyncKHR(egl::Thread *thread,
                                 bool isCallValid,
                                 egl::Display *dpyPacked,
                                 EGLenum type,
                                 const AttributeMap &attrib_listPacked,
                                 EGLSyncKHR returnValue)
{ … }

CallCapture CaptureDestroySyncKHR(egl::Thread *thread,
                                  bool isCallValid,
                                  egl::Display *dpyPacked,
                                  egl::SyncID syncPacked,
                                  EGLBoolean returnValue)
{ … }

CallCapture CaptureGetSyncAttribKHR(egl::Thread *thread,
                                    bool isCallValid,
                                    egl::Display *dpyPacked,
                                    egl::SyncID syncPacked,
                                    EGLint attribute,
                                    EGLint *value,
                                    EGLBoolean returnValue)
{ … }

CallCapture CaptureCreateImageKHR(egl::Thread *thread,
                                  bool isCallValid,
                                  egl::Display *dpyPacked,
                                  gl::ContextID ctxPacked,
                                  EGLenum target,
                                  EGLClientBuffer buffer,
                                  const AttributeMap &attrib_listPacked,
                                  EGLImageKHR returnValue)
{ … }

CallCapture CaptureDestroyImageKHR(egl::Thread *thread,
                                   bool isCallValid,
                                   egl::Display *dpyPacked,
                                   ImageID imagePacked,
                                   EGLBoolean returnValue)
{ … }

CallCapture CaptureLockSurfaceKHR(egl::Thread *thread,
                                  bool isCallValid,
                                  egl::Display *dpyPacked,
                                  SurfaceID surfacePacked,
                                  const AttributeMap &attrib_listPacked,
                                  EGLBoolean returnValue)
{ … }

CallCapture CaptureQuerySurface64KHR(egl::Thread *thread,
                                     bool isCallValid,
                                     egl::Display *dpyPacked,
                                     SurfaceID surfacePacked,
                                     EGLint attribute,
                                     EGLAttribKHR *value,
                                     EGLBoolean returnValue)
{ … }

CallCapture CaptureUnlockSurfaceKHR(egl::Thread *thread,
                                    bool isCallValid,
                                    egl::Display *dpyPacked,
                                    SurfaceID surfacePacked,
                                    EGLBoolean returnValue)
{ … }

CallCapture CaptureSetDamageRegionKHR(egl::Thread *thread,
                                      bool isCallValid,
                                      egl::Display *dpyPacked,
                                      SurfaceID surfacePacked,
                                      EGLint *rects,
                                      EGLint n_rects,
                                      EGLBoolean returnValue)
{ … }

CallCapture CaptureSignalSyncKHR(egl::Thread *thread,
                                 bool isCallValid,
                                 egl::Display *dpyPacked,
                                 egl::SyncID syncPacked,
                                 EGLenum mode,
                                 EGLBoolean returnValue)
{ … }

CallCapture CaptureCreateStreamKHR(egl::Thread *thread,
                                   bool isCallValid,
                                   egl::Display *dpyPacked,
                                   const AttributeMap &attrib_listPacked,
                                   EGLStreamKHR returnValue)
{ … }

CallCapture CaptureDestroyStreamKHR(egl::Thread *thread,
                                    bool isCallValid,
                                    egl::Display *dpyPacked,
                                    egl::Stream *streamPacked,
                                    EGLBoolean returnValue)
{ … }

CallCapture CaptureQueryStreamKHR(egl::Thread *thread,
                                  bool isCallValid,
                                  egl::Display *dpyPacked,
                                  egl::Stream *streamPacked,
                                  EGLenum attribute,
                                  EGLint *value,
                                  EGLBoolean returnValue)
{ … }

CallCapture CaptureQueryStreamu64KHR(egl::Thread *thread,
                                     bool isCallValid,
                                     egl::Display *dpyPacked,
                                     egl::Stream *streamPacked,
                                     EGLenum attribute,
                                     EGLuint64KHR *value,
                                     EGLBoolean returnValue)
{ … }

CallCapture CaptureStreamAttribKHR(egl::Thread *thread,
                                   bool isCallValid,
                                   egl::Display *dpyPacked,
                                   egl::Stream *streamPacked,
                                   EGLenum attribute,
                                   EGLint value,
                                   EGLBoolean returnValue)
{ … }

CallCapture CaptureStreamConsumerAcquireKHR(egl::Thread *thread,
                                            bool isCallValid,
                                            egl::Display *dpyPacked,
                                            egl::Stream *streamPacked,
                                            EGLBoolean returnValue)
{ … }

CallCapture CaptureStreamConsumerGLTextureExternalKHR(egl::Thread *thread,
                                                      bool isCallValid,
                                                      egl::Display *dpyPacked,
                                                      egl::Stream *streamPacked,
                                                      EGLBoolean returnValue)
{ … }

CallCapture CaptureStreamConsumerReleaseKHR(egl::Thread *thread,
                                            bool isCallValid,
                                            egl::Display *dpyPacked,
                                            egl::Stream *streamPacked,
                                            EGLBoolean returnValue)
{ … }

CallCapture CaptureSwapBuffersWithDamageKHR(egl::Thread *thread,
                                            bool isCallValid,
                                            egl::Display *dpyPacked,
                                            SurfaceID surfacePacked,
                                            const EGLint *rects,
                                            EGLint n_rects,
                                            EGLBoolean returnValue)
{ … }

CallCapture CaptureWaitSyncKHR(egl::Thread *thread,
                               bool isCallValid,
                               egl::Display *dpyPacked,
                               egl::SyncID syncPacked,
                               EGLint flags,
                               EGLint returnValue)
{ … }

CallCapture CapturePostSubBufferNV(egl::Thread *thread,
                                   bool isCallValid,
                                   egl::Display *dpyPacked,
                                   SurfaceID surfacePacked,
                                   EGLint x,
                                   EGLint y,
                                   EGLint width,
                                   EGLint height,
                                   EGLBoolean returnValue)
{ … }

CallCapture CaptureStreamConsumerGLTextureExternalAttribsNV(egl::Thread *thread,
                                                            bool isCallValid,
                                                            egl::Display *dpyPacked,
                                                            egl::Stream *streamPacked,
                                                            const AttributeMap &attrib_listPacked,
                                                            EGLBoolean returnValue)
{ … }

}  // namespace egl