gfx/gl/GLContext.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef GLCONTEXT_H_
   8 #define GLCONTEXT_H_
   9
  10 #include <bitset>
  11 #include <stdint.h>
  12 #include <stdio.h>
  13 #include <stack>
  14 #include <vector>
  15
  16 #ifdef DEBUG
  17 #  include <string.h>
  18 #endif
  19
  20 #ifdef GetClassName
  21 #  undef GetClassName
  22 #endif
  23
  24 // Define MOZ_GL_DEBUG_BUILD unconditionally to enable GL debugging in opt
  25 // builds.
  26 #ifdef DEBUG
  27 #  define MOZ_GL_DEBUG_BUILD 1
  28 #endif
  29
  30 #include "mozilla/IntegerRange.h"
  31 #include "mozilla/RefPtr.h"
  32 #include "mozilla/UniquePtr.h"
  33 #include "mozilla/ThreadLocal.h"
  34
  35 #include "MozFramebuffer.h"
  36 #include "nsTArray.h"
  37 #include "GLConsts.h"
  38 #include "GLDefs.h"
  39 #include "GLTypes.h"
  40 #include "nsRegionFwd.h"
  41 #include "nsString.h"
  42 #include "GLContextTypes.h"
  43 #include "GLContextSymbols.h"
  44 #include "base/platform_thread.h"  // for PlatformThreadId
  45 #include "mozilla/GenericRefCounted.h"
  46 #include "mozilla/WeakPtr.h"
  47
  48 template <class ElemT, class... More>
  49 constexpr inline std::array<ElemT, 1 + sizeof...(More)> make_array(
  50     ElemT&& arg1, More&&... more) {
  51   return {std::forward<ElemT>(arg1), std::forward<ElemT>(more)...};
  52 }
  53
  54 #ifdef MOZ_WIDGET_ANDROID
  55 #  include "mozilla/ProfilerLabels.h"
  56 #endif
  57
  58 namespace mozilla {
  59
  60 namespace gl {
  61 class GLBlitHelper;
  62 class GLLibraryEGL;
  63 class GLReadTexImageHelper;
  64 class SharedSurface;
  65 class SymbolLoader;
  66 struct SymLoadStruct;
  67 }  // namespace gl
  68
  69 namespace layers {
  70 class ColorTextureLayerProgram;
  71 }  // namespace layers
  72
  73 namespace widget {
  74 class CompositorWidget;
  75 }  // namespace widget
  76 }  // namespace mozilla
  77
  78 namespace mozilla {
  79 namespace gl {
  80
  81 enum class GLFeature {
  82   bind_buffer_offset,
  83   blend_minmax,
  84   clear_buffers,
  85   copy_buffer,
  86   depth_clamp,
  87   depth_texture,
  88   draw_buffers,
  89   draw_buffers_indexed,
  90   draw_instanced,
  91   element_index_uint,
  92   ES2_compatibility,
  93   ES3_compatibility,
  94   EXT_color_buffer_float,
  95   frag_color_float,
  96   frag_depth,
  97   framebuffer_blit,
  98   framebuffer_multisample,
  99   framebuffer_object,
 100   framebuffer_object_EXT_OES,
 101   get_integer_indexed,
 102   get_integer64_indexed,
 103   get_query_object_i64v,
 104   get_query_object_iv,
 105   gpu_shader4,
 106   instanced_arrays,
 107   instanced_non_arrays,
 108   internalformat_query,
 109   invalidate_framebuffer,
 110   map_buffer_range,
 111   multiview,
 112   occlusion_query,
 113   occlusion_query_boolean,
 114   occlusion_query2,
 115   packed_depth_stencil,
 116   prim_restart,
 117   prim_restart_fixed,
 118   provoking_vertex,
 119   query_counter,
 120   query_objects,
 121   query_time_elapsed,
 122   read_buffer,
 123   renderbuffer_color_float,
 124   renderbuffer_color_half_float,
 125   robust_buffer_access_behavior,
 126   robustness,
 127   sRGB,
 128   sampler_objects,
 129   seamless_cube_map_opt_in,
 130   shader_texture_lod,
 131   split_framebuffer,
 132   standard_derivatives,
 133   sync,
 134   texture_3D,
 135   texture_3D_compressed,
 136   texture_3D_copy,
 137   texture_compression_bptc,
 138   texture_compression_rgtc,
 139   texture_float,
 140   texture_float_linear,
 141   texture_half_float,
 142   texture_half_float_linear,
 143   texture_non_power_of_two,
 144   texture_norm16,
 145   texture_rg,
 146   texture_storage,
 147   texture_swizzle,
 148   transform_feedback2,
 149   uniform_buffer_object,
 150   uniform_matrix_nonsquare,
 151   vertex_array_object,
 152   EnumMax
 153 };
 154
 155 enum class ContextProfile : uint8_t {
 156   Unknown = 0,
 157   OpenGLCore,
 158   OpenGLCompatibility,
 159   OpenGLES
 160 };
 161
 162 enum class GLRenderer {
 163   Adreno200,
 164   Adreno205,
 165   AdrenoTM200,
 166   AdrenoTM205,
 167   AdrenoTM305,
 168   AdrenoTM320,
 169   AdrenoTM330,
 170   AdrenoTM420,
 171   Mali400MP,
 172   Mali450MP,
 173   MaliT,
 174   SGX530,
 175   SGX540,
 176   SGX544MP,
 177   Tegra,
 178   AndroidEmulator,
 179   GalliumLlvmpipe,
 180   IntelHD3000,
 181   MicrosoftBasicRenderDriver,
 182   SamsungXclipse,
 183   Other
 184 };
 185
 186 class GLContext : public GenericAtomicRefCounted, public SupportsWeakPtr {
 187  public:
 188   static MOZ_THREAD_LOCAL(const GLContext*) sCurrentContext;
 189
 190   static void InvalidateCurrentContext();
 191
 192   const GLContextDesc mDesc;
 193
 194   bool mImplicitMakeCurrent = false;
 195   bool mUseTLSIsCurrent;
 196
 197   static void ResetTLSCurrentContext();
 198
 199   class TlsScope final {
 200     const WeakPtr<GLContext> mGL;
 201     const bool mWasTlsOk;
 202
 203    public:
 204     explicit TlsScope(GLContext* const gl, bool invalidate = false)
 205         : mGL(gl), mWasTlsOk(gl && gl->mUseTLSIsCurrent) {
 206       if (mGL) {
 207         if (invalidate) {
 208           InvalidateCurrentContext();
 209         }
 210         mGL->mUseTLSIsCurrent = true;
 211       }
 212     }
 213
 214     ~TlsScope() {
 215       if (mGL) {
 216         mGL->mUseTLSIsCurrent = mWasTlsOk;
 217       }
 218     }
 219   };
 220
 221   // -----------------------------------------------------------------------------
 222   // basic getters
 223  public:
 224   /**
 225    * Returns true if the context is using ANGLE. This should only be overridden
 226    * for an ANGLE implementation.
 227    */
 228   virtual bool IsANGLE() const { return false; }
 229
 230   /**
 231    * Returns true if the context is using WARP. This should only be overridden
 232    * for an ANGLE implementation.
 233    */
 234   virtual bool IsWARP() const { return false; }
 235
 236   virtual void GetWSIInfo(nsCString* const out) const = 0;
 237
 238   /**
 239    * Return true if we are running on a OpenGL core profile context
 240    */
 241   inline bool IsCoreProfile() const {
 242     MOZ_ASSERT(mProfile != ContextProfile::Unknown, "unknown context profile");
 243
 244     return mProfile == ContextProfile::OpenGLCore;
 245   }
 246
 247   /**
 248    * Return true if we are running on a OpenGL compatibility profile context
 249    * (legacy profile 2.1 on Max OS X)
 250    */
 251   inline bool IsCompatibilityProfile() const {
 252     MOZ_ASSERT(mProfile != ContextProfile::Unknown, "unknown context profile");
 253
 254     return mProfile == ContextProfile::OpenGLCompatibility;
 255   }
 256
 257   inline bool IsGLES() const {
 258     MOZ_ASSERT(mProfile != ContextProfile::Unknown, "unknown context profile");
 259
 260     return mProfile == ContextProfile::OpenGLES;
 261   }
 262
 263   inline bool IsAtLeast(ContextProfile profile, unsigned int version) const {
 264     MOZ_ASSERT(profile != ContextProfile::Unknown,
 265                "IsAtLeast: bad <profile> parameter");
 266     MOZ_ASSERT(mProfile != ContextProfile::Unknown, "unknown context profile");
 267     MOZ_ASSERT(mVersion != 0, "unknown context version");
 268
 269     if (version > mVersion) {
 270       return false;
 271     }
 272
 273     return profile == mProfile;
 274   }
 275
 276   /**
 277    * Return the version of the context.
 278    * Example :
 279    *   If this a OpenGL 2.1, that will return 210
 280    */
 281   inline uint32_t Version() const { return mVersion; }
 282
 283   inline uint32_t ShadingLanguageVersion() const {
 284     return mShadingLanguageVersion;
 285   }
 286
 287   GLVendor Vendor() const { return mVendor; }
 288   GLRenderer Renderer() const { return mRenderer; }
 289   bool IsMesa() const { return mIsMesa; }
 290
 291   bool IsContextLost() const { return mContextLost; }
 292
 293   bool CheckContextLost() const {
 294     mTopError = GetError();
 295     return IsContextLost();
 296   }
 297
 298   bool HasPBOState() const { return (!IsGLES() || Version() >= 300); }
 299
 300   /**
 301    * If this context is double-buffered, returns TRUE.
 302    */
 303   virtual bool IsDoubleBuffered() const { return false; }
 304
 305   virtual GLContextType GetContextType() const = 0;
 306
 307   virtual bool IsCurrentImpl() const = 0;
 308   virtual bool MakeCurrentImpl() const = 0;
 309
 310   bool IsCurrent() const {
 311     if (mImplicitMakeCurrent) return MakeCurrent();
 312
 313     return IsCurrentImpl();
 314   }
 315
 316   bool MakeCurrent(bool aForce = false) const;
 317
 318   /**
 319    * Get the default framebuffer for this context.
 320    */
 321   UniquePtr<MozFramebuffer> mOffscreenDefaultFb;
 322
 323   bool CreateOffscreenDefaultFb(const gfx::IntSize& size);
 324
 325   virtual GLuint GetDefaultFramebuffer() {
 326     if (mOffscreenDefaultFb) {
 327       return mOffscreenDefaultFb->mFB;
 328     }
 329     return 0;
 330   }
 331
 332   /**
 333    * mVersion store the OpenGL's version, multiplied by 100. For example, if
 334    * the context is an OpenGL 2.1 context, mVersion value will be 210.
 335    */
 336   uint32_t mVersion = 0;
 337   ContextProfile mProfile = ContextProfile::Unknown;
 338
 339   uint32_t mShadingLanguageVersion = 0;
 340
 341   GLVendor mVendor = GLVendor::Other;
 342   GLRenderer mRenderer = GLRenderer::Other;
 343   bool mIsMesa = false;
 344
 345   // -----------------------------------------------------------------------------
 346   // Extensions management
 347   /**
 348    * This mechanism is designed to know if an extension is supported. In the
 349    * long term, we would like to only use the extension group queries XXX_* to
 350    * have full compatibility with context version and profiles (especialy the
 351    * core that officialy don't bring any extensions).
 352    */
 353
 354   /**
 355    * Known GL extensions that can be queried by
 356    * IsExtensionSupported.  The results of this are cached, and as
 357    * such it's safe to use this even in performance critical code.
 358    * If you add to this array, remember to add to the string names
 359    * in GLContext.cpp.
 360    */
 361   enum GLExtensions {
 362     Extension_None = 0,
 363     AMD_compressed_ATC_texture,
 364     ANGLE_depth_texture,
 365     ANGLE_framebuffer_blit,
 366     ANGLE_framebuffer_multisample,
 367     ANGLE_instanced_arrays,
 368     ANGLE_multiview,
 369     ANGLE_provoking_vertex,
 370     ANGLE_texture_compression_dxt3,
 371     ANGLE_texture_compression_dxt5,
 372     ANGLE_timer_query,
 373     APPLE_client_storage,
 374     APPLE_fence,
 375     APPLE_framebuffer_multisample,
 376     APPLE_sync,
 377     APPLE_texture_range,
 378     APPLE_vertex_array_object,
 379     ARB_ES2_compatibility,
 380     ARB_ES3_compatibility,
 381     ARB_color_buffer_float,
 382     ARB_compatibility,
 383     ARB_copy_buffer,
 384     ARB_depth_clamp,
 385     ARB_depth_texture,
 386     ARB_draw_buffers,
 387     ARB_draw_instanced,
 388     ARB_framebuffer_object,
 389     ARB_framebuffer_sRGB,
 390     ARB_geometry_shader4,
 391     ARB_half_float_pixel,
 392     ARB_instanced_arrays,
 393     ARB_internalformat_query,
 394     ARB_invalidate_subdata,
 395     ARB_map_buffer_range,
 396     ARB_occlusion_query2,
 397     ARB_pixel_buffer_object,
 398     ARB_provoking_vertex,
 399     ARB_robust_buffer_access_behavior,
 400     ARB_robustness,
 401     ARB_sampler_objects,
 402     ARB_seamless_cube_map,
 403     ARB_shader_texture_lod,
 404     ARB_sync,
 405     ARB_texture_compression,
 406     ARB_texture_compression_bptc,
 407     ARB_texture_compression_rgtc,
 408     ARB_texture_float,
 409     ARB_texture_non_power_of_two,
 410     ARB_texture_rectangle,
 411     ARB_texture_rg,
 412     ARB_texture_storage,
 413     ARB_texture_swizzle,
 414     ARB_timer_query,
 415     ARB_transform_feedback2,
 416     ARB_uniform_buffer_object,
 417     ARB_vertex_array_object,
 418     CHROMIUM_color_buffer_float_rgb,
 419     CHROMIUM_color_buffer_float_rgba,
 420     EXT_bgra,
 421     EXT_blend_minmax,
 422     EXT_color_buffer_float,
 423     EXT_color_buffer_half_float,
 424     EXT_copy_texture,
 425     EXT_depth_clamp,
 426     EXT_disjoint_timer_query,
 427     EXT_draw_buffers,
 428     EXT_draw_buffers2,
 429     EXT_draw_instanced,
 430     EXT_float_blend,
 431     EXT_frag_depth,
 432     EXT_framebuffer_blit,
 433     EXT_framebuffer_multisample,
 434     EXT_framebuffer_object,
 435     EXT_framebuffer_sRGB,
 436     EXT_gpu_shader4,
 437     EXT_map_buffer_range,
 438     EXT_multisampled_render_to_texture,
 439     EXT_occlusion_query_boolean,
 440     EXT_packed_depth_stencil,
 441     EXT_provoking_vertex,
 442     EXT_read_format_bgra,
 443     EXT_robustness,
 444     EXT_sRGB,
 445     EXT_sRGB_write_control,
 446     EXT_shader_texture_lod,
 447     EXT_texture_compression_bptc,
 448     EXT_texture_compression_dxt1,
 449     EXT_texture_compression_rgtc,
 450     EXT_texture_compression_s3tc,
 451     EXT_texture_compression_s3tc_srgb,
 452     EXT_texture_filter_anisotropic,
 453     EXT_texture_format_BGRA8888,
 454     EXT_texture_norm16,
 455     EXT_texture_sRGB,
 456     EXT_texture_storage,
 457     EXT_timer_query,
 458     EXT_transform_feedback,
 459     EXT_unpack_subimage,
 460     EXT_semaphore,
 461     EXT_semaphore_fd,
 462     EXT_memory_object,
 463     EXT_memory_object_fd,
 464     IMG_read_format,
 465     IMG_texture_compression_pvrtc,
 466     IMG_texture_npot,
 467     KHR_debug,
 468     KHR_parallel_shader_compile,
 469     KHR_robust_buffer_access_behavior,
 470     KHR_robustness,
 471     KHR_texture_compression_astc_hdr,
 472     KHR_texture_compression_astc_ldr,
 473     NV_draw_instanced,
 474     NV_fence,
 475     NV_framebuffer_blit,
 476     NV_geometry_program4,
 477     NV_half_float,
 478     NV_instanced_arrays,
 479     NV_primitive_restart,
 480     NV_texture_barrier,
 481     NV_transform_feedback,
 482     NV_transform_feedback2,
 483     OES_EGL_image,
 484     OES_EGL_image_external,
 485     OES_EGL_sync,
 486     OES_compressed_ETC1_RGB8_texture,
 487     OES_depth24,
 488     OES_depth32,
 489     OES_depth_texture,
 490     OES_draw_buffers_indexed,
 491     OES_element_index_uint,
 492     OES_fbo_render_mipmap,
 493     OES_framebuffer_object,
 494     OES_packed_depth_stencil,
 495     OES_rgb8_rgba8,
 496     OES_standard_derivatives,
 497     OES_stencil8,
 498     OES_texture_3D,
 499     OES_texture_float,
 500     OES_texture_float_linear,
 501     OES_texture_half_float,
 502     OES_texture_half_float_linear,
 503     OES_texture_npot,
 504     OES_vertex_array_object,
 505     OVR_multiview2,
 506     Extensions_Max,
 507     Extensions_End
 508   };
 509
 510   bool IsExtensionSupported(GLExtensions aKnownExtension) const {
 511     return mAvailableExtensions[aKnownExtension];
 512   }
 513
 514  protected:
 515   void MarkExtensionUnsupported(GLExtensions aKnownExtension) {
 516     mAvailableExtensions[aKnownExtension] = 0;
 517   }
 518
 519   void MarkExtensionSupported(GLExtensions aKnownExtension) {
 520     mAvailableExtensions[aKnownExtension] = 1;
 521   }
 522
 523   std::bitset<Extensions_Max> mAvailableExtensions;
 524
 525   // -----------------------------------------------------------------------------
 526   // Feature queries
 527   /*
 528    * This mecahnism introduces a new way to check if a OpenGL feature is
 529    * supported, regardless of whether it is supported by an extension or
 530    * natively by the context version/profile
 531    */
 532  public:
 533   bool IsSupported(GLFeature feature) const {
 534     return mAvailableFeatures[size_t(feature)];
 535   }
 536
 537   static const char* GetFeatureName(GLFeature feature);
 538
 539  private:
 540   std::bitset<size_t(GLFeature::EnumMax)> mAvailableFeatures;
 541
 542   /**
 543    * Init features regarding OpenGL extension and context version and profile
 544    */
 545   void InitFeatures();
 546
 547   /**
 548    * Mark the feature and associated extensions as unsupported
 549    */
 550   void MarkUnsupported(GLFeature feature);
 551
 552   /**
 553    * Is this feature supported using the core (unsuffixed) symbols?
 554    */
 555   bool IsFeatureProvidedByCoreSymbols(GLFeature feature);
 556
 557   // -----------------------------------------------------------------------------
 558   // Error handling
 559
 560  private:
 561   mutable bool mContextLost = false;
 562   mutable GLenum mTopError = 0;
 563
 564  protected:
 565   void OnContextLostError() const;
 566
 567  public:
 568   static std::string GLErrorToString(GLenum aError);
 569
 570   static bool IsBadCallError(const GLenum err) {
 571     return !(err == 0 || err == LOCAL_GL_CONTEXT_LOST);
 572   }
 573
 574   class LocalErrorScope;
 575
 576  private:
 577   mutable std::stack<const LocalErrorScope*> mLocalErrorScopeStack;
 578   mutable UniquePtr<LocalErrorScope> mDebugErrorScope;
 579
 580   ////////////////////////////////////
 581   // Use this safer option.
 582
 583  public:
 584   class LocalErrorScope {
 585     const GLContext& mGL;
 586     GLenum mOldTop;
 587     bool mHasBeenChecked;
 588
 589    public:
 590     explicit LocalErrorScope(const GLContext& gl)
 591         : mGL(gl), mHasBeenChecked(false) {
 592       mGL.mLocalErrorScopeStack.push(this);
 593       mOldTop = mGL.GetError();
 594     }
 595
 596     /// Never returns CONTEXT_LOST.
 597     GLenum GetError() {
 598       MOZ_ASSERT(!mHasBeenChecked);
 599       mHasBeenChecked = true;
 600
 601       const auto ret = mGL.GetError();
 602       if (ret == LOCAL_GL_CONTEXT_LOST) return 0;
 603       return ret;
 604     }
 605
 606     ~LocalErrorScope() {
 607       MOZ_ASSERT(mHasBeenChecked);
 608
 609       MOZ_ASSERT(!IsBadCallError(mGL.GetError()));
 610
 611       MOZ_ASSERT(mGL.mLocalErrorScopeStack.top() == this);
 612       mGL.mLocalErrorScopeStack.pop();
 613
 614       mGL.mTopError = mOldTop;
 615     }
 616   };
 617
 618   // -
 619
 620   bool GetPotentialInteger(GLenum pname, GLint* param) {
 621     LocalErrorScope localError(*this);
 622
 623     fGetIntegerv(pname, param);
 624
 625     GLenum err = localError.GetError();
 626     MOZ_ASSERT_IF(err != LOCAL_GL_NO_ERROR, err == LOCAL_GL_INVALID_ENUM);
 627     return err == LOCAL_GL_NO_ERROR;
 628   }
 629
 630   void DebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity,
 631                      GLsizei length, const GLchar* message);
 632
 633  private:
 634   static void GLAPIENTRY StaticDebugCallback(GLenum source, GLenum type,
 635                                              GLuint id, GLenum severity,
 636                                              GLsizei length,
 637                                              const GLchar* message,
 638                                              const GLvoid* userParam);
 639
 640   // -----------------------------------------------------------------------------
 641   // Debugging implementation
 642  private:
 643 #ifndef MOZ_FUNCTION_NAME
 644 #  ifdef __GNUC__
 645 #    define MOZ_FUNCTION_NAME __PRETTY_FUNCTION__
 646 #  elif defined(_MSC_VER)
 647 #    define MOZ_FUNCTION_NAME __FUNCTION__
 648 #  else
 649 #    define MOZ_FUNCTION_NAME \
 650       __func__  // defined in C99, supported in various C++ compilers. Just raw
 651                 // function name.
 652 #  endif
 653 #endif
 654
 655 #ifdef MOZ_WIDGET_ANDROID
 656 // Record the name of the GL call for better hang stacks on Android.
 657 #  define ANDROID_ONLY_PROFILER_LABEL AUTO_PROFILER_LABEL(__func__, GRAPHICS);
 658 #else
 659 #  define ANDROID_ONLY_PROFILER_LABEL
 660 #endif
 661
 662 #define BEFORE_GL_CALL                               \
 663   ANDROID_ONLY_PROFILER_LABEL                        \
 664   if (MOZ_LIKELY(BeforeGLCall(MOZ_FUNCTION_NAME))) { \
 665     do {                                             \
 666   } while (0)
 667
 668 #define AFTER_GL_CALL             \
 669   AfterGLCall(MOZ_FUNCTION_NAME); \
 670   }                               \
 671   do {                            \
 672   } while (0)
 673
 674   void BeforeGLCall_Debug(const char* funcName) const;
 675   void AfterGLCall_Debug(const char* funcName) const;
 676   static void OnImplicitMakeCurrentFailure(const char* funcName);
 677
 678   bool BeforeGLCall(const char* const funcName) const {
 679     if (mImplicitMakeCurrent) {
 680       if (MOZ_UNLIKELY(!MakeCurrent())) {
 681         if (!mContextLost) {
 682           OnImplicitMakeCurrentFailure(funcName);
 683         }
 684         return false;
 685       }
 686     }
 687     MOZ_GL_ASSERT(this, IsCurrentImpl());
 688
 689     if (MOZ_UNLIKELY(mDebugFlags)) {
 690       BeforeGLCall_Debug(funcName);
 691     }
 692     return true;
 693   }
 694
 695   void AfterGLCall(const char* const funcName) const {
 696     if (MOZ_UNLIKELY(mDebugFlags)) {
 697       AfterGLCall_Debug(funcName);
 698     }
 699   }
 700
 701   GLContext* TrackingContext() {
 702     GLContext* tip = this;
 703     while (tip->mSharedContext) tip = tip->mSharedContext;
 704     return tip;
 705   }
 706
 707   static void AssertNotPassingStackBufferToTheGL(const void* ptr);
 708
 709 #ifdef MOZ_GL_DEBUG_BUILD
 710
 711 #  define TRACKING_CONTEXT(a) \
 712     do {                      \
 713       TrackingContext()->a;   \
 714     } while (0)
 715
 716 #  define ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(ptr) \
 717     AssertNotPassingStackBufferToTheGL(ptr)
 718
 719 #  define ASSERT_SYMBOL_PRESENT(func)                                    \
 720     do {                                                                 \
 721       MOZ_ASSERT(strstr(MOZ_FUNCTION_NAME, #func) != nullptr,            \
 722                  "Mismatched symbol check.");                            \
 723       if (MOZ_UNLIKELY(!mSymbols.func)) {                                \
 724         printf_stderr("RUNTIME ASSERT: Uninitialized GL function: %s\n", \
 725                       #func);                                            \
 726         MOZ_CRASH("GFX: Uninitialized GL function");                     \
 727       }                                                                  \
 728     } while (0)
 729
 730 #else  // ifdef MOZ_GL_DEBUG_BUILD
 731
 732 #  define TRACKING_CONTEXT(a) \
 733     do {                      \
 734     } while (0)
 735 #  define ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(ptr) \
 736     do {                                             \
 737     } while (0)
 738 #  define ASSERT_SYMBOL_PRESENT(func) \
 739     do {                              \
 740     } while (0)
 741
 742 #endif  // ifdef MOZ_GL_DEBUG_BUILD
 743
 744   // Do whatever setup is necessary to draw to our offscreen FBO, if it's
 745   // bound.
 746   void BeforeGLDrawCall() {}
 747
 748   // Do whatever tear-down is necessary after drawing to our offscreen FBO,
 749   // if it's bound.
 750   void AfterGLDrawCall() { mHeavyGLCallsSinceLastFlush = true; }
 751
 752   // Do whatever setup is necessary to read from our offscreen FBO, if it's
 753   // bound.
 754   void BeforeGLReadCall() {}
 755
 756   // Do whatever tear-down is necessary after reading from our offscreen FBO,
 757   // if it's bound.
 758   void AfterGLReadCall() {}
 759
 760  public:
 761   void OnSyncCall() const { mSyncGLCallCount++; }
 762
 763   uint64_t GetSyncCallCount() const { return mSyncGLCallCount; }
 764
 765   void ResetSyncCallCount(const char* resetReason) const;
 766
 767   // -----------------------------------------------------------------------------
 768   // GL official entry points
 769  public:
 770   // We smash all errors together, so you never have to loop on this. We
 771   // guarantee that immediately after this call, there are no errors left.
 772   // Always returns the top-most error, except if followed by CONTEXT_LOST, then
 773   // return that instead.
 774   GLenum GetError() const;
 775
 776   GLenum fGetError() { return GetError(); }
 777
 778   GLenum fGetGraphicsResetStatus() const;
 779
 780   // -
 781
 782   void fActiveTexture(GLenum texture) {
 783     BEFORE_GL_CALL;
 784     mSymbols.fActiveTexture(texture);
 785     AFTER_GL_CALL;
 786   }
 787
 788   void fAttachShader(GLuint program, GLuint shader) {
 789     BEFORE_GL_CALL;
 790     mSymbols.fAttachShader(program, shader);
 791     AFTER_GL_CALL;
 792   }
 793
 794   void fBeginQuery(GLenum target, GLuint id) {
 795     BEFORE_GL_CALL;
 796     ASSERT_SYMBOL_PRESENT(fBeginQuery);
 797     mSymbols.fBeginQuery(target, id);
 798     AFTER_GL_CALL;
 799   }
 800
 801   void fBindAttribLocation(GLuint program, GLuint index, const GLchar* name) {
 802     BEFORE_GL_CALL;
 803     mSymbols.fBindAttribLocation(program, index, name);
 804     AFTER_GL_CALL;
 805   }
 806
 807   void fBindBuffer(GLenum target, GLuint buffer) {
 808     BEFORE_GL_CALL;
 809     mSymbols.fBindBuffer(target, buffer);
 810     AFTER_GL_CALL;
 811   }
 812
 813   void InvalidateFramebuffer(GLenum target) {
 814     constexpr auto ATTACHMENTS = make_array(GLenum{LOCAL_GL_COLOR_ATTACHMENT0},
 815                                             LOCAL_GL_DEPTH_STENCIL_ATTACHMENT);
 816     fInvalidateFramebuffer(target, ATTACHMENTS.size(), ATTACHMENTS.data());
 817   }
 818
 819   void fInvalidateFramebuffer(GLenum target, GLsizei numAttachments,
 820                               const GLenum* attachments) {
 821     if (!mSymbols.fInvalidateFramebuffer) return;
 822     BeforeGLDrawCall();
 823     BEFORE_GL_CALL;
 824     ASSERT_SYMBOL_PRESENT(fInvalidateFramebuffer);
 825     mSymbols.fInvalidateFramebuffer(target, numAttachments, attachments);
 826     AFTER_GL_CALL;
 827     AfterGLDrawCall();
 828   }
 829
 830   void fInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments,
 831                                  const GLenum* attachments, GLint x, GLint y,
 832                                  GLsizei width, GLsizei height) {
 833     if (!mSymbols.fInvalidateSubFramebuffer) return;
 834     BeforeGLDrawCall();
 835     BEFORE_GL_CALL;
 836     ASSERT_SYMBOL_PRESENT(fInvalidateSubFramebuffer);
 837     mSymbols.fInvalidateSubFramebuffer(target, numAttachments, attachments, x,
 838                                        y, width, height);
 839     AFTER_GL_CALL;
 840     AfterGLDrawCall();
 841   }
 842
 843   void fBindTexture(GLenum target, GLuint texture) {
 844     BEFORE_GL_CALL;
 845     mSymbols.fBindTexture(target, texture);
 846     AFTER_GL_CALL;
 847   }
 848
 849   void BindSamplerTexture(GLuint texUnitId, GLuint samplerHandle,
 850                           GLenum texTarget, GLuint texHandle) {
 851     fBindSampler(texUnitId, samplerHandle);
 852     fActiveTexture(LOCAL_GL_TEXTURE0 + texUnitId);
 853     fBindTexture(texTarget, texHandle);
 854   }
 855
 856   void fBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
 857     BEFORE_GL_CALL;
 858     mSymbols.fBlendColor(red, green, blue, alpha);
 859     AFTER_GL_CALL;
 860   }
 861
 862   void fBlendEquation(GLenum mode) {
 863     BEFORE_GL_CALL;
 864     mSymbols.fBlendEquation(mode);
 865     AFTER_GL_CALL;
 866   }
 867
 868   void fBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
 869     BEFORE_GL_CALL;
 870     mSymbols.fBlendEquationSeparate(modeRGB, modeAlpha);
 871     AFTER_GL_CALL;
 872   }
 873
 874   void fBlendFunc(GLenum sfactor, GLenum dfactor) {
 875     BEFORE_GL_CALL;
 876     mSymbols.fBlendFunc(sfactor, dfactor);
 877     AFTER_GL_CALL;
 878   }
 879
 880   void fBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB,
 881                           GLenum sfactorAlpha, GLenum dfactorAlpha) {
 882     BEFORE_GL_CALL;
 883     mSymbols.fBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha,
 884                                 dfactorAlpha);
 885     AFTER_GL_CALL;
 886   }
 887
 888  private:
 889   void raw_fBufferData(GLenum target, GLsizeiptr size, const GLvoid* data,
 890                        GLenum usage) {
 891     ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(data);
 892     BEFORE_GL_CALL;
 893     mSymbols.fBufferData(target, size, data, usage);
 894     OnSyncCall();
 895     AFTER_GL_CALL;
 896     mHeavyGLCallsSinceLastFlush = true;
 897   }
 898
 899  public:
 900   void fBufferData(GLenum target, GLsizeiptr size, const GLvoid* data,
 901                    GLenum usage) {
 902     raw_fBufferData(target, size, data, usage);
 903
 904     // bug 744888
 905     if (WorkAroundDriverBugs() && !data && Vendor() == GLVendor::NVIDIA) {
 906       UniquePtr<char[]> buf = MakeUnique<char[]>(1);
 907       buf[0] = 0;
 908       fBufferSubData(target, size - 1, 1, buf.get());
 909     }
 910   }
 911
 912   void fBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
 913                       const GLvoid* data) {
 914     ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(data);
 915     BEFORE_GL_CALL;
 916     mSymbols.fBufferSubData(target, offset, size, data);
 917     AFTER_GL_CALL;
 918     mHeavyGLCallsSinceLastFlush = true;
 919   }
 920
 921  private:
 922   void raw_fClear(GLbitfield mask) {
 923     BEFORE_GL_CALL;
 924     mSymbols.fClear(mask);
 925     AFTER_GL_CALL;
 926   }
 927
 928  public:
 929   void fClear(GLbitfield mask) {
 930     BeforeGLDrawCall();
 931     raw_fClear(mask);
 932     AfterGLDrawCall();
 933   }
 934
 935   void fClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth,
 936                       GLint stencil) {
 937     BeforeGLDrawCall();
 938     BEFORE_GL_CALL;
 939     mSymbols.fClearBufferfi(buffer, drawbuffer, depth, stencil);
 940     AFTER_GL_CALL;
 941     AfterGLDrawCall();
 942   }
 943
 944   void fClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) {
 945     BeforeGLDrawCall();
 946     BEFORE_GL_CALL;
 947     mSymbols.fClearBufferfv(buffer, drawbuffer, value);
 948     AFTER_GL_CALL;
 949     AfterGLDrawCall();
 950   }
 951
 952   void fClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) {
 953     BeforeGLDrawCall();
 954     BEFORE_GL_CALL;
 955     mSymbols.fClearBufferiv(buffer, drawbuffer, value);
 956     AFTER_GL_CALL;
 957     AfterGLDrawCall();
 958   }
 959
 960   void fClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) {
 961     BeforeGLDrawCall();
 962     BEFORE_GL_CALL;
 963     mSymbols.fClearBufferuiv(buffer, drawbuffer, value);
 964     AFTER_GL_CALL;
 965     AfterGLDrawCall();
 966   }
 967
 968   void fClearColor(GLfloat r, GLfloat g, GLfloat b, GLfloat a) {
 969     BEFORE_GL_CALL;
 970     mSymbols.fClearColor(r, g, b, a);
 971     AFTER_GL_CALL;
 972   }
 973
 974   void fClearStencil(GLint s) {
 975     BEFORE_GL_CALL;
 976     mSymbols.fClearStencil(s);
 977     AFTER_GL_CALL;
 978   }
 979
 980   void fClientActiveTexture(GLenum texture) {
 981     BEFORE_GL_CALL;
 982     mSymbols.fClientActiveTexture(texture);
 983     AFTER_GL_CALL;
 984   }
 985
 986   void fColorMask(realGLboolean red, realGLboolean green, realGLboolean blue,
 987                   realGLboolean alpha) {
 988     BEFORE_GL_CALL;
 989     mSymbols.fColorMask(red, green, blue, alpha);
 990     AFTER_GL_CALL;
 991   }
 992
 993   void fCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat,
 994                              GLsizei width, GLsizei height, GLint border,
 995                              GLsizei imageSize, const GLvoid* pixels) {
 996     ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(pixels);
 997     BEFORE_GL_CALL;
 998     mSymbols.fCompressedTexImage2D(target, level, internalformat, width, height,
 999                                    border, imageSize, pixels);
1000     AFTER_GL_CALL;
1001     mHeavyGLCallsSinceLastFlush = true;
1002   }
1003
1004   void fCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset,
1005                                 GLint yoffset, GLsizei width, GLsizei height,
1006                                 GLenum format, GLsizei imageSize,
1007                                 const GLvoid* pixels) {
1008     ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(pixels);
1009     BEFORE_GL_CALL;
1010     mSymbols.fCompressedTexSubImage2D(target, level, xoffset, yoffset, width,
1011                                       height, format, imageSize, pixels);
1012     AFTER_GL_CALL;
1013     mHeavyGLCallsSinceLastFlush = true;
1014   }
1015
1016   void fCopyTexImage2D(GLenum target, GLint level, GLenum internalformat,
1017                        GLint x, GLint y, GLsizei width, GLsizei height,
1018                        GLint border);
1019
1020   void fCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset,
1021                           GLint yoffset, GLint x, GLint y, GLsizei width,
1022                           GLsizei height) {
1023     BeforeGLReadCall();
1024     raw_fCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width,
1025                            height);
1026     AfterGLReadCall();
1027   }
1028
1029   void fCullFace(GLenum mode) {
1030     BEFORE_GL_CALL;
1031     mSymbols.fCullFace(mode);
1032     AFTER_GL_CALL;
1033   }
1034
1035   void fDebugMessageCallback(GLDEBUGPROC callback, const GLvoid* userParam) {
1036     BEFORE_GL_CALL;
1037     ASSERT_SYMBOL_PRESENT(fDebugMessageCallback);
1038     mSymbols.fDebugMessageCallback(callback, userParam);
1039     AFTER_GL_CALL;
1040   }
1041
1042   void fDebugMessageControl(GLenum source, GLenum type, GLenum severity,
1043                             GLsizei count, const GLuint* ids,
1044                             realGLboolean enabled) {
1045     BEFORE_GL_CALL;
1046     ASSERT_SYMBOL_PRESENT(fDebugMessageControl);
1047     mSymbols.fDebugMessageControl(source, type, severity, count, ids, enabled);
1048     AFTER_GL_CALL;
1049   }
1050
1051   void fDebugMessageInsert(GLenum source, GLenum type, GLuint id,
1052                            GLenum severity, GLsizei length, const GLchar* buf) {
1053     BEFORE_GL_CALL;
1054     ASSERT_SYMBOL_PRESENT(fDebugMessageInsert);
1055     mSymbols.fDebugMessageInsert(source, type, id, severity, length, buf);
1056     AFTER_GL_CALL;
1057   }
1058
1059   void fDetachShader(GLuint program, GLuint shader) {
1060     BEFORE_GL_CALL;
1061     mSymbols.fDetachShader(program, shader);
1062     AFTER_GL_CALL;
1063   }
1064
1065   void fDepthFunc(GLenum func) {
1066     BEFORE_GL_CALL;
1067     mSymbols.fDepthFunc(func);
1068     AFTER_GL_CALL;
1069   }
1070
1071   void fDepthMask(realGLboolean flag) {
1072     BEFORE_GL_CALL;
1073     mSymbols.fDepthMask(flag);
1074     AFTER_GL_CALL;
1075   }
1076
1077   void fDisable(GLenum capability) {
1078     BEFORE_GL_CALL;
1079     mSymbols.fDisable(capability);
1080     AFTER_GL_CALL;
1081   }
1082
1083   void fDisableClientState(GLenum capability) {
1084     BEFORE_GL_CALL;
1085     mSymbols.fDisableClientState(capability);
1086     AFTER_GL_CALL;
1087   }
1088
1089   void fDisableVertexAttribArray(GLuint index) {
1090     BEFORE_GL_CALL;
1091     mSymbols.fDisableVertexAttribArray(index);
1092     AFTER_GL_CALL;
1093   }
1094
1095   void fDrawBuffer(GLenum mode) {
1096     BEFORE_GL_CALL;
1097     mSymbols.fDrawBuffer(mode);
1098     AFTER_GL_CALL;
1099   }
1100
1101  private:
1102   void raw_fDrawArrays(GLenum mode, GLint first, GLsizei count) {
1103     BEFORE_GL_CALL;
1104     mSymbols.fDrawArrays(mode, first, count);
1105     AFTER_GL_CALL;
1106   }
1107
1108   void raw_fDrawElements(GLenum mode, GLsizei count, GLenum type,
1109                          const GLvoid* indices) {
1110     BEFORE_GL_CALL;
1111     mSymbols.fDrawElements(mode, count, type, indices);
1112     AFTER_GL_CALL;
1113   }
1114
1115  public:
1116   void fDrawArrays(GLenum mode, GLint first, GLsizei count) {
1117     BeforeGLDrawCall();
1118     raw_fDrawArrays(mode, first, count);
1119     AfterGLDrawCall();
1120   }
1121
1122   void fDrawElements(GLenum mode, GLsizei count, GLenum type,
1123                      const GLvoid* indices) {
1124     BeforeGLDrawCall();
1125     raw_fDrawElements(mode, count, type, indices);
1126     AfterGLDrawCall();
1127   }
1128
1129   void fEnable(GLenum capability) {
1130     BEFORE_GL_CALL;
1131     mSymbols.fEnable(capability);
1132     AFTER_GL_CALL;
1133   }
1134
1135   void fEnableClientState(GLenum capability) {
1136     BEFORE_GL_CALL;
1137     mSymbols.fEnableClientState(capability);
1138     AFTER_GL_CALL;
1139   }
1140
1141   void fEnableVertexAttribArray(GLuint index) {
1142     BEFORE_GL_CALL;
1143     mSymbols.fEnableVertexAttribArray(index);
1144     AFTER_GL_CALL;
1145   }
1146
1147   void fEndQuery(GLenum target) {
1148     BEFORE_GL_CALL;
1149     ASSERT_SYMBOL_PRESENT(fEndQuery);
1150     mSymbols.fEndQuery(target);
1151     AFTER_GL_CALL;
1152   }
1153
1154   void fFinish() {
1155     BEFORE_GL_CALL;
1156     mSymbols.fFinish();
1157     OnSyncCall();
1158     AFTER_GL_CALL;
1159     mHeavyGLCallsSinceLastFlush = false;
1160   }
1161
1162   void fFlush() {
1163     BEFORE_GL_CALL;
1164     mSymbols.fFlush();
1165     AFTER_GL_CALL;
1166     mHeavyGLCallsSinceLastFlush = false;
1167   }
1168
1169   void fFrontFace(GLenum face) {
1170     BEFORE_GL_CALL;
1171     mSymbols.fFrontFace(face);
1172     AFTER_GL_CALL;
1173   }
1174
1175   void fGetActiveAttrib(GLuint program, GLuint index, GLsizei maxLength,
1176                         GLsizei* length, GLint* size, GLenum* type,
1177                         GLchar* name) {
1178     BEFORE_GL_CALL;
1179     mSymbols.fGetActiveAttrib(program, index, maxLength, length, size, type,
1180                               name);
1181     OnSyncCall();
1182     AFTER_GL_CALL;
1183   }
1184
1185   void fGetActiveUniform(GLuint program, GLuint index, GLsizei maxLength,
1186                          GLsizei* length, GLint* size, GLenum* type,
1187                          GLchar* name) {
1188     BEFORE_GL_CALL;
1189     mSymbols.fGetActiveUniform(program, index, maxLength, length, size, type,
1190                                name);
1191     OnSyncCall();
1192     AFTER_GL_CALL;
1193   }
1194
1195   void fGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei* count,
1196                            GLuint* shaders) {
1197     BEFORE_GL_CALL;
1198     mSymbols.fGetAttachedShaders(program, maxCount, count, shaders);
1199     OnSyncCall();
1200     AFTER_GL_CALL;
1201   }
1202
1203   GLint fGetAttribLocation(GLuint program, const GLchar* name) {
1204     GLint retval = 0;
1205     BEFORE_GL_CALL;
1206     retval = mSymbols.fGetAttribLocation(program, name);
1207     OnSyncCall();
1208     AFTER_GL_CALL;
1209     return retval;
1210   }
1211
1212  private:
1213   void raw_fGetIntegerv(GLenum pname, GLint* params) const {
1214     BEFORE_GL_CALL;
1215     mSymbols.fGetIntegerv(pname, params);
1216     OnSyncCall();
1217     AFTER_GL_CALL;
1218   }
1219
1220  public:
1221   void fGetIntegerv(GLenum pname, GLint* params) const;
1222
1223   template <typename T>
1224   void GetInt(const GLenum pname, T* const params) const {
1225     static_assert(sizeof(T) == sizeof(GLint), "Invalid T.");
1226     fGetIntegerv(pname, reinterpret_cast<GLint*>(params));
1227   }
1228
1229   void GetUIntegerv(GLenum pname, GLuint* params) const {
1230     GetInt(pname, params);
1231   }
1232
1233   template <typename T>
1234   T GetIntAs(GLenum pname) const {
1235     static_assert(sizeof(T) == sizeof(GLint), "Invalid T.");
1236     T ret = 0;
1237     fGetIntegerv(pname, (GLint*)&ret);
1238     return ret;
1239   }
1240
1241   void fGetFloatv(GLenum pname, GLfloat* params) const {
1242     BEFORE_GL_CALL;
1243     mSymbols.fGetFloatv(pname, params);
1244     OnSyncCall();
1245     AFTER_GL_CALL;
1246   }
1247
1248   void fGetBooleanv(GLenum pname, realGLboolean* params) const {
1249     BEFORE_GL_CALL;
1250     mSymbols.fGetBooleanv(pname, params);
1251     OnSyncCall();
1252     AFTER_GL_CALL;
1253   }
1254
1255   void fGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) {
1256     BEFORE_GL_CALL;
1257     mSymbols.fGetBufferParameteriv(target, pname, params);
1258     OnSyncCall();
1259     AFTER_GL_CALL;
1260   }
1261
1262   GLuint fGetDebugMessageLog(GLuint count, GLsizei bufsize, GLenum* sources,
1263                              GLenum* types, GLuint* ids, GLenum* severities,
1264                              GLsizei* lengths, GLchar* messageLog) {
1265     GLuint ret = 0;
1266     BEFORE_GL_CALL;
1267     ASSERT_SYMBOL_PRESENT(fGetDebugMessageLog);
1268     ret = mSymbols.fGetDebugMessageLog(count, bufsize, sources, types, ids,
1269                                        severities, lengths, messageLog);
1270     OnSyncCall();
1271     AFTER_GL_CALL;
1272     return ret;
1273   }
1274
1275   void fGetPointerv(GLenum pname, GLvoid** params) {
1276     BEFORE_GL_CALL;
1277     ASSERT_SYMBOL_PRESENT(fGetPointerv);
1278     mSymbols.fGetPointerv(pname, params);
1279     OnSyncCall();
1280     AFTER_GL_CALL;
1281   }
1282
1283   void fGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize,
1284                        GLsizei* length, GLchar* label) {
1285     BEFORE_GL_CALL;
1286     ASSERT_SYMBOL_PRESENT(fGetObjectLabel);
1287     mSymbols.fGetObjectLabel(identifier, name, bufSize, length, label);
1288     OnSyncCall();
1289     AFTER_GL_CALL;
1290   }
1291
1292   void fGetObjectPtrLabel(const GLvoid* ptr, GLsizei bufSize, GLsizei* length,
1293                           GLchar* label) {
1294     BEFORE_GL_CALL;
1295     ASSERT_SYMBOL_PRESENT(fGetObjectPtrLabel);
1296     mSymbols.fGetObjectPtrLabel(ptr, bufSize, length, label);
1297     OnSyncCall();
1298     AFTER_GL_CALL;
1299   }
1300
1301   void fGenerateMipmap(GLenum target) {
1302     BEFORE_GL_CALL;
1303     mSymbols.fGenerateMipmap(target);
1304     AFTER_GL_CALL;
1305   }
1306
1307   void fGetProgramiv(GLuint program, GLenum pname, GLint* param) {
1308     BEFORE_GL_CALL;
1309     mSymbols.fGetProgramiv(program, pname, param);
1310     OnSyncCall();
1311     AFTER_GL_CALL;
1312   }
1313
1314   void fGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei* length,
1315                           GLchar* infoLog) {
1316     BEFORE_GL_CALL;
1317     mSymbols.fGetProgramInfoLog(program, bufSize, length, infoLog);
1318     OnSyncCall();
1319     AFTER_GL_CALL;
1320   }
1321
1322   void fTexParameteri(GLenum target, GLenum pname, GLint param) {
1323     BEFORE_GL_CALL;
1324     mSymbols.fTexParameteri(target, pname, param);
1325     AFTER_GL_CALL;
1326   }
1327
1328   void fTexParameteriv(GLenum target, GLenum pname, const GLint* params) {
1329     BEFORE_GL_CALL;
1330     mSymbols.fTexParameteriv(target, pname, params);
1331     AFTER_GL_CALL;
1332   }
1333
1334   void fTexParameterf(GLenum target, GLenum pname, GLfloat param) {
1335     BEFORE_GL_CALL;
1336     mSymbols.fTexParameterf(target, pname, param);
1337     AFTER_GL_CALL;
1338   }
1339
1340   const GLubyte* fGetString(GLenum name) {
1341     const GLubyte* result = nullptr;
1342     BEFORE_GL_CALL;
1343     result = mSymbols.fGetString(name);
1344     OnSyncCall();
1345     AFTER_GL_CALL;
1346     return result;
1347   }
1348
1349   void fGetTexImage(GLenum target, GLint level, GLenum format, GLenum type,
1350                     GLvoid* img) {
1351     BEFORE_GL_CALL;
1352     ASSERT_SYMBOL_PRESENT(fGetTexImage);
1353     mSymbols.fGetTexImage(target, level, format, type, img);
1354     OnSyncCall();
1355     AFTER_GL_CALL;
1356   }
1357
1358   void fGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname,
1359                                GLint* params) {
1360     BEFORE_GL_CALL;
1361     ASSERT_SYMBOL_PRESENT(fGetTexLevelParameteriv);
1362     mSymbols.fGetTexLevelParameteriv(target, level, pname, params);
1363     OnSyncCall();
1364     AFTER_GL_CALL;
1365   }
1366
1367   void fGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) {
1368     BEFORE_GL_CALL;
1369     mSymbols.fGetTexParameterfv(target, pname, params);
1370     OnSyncCall();
1371     AFTER_GL_CALL;
1372   }
1373
1374   void fGetTexParameteriv(GLenum target, GLenum pname, GLint* params) {
1375     BEFORE_GL_CALL;
1376     mSymbols.fGetTexParameteriv(target, pname, params);
1377     OnSyncCall();
1378     AFTER_GL_CALL;
1379   }
1380
1381   void fGetUniformfv(GLuint program, GLint location, GLfloat* params) {
1382     BEFORE_GL_CALL;
1383     mSymbols.fGetUniformfv(program, location, params);
1384     OnSyncCall();
1385     AFTER_GL_CALL;
1386   }
1387
1388   void fGetUniformiv(GLuint program, GLint location, GLint* params) {
1389     BEFORE_GL_CALL;
1390     mSymbols.fGetUniformiv(program, location, params);
1391     OnSyncCall();
1392     AFTER_GL_CALL;
1393   }
1394
1395   void fGetUniformuiv(GLuint program, GLint location, GLuint* params) {
1396     BEFORE_GL_CALL;
1397     ASSERT_SYMBOL_PRESENT(fGetUniformuiv);
1398     mSymbols.fGetUniformuiv(program, location, params);
1399     OnSyncCall();
1400     AFTER_GL_CALL;
1401   }
1402
1403   GLint fGetUniformLocation(GLuint programObj, const GLchar* name) {
1404     GLint retval = 0;
1405     BEFORE_GL_CALL;
1406     retval = mSymbols.fGetUniformLocation(programObj, name);
1407     OnSyncCall();
1408     AFTER_GL_CALL;
1409     return retval;
1410   }
1411
1412   void fGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* retval) {
1413     BEFORE_GL_CALL;
1414     mSymbols.fGetVertexAttribfv(index, pname, retval);
1415     OnSyncCall();
1416     AFTER_GL_CALL;
1417   }
1418
1419   void fGetVertexAttribiv(GLuint index, GLenum pname, GLint* retval) {
1420     BEFORE_GL_CALL;
1421     mSymbols.fGetVertexAttribiv(index, pname, retval);
1422     OnSyncCall();
1423     AFTER_GL_CALL;
1424   }
1425
1426   void fGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** retval) {
1427     BEFORE_GL_CALL;
1428     mSymbols.fGetVertexAttribPointerv(index, pname, retval);
1429     OnSyncCall();
1430     AFTER_GL_CALL;
1431   }
1432
1433   void fHint(GLenum target, GLenum mode) {
1434     BEFORE_GL_CALL;
1435     mSymbols.fHint(target, mode);
1436     AFTER_GL_CALL;
1437   }
1438
1439   realGLboolean fIsBuffer(GLuint buffer) {
1440     realGLboolean retval = false;
1441     BEFORE_GL_CALL;
1442     retval = mSymbols.fIsBuffer(buffer);
1443     OnSyncCall();
1444     AFTER_GL_CALL;
1445     return retval;
1446   }
1447
1448   realGLboolean fIsEnabled(GLenum capability) {
1449     realGLboolean retval = false;
1450     BEFORE_GL_CALL;
1451     retval = mSymbols.fIsEnabled(capability);
1452     AFTER_GL_CALL;
1453     return retval;
1454   }
1455
1456   void SetEnabled(const GLenum cap, const bool val) {
1457     if (val) {
1458       fEnable(cap);
1459     } else {
1460       fDisable(cap);
1461     }
1462   }
1463
1464   bool PushEnabled(const GLenum cap, const bool newVal) {
1465     const bool oldVal = fIsEnabled(cap);
1466     if (oldVal != newVal) {
1467       SetEnabled(cap, newVal);
1468     }
1469     return oldVal;
1470   }
1471
1472   realGLboolean fIsProgram(GLuint program) {
1473     realGLboolean retval = false;
1474     BEFORE_GL_CALL;
1475     retval = mSymbols.fIsProgram(program);
1476     AFTER_GL_CALL;
1477     return retval;
1478   }
1479
1480   realGLboolean fIsShader(GLuint shader) {
1481     realGLboolean retval = false;
1482     BEFORE_GL_CALL;
1483     retval = mSymbols.fIsShader(shader);
1484     AFTER_GL_CALL;
1485     return retval;
1486   }
1487
1488   realGLboolean fIsTexture(GLuint texture) {
1489     realGLboolean retval = false;
1490     BEFORE_GL_CALL;
1491     retval = mSymbols.fIsTexture(texture);
1492     AFTER_GL_CALL;
1493     return retval;
1494   }
1495
1496   void fLineWidth(GLfloat width) {
1497     BEFORE_GL_CALL;
1498     mSymbols.fLineWidth(width);
1499     AFTER_GL_CALL;
1500   }
1501
1502   void fLinkProgram(GLuint program) {
1503     BEFORE_GL_CALL;
1504     mSymbols.fLinkProgram(program);
1505     AFTER_GL_CALL;
1506   }
1507
1508   void fObjectLabel(GLenum identifier, GLuint name, GLsizei length,
1509                     const GLchar* label) {
1510     BEFORE_GL_CALL;
1511     ASSERT_SYMBOL_PRESENT(fObjectLabel);
1512     mSymbols.fObjectLabel(identifier, name, length, label);
1513     AFTER_GL_CALL;
1514   }
1515
1516   void fObjectPtrLabel(const GLvoid* ptr, GLsizei length, const GLchar* label) {
1517     BEFORE_GL_CALL;
1518     ASSERT_SYMBOL_PRESENT(fObjectPtrLabel);
1519     mSymbols.fObjectPtrLabel(ptr, length, label);
1520     AFTER_GL_CALL;
1521   }
1522
1523   void fLoadIdentity() {
1524     BEFORE_GL_CALL;
1525     mSymbols.fLoadIdentity();
1526     AFTER_GL_CALL;
1527   }
1528
1529   void fLoadMatrixf(const GLfloat* matrix) {
1530     BEFORE_GL_CALL;
1531     mSymbols.fLoadMatrixf(matrix);
1532     AFTER_GL_CALL;
1533   }
1534
1535   void fMatrixMode(GLenum mode) {
1536     BEFORE_GL_CALL;
1537     mSymbols.fMatrixMode(mode);
1538     AFTER_GL_CALL;
1539   }
1540
1541   void fPixelStorei(GLenum pname, GLint param) {
1542     BEFORE_GL_CALL;
1543     mSymbols.fPixelStorei(pname, param);
1544     AFTER_GL_CALL;
1545   }
1546
1547   void fTextureRangeAPPLE(GLenum target, GLsizei length, GLvoid* pointer) {
1548     ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(pointer);
1549     BEFORE_GL_CALL;
1550     mSymbols.fTextureRangeAPPLE(target, length, pointer);
1551     AFTER_GL_CALL;
1552   }
1553
1554   void fPointParameterf(GLenum pname, GLfloat param) {
1555     BEFORE_GL_CALL;
1556     mSymbols.fPointParameterf(pname, param);
1557     AFTER_GL_CALL;
1558   }
1559
1560   void fPolygonMode(GLenum face, GLenum mode) {
1561     BEFORE_GL_CALL;
1562     mSymbols.fPolygonMode(face, mode);
1563     AFTER_GL_CALL;
1564   }
1565
1566   void fPolygonOffset(GLfloat factor, GLfloat bias) {
1567     BEFORE_GL_CALL;
1568     mSymbols.fPolygonOffset(factor, bias);
1569     AFTER_GL_CALL;
1570   }
1571
1572   void fPopDebugGroup() {
1573     BEFORE_GL_CALL;
1574     ASSERT_SYMBOL_PRESENT(fPopDebugGroup);
1575     mSymbols.fPopDebugGroup();
1576     AFTER_GL_CALL;
1577   }
1578
1579   void fPushDebugGroup(GLenum source, GLuint id, GLsizei length,
1580                        const GLchar* message) {
1581     BEFORE_GL_CALL;
1582     ASSERT_SYMBOL_PRESENT(fPushDebugGroup);
1583     mSymbols.fPushDebugGroup(source, id, length, message);
1584     AFTER_GL_CALL;
1585   }
1586
1587   void fReadBuffer(GLenum mode) {
1588     BEFORE_GL_CALL;
1589     mSymbols.fReadBuffer(mode);
1590     AFTER_GL_CALL;
1591   }
1592
1593   void raw_fReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
1594                        GLenum format, GLenum type, GLvoid* pixels) {
1595     BEFORE_GL_CALL;
1596     mSymbols.fReadPixels(x, y, width, height, format, type, pixels);
1597     OnSyncCall();
1598     AFTER_GL_CALL;
1599     mHeavyGLCallsSinceLastFlush = true;
1600   }
1601
1602   void fReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
1603                    GLenum format, GLenum type, GLvoid* pixels);
1604
1605  public:
1606   void fSampleCoverage(GLclampf value, realGLboolean invert) {
1607     BEFORE_GL_CALL;
1608     mSymbols.fSampleCoverage(value, invert);
1609     AFTER_GL_CALL;
1610   }
1611
1612   void fScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
1613     if (mScissorRect[0] == x && mScissorRect[1] == y &&
1614         mScissorRect[2] == width && mScissorRect[3] == height) {
1615       return;
1616     }
1617     mScissorRect[0] = x;
1618     mScissorRect[1] = y;
1619     mScissorRect[2] = width;
1620     mScissorRect[3] = height;
1621     BEFORE_GL_CALL;
1622     mSymbols.fScissor(x, y, width, height);
1623     AFTER_GL_CALL;
1624   }
1625
1626   void fStencilFunc(GLenum func, GLint reference, GLuint mask) {
1627     BEFORE_GL_CALL;
1628     mSymbols.fStencilFunc(func, reference, mask);
1629     AFTER_GL_CALL;
1630   }
1631
1632   void fStencilFuncSeparate(GLenum frontfunc, GLenum backfunc, GLint reference,
1633                             GLuint mask) {
1634     BEFORE_GL_CALL;
1635     mSymbols.fStencilFuncSeparate(frontfunc, backfunc, reference, mask);
1636     AFTER_GL_CALL;
1637   }
1638
1639   void fStencilMask(GLuint mask) {
1640     BEFORE_GL_CALL;
1641     mSymbols.fStencilMask(mask);
1642     AFTER_GL_CALL;
1643   }
1644
1645   void fStencilMaskSeparate(GLenum face, GLuint mask) {
1646     BEFORE_GL_CALL;
1647     mSymbols.fStencilMaskSeparate(face, mask);
1648     AFTER_GL_CALL;
1649   }
1650
1651   void fStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
1652     BEFORE_GL_CALL;
1653     mSymbols.fStencilOp(fail, zfail, zpass);
1654     AFTER_GL_CALL;
1655   }
1656
1657   void fStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail,
1658                           GLenum dppass) {
1659     BEFORE_GL_CALL;
1660     mSymbols.fStencilOpSeparate(face, sfail, dpfail, dppass);
1661     AFTER_GL_CALL;
1662   }
1663
1664   void fTexGeni(GLenum coord, GLenum pname, GLint param) {
1665     BEFORE_GL_CALL;
1666     mSymbols.fTexGeni(coord, pname, param);
1667     AFTER_GL_CALL;
1668   }
1669
1670   void fTexGenf(GLenum coord, GLenum pname, GLfloat param) {
1671     BEFORE_GL_CALL;
1672     mSymbols.fTexGenf(coord, pname, param);
1673     AFTER_GL_CALL;
1674   }
1675
1676   void fTexGenfv(GLenum coord, GLenum pname, const GLfloat* params) {
1677     BEFORE_GL_CALL;
1678     mSymbols.fTexGenfv(coord, pname, params);
1679     AFTER_GL_CALL;
1680   }
1681
1682  private:
1683   void raw_fTexImage2D(GLenum target, GLint level, GLint internalformat,
1684                        GLsizei width, GLsizei height, GLint border,
1685                        GLenum format, GLenum type, const GLvoid* pixels) {
1686     ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(pixels);
1687     BEFORE_GL_CALL;
1688     mSymbols.fTexImage2D(target, level, internalformat, width, height, border,
1689                          format, type, pixels);
1690     AFTER_GL_CALL;
1691     mHeavyGLCallsSinceLastFlush = true;
1692   }
1693
1694  public:
1695   void fTexImage2D(GLenum target, GLint level, GLint internalformat,
1696                    GLsizei width, GLsizei height, GLint border, GLenum format,
1697                    GLenum type, const GLvoid* pixels);
1698
1699   void fTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
1700                       GLsizei width, GLsizei height, GLenum format, GLenum type,
1701                       const GLvoid* pixels) {
1702     ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(pixels);
1703     BEFORE_GL_CALL;
1704     mSymbols.fTexSubImage2D(target, level, xoffset, yoffset, width, height,
1705                             format, type, pixels);
1706     AFTER_GL_CALL;
1707     mHeavyGLCallsSinceLastFlush = true;
1708   }
1709
1710   void fUniform1f(GLint location, GLfloat v0) {
1711     BEFORE_GL_CALL;
1712     mSymbols.fUniform1f(location, v0);
1713     AFTER_GL_CALL;
1714   }
1715
1716   void fUniform1fv(GLint location, GLsizei count, const GLfloat* value) {
1717     BEFORE_GL_CALL;
1718     mSymbols.fUniform1fv(location, count, value);
1719     AFTER_GL_CALL;
1720   }
1721
1722   void fUniform1i(GLint location, GLint v0) {
1723     BEFORE_GL_CALL;
1724     mSymbols.fUniform1i(location, v0);
1725     AFTER_GL_CALL;
1726   }
1727
1728   void fUniform1iv(GLint location, GLsizei count, const GLint* value) {
1729     BEFORE_GL_CALL;
1730     mSymbols.fUniform1iv(location, count, value);
1731     AFTER_GL_CALL;
1732   }
1733
1734   void fUniform2f(GLint location, GLfloat v0, GLfloat v1) {
1735     BEFORE_GL_CALL;
1736     mSymbols.fUniform2f(location, v0, v1);
1737     AFTER_GL_CALL;
1738   }
1739
1740   void fUniform2fv(GLint location, GLsizei count, const GLfloat* value) {
1741     BEFORE_GL_CALL;
1742     mSymbols.fUniform2fv(location, count, value);
1743     AFTER_GL_CALL;
1744   }
1745
1746   void fUniform2i(GLint location, GLint v0, GLint v1) {
1747     BEFORE_GL_CALL;
1748     mSymbols.fUniform2i(location, v0, v1);
1749     AFTER_GL_CALL;
1750   }
1751
1752   void fUniform2iv(GLint location, GLsizei count, const GLint* value) {
1753     BEFORE_GL_CALL;
1754     mSymbols.fUniform2iv(location, count, value);
1755     AFTER_GL_CALL;
1756   }
1757
1758   void fUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
1759     BEFORE_GL_CALL;
1760     mSymbols.fUniform3f(location, v0, v1, v2);
1761     AFTER_GL_CALL;
1762   }
1763
1764   void fUniform3fv(GLint location, GLsizei count, const GLfloat* value) {
1765     BEFORE_GL_CALL;
1766     mSymbols.fUniform3fv(location, count, value);
1767     AFTER_GL_CALL;
1768   }
1769
1770   void fUniform3i(GLint location, GLint v0, GLint v1, GLint v2) {
1771     BEFORE_GL_CALL;
1772     mSymbols.fUniform3i(location, v0, v1, v2);
1773     AFTER_GL_CALL;
1774   }
1775
1776   void fUniform3iv(GLint location, GLsizei count, const GLint* value) {
1777     BEFORE_GL_CALL;
1778     mSymbols.fUniform3iv(location, count, value);
1779     AFTER_GL_CALL;
1780   }
1781
1782   void fUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2,
1783                   GLfloat v3) {
1784     BEFORE_GL_CALL;
1785     mSymbols.fUniform4f(location, v0, v1, v2, v3);
1786     AFTER_GL_CALL;
1787   }
1788
1789   void fUniform4fv(GLint location, GLsizei count, const GLfloat* value) {
1790     BEFORE_GL_CALL;
1791     mSymbols.fUniform4fv(location, count, value);
1792     AFTER_GL_CALL;
1793   }
1794
1795   void fUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {
1796     BEFORE_GL_CALL;
1797     mSymbols.fUniform4i(location, v0, v1, v2, v3);
1798     AFTER_GL_CALL;
1799   }
1800
1801   void fUniform4iv(GLint location, GLsizei count, const GLint* value) {
1802     BEFORE_GL_CALL;
1803     mSymbols.fUniform4iv(location, count, value);
1804     AFTER_GL_CALL;
1805   }
1806
1807   void fUniformMatrix2fv(GLint location, GLsizei count, realGLboolean transpose,
1808                          const GLfloat* value) {
1809     BEFORE_GL_CALL;
1810     mSymbols.fUniformMatrix2fv(location, count, transpose, value);
1811     AFTER_GL_CALL;
1812   }
1813
1814   void fUniformMatrix2x3fv(GLint location, GLsizei count,
1815                            realGLboolean transpose, const GLfloat* value) {
1816     BEFORE_GL_CALL;
1817     ASSERT_SYMBOL_PRESENT(fUniformMatrix2x3fv);
1818     mSymbols.fUniformMatrix2x3fv(location, count, transpose, value);
1819     AFTER_GL_CALL;
1820   }
1821
1822   void fUniformMatrix2x4fv(GLint location, GLsizei count,
1823                            realGLboolean transpose, const GLfloat* value) {
1824     BEFORE_GL_CALL;
1825     ASSERT_SYMBOL_PRESENT(fUniformMatrix2x4fv);
1826     mSymbols.fUniformMatrix2x4fv(location, count, transpose, value);
1827     AFTER_GL_CALL;
1828   }
1829
1830   void fUniformMatrix3fv(GLint location, GLsizei count, realGLboolean transpose,
1831                          const GLfloat* value) {
1832     BEFORE_GL_CALL;
1833     mSymbols.fUniformMatrix3fv(location, count, transpose, value);
1834     AFTER_GL_CALL;
1835   }
1836
1837   void fUniformMatrix3x2fv(GLint location, GLsizei count,
1838                            realGLboolean transpose, const GLfloat* value) {
1839     BEFORE_GL_CALL;
1840     ASSERT_SYMBOL_PRESENT(fUniformMatrix3x2fv);
1841     mSymbols.fUniformMatrix3x2fv(location, count, transpose, value);
1842     AFTER_GL_CALL;
1843   }
1844
1845   void fUniformMatrix3x4fv(GLint location, GLsizei count,
1846                            realGLboolean transpose, const GLfloat* value) {
1847     BEFORE_GL_CALL;
1848     ASSERT_SYMBOL_PRESENT(fUniformMatrix3x4fv);
1849     mSymbols.fUniformMatrix3x4fv(location, count, transpose, value);
1850     AFTER_GL_CALL;
1851   }
1852
1853   void fUniformMatrix4fv(GLint location, GLsizei count, realGLboolean transpose,
1854                          const GLfloat* value) {
1855     BEFORE_GL_CALL;
1856     mSymbols.fUniformMatrix4fv(location, count, transpose, value);
1857     AFTER_GL_CALL;
1858   }
1859
1860   void fUniformMatrix4x2fv(GLint location, GLsizei count,
1861                            realGLboolean transpose, const GLfloat* value) {
1862     BEFORE_GL_CALL;
1863     ASSERT_SYMBOL_PRESENT(fUniformMatrix4x2fv);
1864     mSymbols.fUniformMatrix4x2fv(location, count, transpose, value);
1865     AFTER_GL_CALL;
1866   }
1867
1868   void fUniformMatrix4x3fv(GLint location, GLsizei count,
1869                            realGLboolean transpose, const GLfloat* value) {
1870     BEFORE_GL_CALL;
1871     ASSERT_SYMBOL_PRESENT(fUniformMatrix4x3fv);
1872     mSymbols.fUniformMatrix4x3fv(location, count, transpose, value);
1873     AFTER_GL_CALL;
1874   }
1875
1876   void fUseProgram(GLuint program) {
1877     BEFORE_GL_CALL;
1878     mSymbols.fUseProgram(program);
1879     AFTER_GL_CALL;
1880   }
1881
1882   void fValidateProgram(GLuint program) {
1883     BEFORE_GL_CALL;
1884     mSymbols.fValidateProgram(program);
1885     AFTER_GL_CALL;
1886   }
1887
1888   void fVertexAttribPointer(GLuint index, GLint size, GLenum type,
1889                             realGLboolean normalized, GLsizei stride,
1890                             const GLvoid* pointer) {
1891     BEFORE_GL_CALL;
1892     mSymbols.fVertexAttribPointer(index, size, type, normalized, stride,
1893                                   pointer);
1894     AFTER_GL_CALL;
1895   }
1896
1897   void fVertexAttrib1f(GLuint index, GLfloat x) {
1898     BEFORE_GL_CALL;
1899     mSymbols.fVertexAttrib1f(index, x);
1900     AFTER_GL_CALL;
1901   }
1902
1903   void fVertexAttrib2f(GLuint index, GLfloat x, GLfloat y) {
1904     BEFORE_GL_CALL;
1905     mSymbols.fVertexAttrib2f(index, x, y);
1906     AFTER_GL_CALL;
1907   }
1908
1909   void fVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z) {
1910     BEFORE_GL_CALL;
1911     mSymbols.fVertexAttrib3f(index, x, y, z);
1912     AFTER_GL_CALL;
1913   }
1914
1915   void fVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z,
1916                        GLfloat w) {
1917     BEFORE_GL_CALL;
1918     mSymbols.fVertexAttrib4f(index, x, y, z, w);
1919     AFTER_GL_CALL;
1920   }
1921
1922   void fVertexAttrib1fv(GLuint index, const GLfloat* v) {
1923     BEFORE_GL_CALL;
1924     mSymbols.fVertexAttrib1fv(index, v);
1925     AFTER_GL_CALL;
1926   }
1927
1928   void fVertexAttrib2fv(GLuint index, const GLfloat* v) {
1929     BEFORE_GL_CALL;
1930     mSymbols.fVertexAttrib2fv(index, v);
1931     AFTER_GL_CALL;
1932   }
1933
1934   void fVertexAttrib3fv(GLuint index, const GLfloat* v) {
1935     BEFORE_GL_CALL;
1936     mSymbols.fVertexAttrib3fv(index, v);
1937     AFTER_GL_CALL;
1938   }
1939
1940   void fVertexAttrib4fv(GLuint index, const GLfloat* v) {
1941     BEFORE_GL_CALL;
1942     mSymbols.fVertexAttrib4fv(index, v);
1943     AFTER_GL_CALL;
1944   }
1945
1946   void fVertexPointer(GLint size, GLenum type, GLsizei stride,
1947                       const GLvoid* pointer) {
1948     BEFORE_GL_CALL;
1949     mSymbols.fVertexPointer(size, type, stride, pointer);
1950     AFTER_GL_CALL;
1951   }
1952
1953   void fViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
1954     if (mViewportRect[0] == x && mViewportRect[1] == y &&
1955         mViewportRect[2] == width && mViewportRect[3] == height) {
1956       return;
1957     }
1958     mViewportRect[0] = x;
1959     mViewportRect[1] = y;
1960     mViewportRect[2] = width;
1961     mViewportRect[3] = height;
1962     BEFORE_GL_CALL;
1963     mSymbols.fViewport(x, y, width, height);
1964     AFTER_GL_CALL;
1965   }
1966
1967   void fCompileShader(GLuint shader) {
1968     BEFORE_GL_CALL;
1969     mSymbols.fCompileShader(shader);
1970     AFTER_GL_CALL;
1971   }
1972
1973  private:
1974   friend class SharedSurface_IOSurface;
1975
1976   void raw_fCopyTexImage2D(GLenum target, GLint level, GLenum internalformat,
1977                            GLint x, GLint y, GLsizei width, GLsizei height,
1978                            GLint border) {
1979     BEFORE_GL_CALL;
1980     mSymbols.fCopyTexImage2D(target, level, internalformat, x, y, width, height,
1981                              border);
1982     AFTER_GL_CALL;
1983   }
1984
1985   void raw_fCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset,
1986                               GLint yoffset, GLint x, GLint y, GLsizei width,
1987                               GLsizei height) {
1988     BEFORE_GL_CALL;
1989     mSymbols.fCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width,
1990                                 height);
1991     AFTER_GL_CALL;
1992   }
1993
1994  public:
1995   void fGetShaderiv(GLuint shader, GLenum pname, GLint* param) {
1996     BEFORE_GL_CALL;
1997     mSymbols.fGetShaderiv(shader, pname, param);
1998     OnSyncCall();
1999     AFTER_GL_CALL;
2000   }
2001
2002   void fGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei* length,
2003                          GLchar* infoLog) {
2004     BEFORE_GL_CALL;
2005     mSymbols.fGetShaderInfoLog(shader, bufSize, length, infoLog);
2006     OnSyncCall();
2007     AFTER_GL_CALL;
2008   }
2009
2010  private:
2011   void raw_fGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
2012                                      GLint* range, GLint* precision) {
2013     MOZ_ASSERT(IsGLES());
2014
2015     BEFORE_GL_CALL;
2016     ASSERT_SYMBOL_PRESENT(fGetShaderPrecisionFormat);
2017     mSymbols.fGetShaderPrecisionFormat(shadertype, precisiontype, range,
2018                                        precision);
2019     OnSyncCall();
2020     AFTER_GL_CALL;
2021   }
2022
2023  public:
2024   void fGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
2025                                  GLint* range, GLint* precision) {
2026     if (IsGLES()) {
2027       raw_fGetShaderPrecisionFormat(shadertype, precisiontype, range,
2028                                     precision);
2029     } else {
2030       // Fall back to automatic values because almost all desktop hardware
2031       // supports the OpenGL standard precisions.
2032       GetShaderPrecisionFormatNonES2(shadertype, precisiontype, range,
2033                                      precision);
2034     }
2035   }
2036
2037   void fGetShaderSource(GLint obj, GLsizei maxLength, GLsizei* length,
2038                         GLchar* source) {
2039     BEFORE_GL_CALL;
2040     mSymbols.fGetShaderSource(obj, maxLength, length, source);
2041     OnSyncCall();
2042     AFTER_GL_CALL;
2043   }
2044
2045   void fShaderSource(GLuint shader, GLsizei count, const GLchar* const* strings,
2046                      const GLint* lengths) {
2047     BEFORE_GL_CALL;
2048     mSymbols.fShaderSource(shader, count, strings, lengths);
2049     AFTER_GL_CALL;
2050   }
2051
2052  private:
2053   mutable GLuint mCachedDrawFb = 0;
2054   mutable GLuint mCachedReadFb = 0;
2055
2056  public:
2057   bool mElideDuplicateBindFramebuffers = false;
2058
2059   // If e.g. GL_DRAW_FRAMEBUFFER isn't supported, will bind GL_FRAMEBUFFER.
2060   void fBindFramebuffer(GLenum target, const GLuint fb) const {
2061     if (!IsSupported(gl::GLFeature::framebuffer_blit)) {
2062       target = LOCAL_GL_FRAMEBUFFER;
2063     }
2064     if (mElideDuplicateBindFramebuffers) {
2065       MOZ_ASSERT(mCachedDrawFb ==
2066                  GetIntAs<GLuint>(LOCAL_GL_DRAW_FRAMEBUFFER_BINDING));
2067       MOZ_ASSERT(mCachedReadFb ==
2068                  GetIntAs<GLuint>(LOCAL_GL_READ_FRAMEBUFFER_BINDING));
2069
2070       switch (target) {
2071         case LOCAL_GL_FRAMEBUFFER:
2072           if (mCachedDrawFb == fb && mCachedReadFb == fb) return;
2073           break;
2074         case LOCAL_GL_DRAW_FRAMEBUFFER:
2075           if (mCachedDrawFb == fb) return;
2076           break;
2077         case LOCAL_GL_READ_FRAMEBUFFER:
2078           if (mCachedReadFb == fb) return;
2079           break;
2080       }
2081     }
2082
2083     BEFORE_GL_CALL;
2084     mSymbols.fBindFramebuffer(target, fb);
2085     AFTER_GL_CALL;
2086
2087     switch (target) {
2088       case LOCAL_GL_FRAMEBUFFER:
2089         mCachedDrawFb = fb;
2090         mCachedReadFb = fb;
2091         break;
2092       case LOCAL_GL_DRAW_FRAMEBUFFER:
2093         mCachedDrawFb = fb;
2094         break;
2095       case LOCAL_GL_READ_FRAMEBUFFER:
2096         mCachedReadFb = fb;
2097         break;
2098     }
2099   }
2100
2101   void fBindRenderbuffer(GLenum target, GLuint renderbuffer) {
2102     BEFORE_GL_CALL;
2103     mSymbols.fBindRenderbuffer(target, renderbuffer);
2104     AFTER_GL_CALL;
2105   }
2106
2107   GLenum fCheckFramebufferStatus(GLenum target) {
2108     GLenum retval = 0;
2109     BEFORE_GL_CALL;
2110     retval = mSymbols.fCheckFramebufferStatus(target);
2111     OnSyncCall();
2112     AFTER_GL_CALL;
2113     return retval;
2114   }
2115
2116   void fFramebufferRenderbuffer(GLenum target, GLenum attachmentPoint,
2117                                 GLenum renderbufferTarget,
2118                                 GLuint renderbuffer) {
2119     BEFORE_GL_CALL;
2120     mSymbols.fFramebufferRenderbuffer(target, attachmentPoint,
2121                                       renderbufferTarget, renderbuffer);
2122     AFTER_GL_CALL;
2123   }
2124
2125   void fFramebufferTexture2D(GLenum target, GLenum attachmentPoint,
2126                              GLenum textureTarget, GLuint texture,
2127                              GLint level) {
2128     BEFORE_GL_CALL;
2129     mSymbols.fFramebufferTexture2D(target, attachmentPoint, textureTarget,
2130                                    texture, level);
2131     AFTER_GL_CALL;
2132   }
2133
2134   void fFramebufferTextureLayer(GLenum target, GLenum attachment,
2135                                 GLuint texture, GLint level, GLint layer) {
2136     BEFORE_GL_CALL;
2137     ASSERT_SYMBOL_PRESENT(fFramebufferTextureLayer);
2138     mSymbols.fFramebufferTextureLayer(target, attachment, texture, level,
2139                                       layer);
2140     AFTER_GL_CALL;
2141   }
2142
2143   void fGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment,
2144                                             GLenum pname, GLint* value) {
2145     BEFORE_GL_CALL;
2146     mSymbols.fGetFramebufferAttachmentParameteriv(target, attachment, pname,
2147                                                   value);
2148     OnSyncCall();
2149     AFTER_GL_CALL;
2150   }
2151
2152   void fGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* value) {
2153     BEFORE_GL_CALL;
2154     mSymbols.fGetRenderbufferParameteriv(target, pname, value);
2155     OnSyncCall();
2156     AFTER_GL_CALL;
2157   }
2158
2159   realGLboolean fIsFramebuffer(GLuint framebuffer) {
2160     realGLboolean retval = false;
2161     BEFORE_GL_CALL;
2162     retval = mSymbols.fIsFramebuffer(framebuffer);
2163     OnSyncCall();
2164     AFTER_GL_CALL;
2165     return retval;
2166   }
2167
2168  public:
2169   realGLboolean fIsRenderbuffer(GLuint renderbuffer) {
2170     realGLboolean retval = false;
2171     BEFORE_GL_CALL;
2172     retval = mSymbols.fIsRenderbuffer(renderbuffer);
2173     OnSyncCall();
2174     AFTER_GL_CALL;
2175     return retval;
2176   }
2177
2178   void fRenderbufferStorage(GLenum target, GLenum internalFormat, GLsizei width,
2179                             GLsizei height) {
2180     BEFORE_GL_CALL;
2181     mSymbols.fRenderbufferStorage(target, internalFormat, width, height);
2182     AFTER_GL_CALL;
2183   }
2184
2185  private:
2186   void raw_fDepthRange(GLclampf a, GLclampf b) {
2187     MOZ_ASSERT(!IsGLES());
2188
2189     BEFORE_GL_CALL;
2190     ASSERT_SYMBOL_PRESENT(fDepthRange);
2191     mSymbols.fDepthRange(a, b);
2192     AFTER_GL_CALL;
2193   }
2194
2195   void raw_fDepthRangef(GLclampf a, GLclampf b) {
2196     MOZ_ASSERT(IsGLES());
2197
2198     BEFORE_GL_CALL;
2199     ASSERT_SYMBOL_PRESENT(fDepthRangef);
2200     mSymbols.fDepthRangef(a, b);
2201     AFTER_GL_CALL;
2202   }
2203
2204   void raw_fClearDepth(GLclampf v) {
2205     MOZ_ASSERT(!IsGLES());
2206
2207     BEFORE_GL_CALL;
2208     ASSERT_SYMBOL_PRESENT(fClearDepth);
2209     mSymbols.fClearDepth(v);
2210     AFTER_GL_CALL;
2211   }
2212
2213   void raw_fClearDepthf(GLclampf v) {
2214     MOZ_ASSERT(IsGLES());
2215
2216     BEFORE_GL_CALL;
2217     ASSERT_SYMBOL_PRESENT(fClearDepthf);
2218     mSymbols.fClearDepthf(v);
2219     AFTER_GL_CALL;
2220   }
2221
2222  public:
2223   void fDepthRange(GLclampf a, GLclampf b) {
2224     if (IsGLES()) {
2225       raw_fDepthRangef(a, b);
2226     } else {
2227       raw_fDepthRange(a, b);
2228     }
2229   }
2230
2231   void fClearDepth(GLclampf v) {
2232     if (IsGLES()) {
2233       raw_fClearDepthf(v);
2234     } else {
2235       raw_fClearDepth(v);
2236     }
2237   }
2238
2239   void* fMapBuffer(GLenum target, GLenum access) {
2240     void* ret = nullptr;
2241     BEFORE_GL_CALL;
2242     ASSERT_SYMBOL_PRESENT(fMapBuffer);
2243     ret = mSymbols.fMapBuffer(target, access);
2244     OnSyncCall();
2245     AFTER_GL_CALL;
2246     return ret;
2247   }
2248
2249   realGLboolean fUnmapBuffer(GLenum target) {
2250     realGLboolean ret = false;
2251     BEFORE_GL_CALL;
2252     ASSERT_SYMBOL_PRESENT(fUnmapBuffer);
2253     ret = mSymbols.fUnmapBuffer(target);
2254     AFTER_GL_CALL;
2255     return ret;
2256   }
2257
2258  private:
2259   GLuint raw_fCreateProgram() {
2260     GLuint ret = 0;
2261     BEFORE_GL_CALL;
2262     ret = mSymbols.fCreateProgram();
2263     AFTER_GL_CALL;
2264     return ret;
2265   }
2266
2267   GLuint raw_fCreateShader(GLenum t) {
2268     GLuint ret = 0;
2269     BEFORE_GL_CALL;
2270     ret = mSymbols.fCreateShader(t);
2271     AFTER_GL_CALL;
2272     return ret;
2273   }
2274
2275   void raw_fGenBuffers(GLsizei n, GLuint* names) {
2276     BEFORE_GL_CALL;
2277     mSymbols.fGenBuffers(n, names);
2278     OnSyncCall();
2279     AFTER_GL_CALL;
2280   }
2281
2282   void raw_fGenFramebuffers(GLsizei n, GLuint* names) {
2283     BEFORE_GL_CALL;
2284     mSymbols.fGenFramebuffers(n, names);
2285     OnSyncCall();
2286     AFTER_GL_CALL;
2287   }
2288
2289   void raw_fGenRenderbuffers(GLsizei n, GLuint* names) {
2290     BEFORE_GL_CALL;
2291     mSymbols.fGenRenderbuffers(n, names);
2292     OnSyncCall();
2293     AFTER_GL_CALL;
2294   }
2295
2296   void raw_fGenTextures(GLsizei n, GLuint* names) {
2297     BEFORE_GL_CALL;
2298     mSymbols.fGenTextures(n, names);
2299     OnSyncCall();
2300     AFTER_GL_CALL;
2301   }
2302
2303  public:
2304   GLuint fCreateProgram() {
2305     GLuint ret = raw_fCreateProgram();
2306     TRACKING_CONTEXT(CreatedProgram(this, ret));
2307     return ret;
2308   }
2309
2310   GLuint fCreateShader(GLenum t) {
2311     GLuint ret = raw_fCreateShader(t);
2312     TRACKING_CONTEXT(CreatedShader(this, ret));
2313     return ret;
2314   }
2315
2316   void fGenBuffers(GLsizei n, GLuint* names) {
2317     raw_fGenBuffers(n, names);
2318     TRACKING_CONTEXT(CreatedBuffers(this, n, names));
2319   }
2320
2321   void fGenFramebuffers(GLsizei n, GLuint* names) {
2322     raw_fGenFramebuffers(n, names);
2323     TRACKING_CONTEXT(CreatedFramebuffers(this, n, names));
2324   }
2325
2326   void fGenRenderbuffers(GLsizei n, GLuint* names) {
2327     raw_fGenRenderbuffers(n, names);
2328     TRACKING_CONTEXT(CreatedRenderbuffers(this, n, names));
2329   }
2330
2331   void fGenTextures(GLsizei n, GLuint* names) {
2332     raw_fGenTextures(n, names);
2333     TRACKING_CONTEXT(CreatedTextures(this, n, names));
2334   }
2335
2336  private:
2337   void raw_fDeleteProgram(GLuint program) {
2338     BEFORE_GL_CALL;
2339     mSymbols.fDeleteProgram(program);
2340     AFTER_GL_CALL;
2341   }
2342
2343   void raw_fDeleteShader(GLuint shader) {
2344     BEFORE_GL_CALL;
2345     mSymbols.fDeleteShader(shader);
2346     AFTER_GL_CALL;
2347   }
2348
2349   void raw_fDeleteBuffers(GLsizei n, const GLuint* names) {
2350     BEFORE_GL_CALL;
2351     mSymbols.fDeleteBuffers(n, names);
2352     AFTER_GL_CALL;
2353   }
2354
2355   void raw_fDeleteFramebuffers(GLsizei n, const GLuint* names) {
2356     BEFORE_GL_CALL;
2357     mSymbols.fDeleteFramebuffers(n, names);
2358     AFTER_GL_CALL;
2359
2360     for (const auto i : IntegerRange(n)) {
2361       const auto fb = names[i];
2362       if (mCachedDrawFb == fb) {
2363         mCachedDrawFb = 0;
2364       }
2365       if (mCachedReadFb == fb) {
2366         mCachedReadFb = 0;
2367       }
2368     }
2369   }
2370
2371   void raw_fDeleteRenderbuffers(GLsizei n, const GLuint* names) {
2372     BEFORE_GL_CALL;
2373     mSymbols.fDeleteRenderbuffers(n, names);
2374     AFTER_GL_CALL;
2375   }
2376
2377   void raw_fDeleteTextures(GLsizei n, const GLuint* names) {
2378     BEFORE_GL_CALL;
2379     mSymbols.fDeleteTextures(n, names);
2380     AFTER_GL_CALL;
2381   }
2382
2383  public:
2384   void fDeleteProgram(GLuint program) {
2385     raw_fDeleteProgram(program);
2386     TRACKING_CONTEXT(DeletedProgram(this, program));
2387   }
2388
2389   void fDeleteShader(GLuint shader) {
2390     raw_fDeleteShader(shader);
2391     TRACKING_CONTEXT(DeletedShader(this, shader));
2392   }
2393
2394   void fDeleteBuffers(GLsizei n, const GLuint* names) {
2395     raw_fDeleteBuffers(n, names);
2396     TRACKING_CONTEXT(DeletedBuffers(this, n, names));
2397   }
2398
2399   void fDeleteFramebuffers(GLsizei n, const GLuint* names);
2400
2401   void fDeleteRenderbuffers(GLsizei n, const GLuint* names) {
2402     raw_fDeleteRenderbuffers(n, names);
2403     TRACKING_CONTEXT(DeletedRenderbuffers(this, n, names));
2404   }
2405
2406   void fDeleteTextures(GLsizei n, const GLuint* names) {
2407 #ifdef XP_MACOSX
2408     // On the Mac the call to fDeleteTextures() triggers a flush. But it
2409     // happens at the wrong time, which can lead to crashes. To work around
2410     // this we call fFlush() explicitly ourselves, before the call to
2411     // fDeleteTextures(). This fixes bug 1666293.
2412     fFlush();
2413 #endif
2414     raw_fDeleteTextures(n, names);
2415     TRACKING_CONTEXT(DeletedTextures(this, n, names));
2416   }
2417
2418   // -----------------------------------------------------------------------------
2419   // Extension ARB_sync (GL)
2420  public:
2421   GLsync fFenceSync(GLenum condition, GLbitfield flags) {
2422     GLsync ret = 0;
2423     BEFORE_GL_CALL;
2424     ASSERT_SYMBOL_PRESENT(fFenceSync);
2425     ret = mSymbols.fFenceSync(condition, flags);
2426     OnSyncCall();
2427     AFTER_GL_CALL;
2428     return ret;
2429   }
2430
2431   realGLboolean fIsSync(GLsync sync) {
2432     realGLboolean ret = false;
2433     BEFORE_GL_CALL;
2434     ASSERT_SYMBOL_PRESENT(fIsSync);
2435     ret = mSymbols.fIsSync(sync);
2436     OnSyncCall();
2437     AFTER_GL_CALL;
2438     return ret;
2439   }
2440
2441   void fDeleteSync(GLsync sync) {
2442     BEFORE_GL_CALL;
2443     ASSERT_SYMBOL_PRESENT(fDeleteSync);
2444     mSymbols.fDeleteSync(sync);
2445     AFTER_GL_CALL;
2446   }
2447
2448   GLenum fClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
2449     GLenum ret = 0;
2450     BEFORE_GL_CALL;
2451     ASSERT_SYMBOL_PRESENT(fClientWaitSync);
2452     ret = mSymbols.fClientWaitSync(sync, flags, timeout);
2453     OnSyncCall();
2454     AFTER_GL_CALL;
2455     return ret;
2456   }
2457
2458   void fWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
2459     BEFORE_GL_CALL;
2460     ASSERT_SYMBOL_PRESENT(fWaitSync);
2461     mSymbols.fWaitSync(sync, flags, timeout);
2462     AFTER_GL_CALL;
2463   }
2464
2465   void fGetInteger64v(GLenum pname, GLint64* params) {
2466     BEFORE_GL_CALL;
2467     ASSERT_SYMBOL_PRESENT(fGetInteger64v);
2468     mSymbols.fGetInteger64v(pname, params);
2469     AFTER_GL_CALL;
2470   }
2471
2472   void fGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length,
2473                   GLint* values) {
2474     BEFORE_GL_CALL;
2475     ASSERT_SYMBOL_PRESENT(fGetSynciv);
2476     mSymbols.fGetSynciv(sync, pname, bufSize, length, values);
2477     OnSyncCall();
2478     AFTER_GL_CALL;
2479   }
2480
2481   // -----------------------------------------------------------------------------
2482   // Extension OES_EGL_image (GLES)
2483  public:
2484   void fEGLImageTargetTexture2D(GLenum target, GLeglImage image) {
2485     BEFORE_GL_CALL;
2486     ASSERT_SYMBOL_PRESENT(fEGLImageTargetTexture2D);
2487     mSymbols.fEGLImageTargetTexture2D(target, image);
2488     AFTER_GL_CALL;
2489     mHeavyGLCallsSinceLastFlush = true;
2490   }
2491
2492   void fEGLImageTargetRenderbufferStorage(GLenum target, GLeglImage image) {
2493     BEFORE_GL_CALL;
2494     ASSERT_SYMBOL_PRESENT(fEGLImageTargetRenderbufferStorage);
2495     mSymbols.fEGLImageTargetRenderbufferStorage(target, image);
2496     AFTER_GL_CALL;
2497   }
2498
2499   // -----------------------------------------------------------------------------
2500   // Package XXX_bind_buffer_offset
2501  public:
2502   void fBindBufferOffset(GLenum target, GLuint index, GLuint buffer,
2503                          GLintptr offset) {
2504     BEFORE_GL_CALL;
2505     ASSERT_SYMBOL_PRESENT(fBindBufferOffset);
2506     mSymbols.fBindBufferOffset(target, index, buffer, offset);
2507     AFTER_GL_CALL;
2508   }
2509
2510   // -----------------------------------------------------------------------------
2511   // Package XXX_draw_buffers
2512  public:
2513   void fDrawBuffers(GLsizei n, const GLenum* bufs) {
2514     BEFORE_GL_CALL;
2515     ASSERT_SYMBOL_PRESENT(fDrawBuffers);
2516     mSymbols.fDrawBuffers(n, bufs);
2517     AFTER_GL_CALL;
2518   }
2519
2520   // -----------------------------------------------------------------------------
2521   // Package XXX_draw_instanced
2522  public:
2523   void fDrawArraysInstanced(GLenum mode, GLint first, GLsizei count,
2524                             GLsizei primcount) {
2525     BeforeGLDrawCall();
2526     raw_fDrawArraysInstanced(mode, first, count, primcount);
2527     AfterGLDrawCall();
2528   }
2529
2530   void fDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type,
2531                               const GLvoid* indices, GLsizei primcount) {
2532     BeforeGLDrawCall();
2533     raw_fDrawElementsInstanced(mode, count, type, indices, primcount);
2534     AfterGLDrawCall();
2535   }
2536
2537  private:
2538   void raw_fDrawArraysInstanced(GLenum mode, GLint first, GLsizei count,
2539                                 GLsizei primcount) {
2540     BEFORE_GL_CALL;
2541     ASSERT_SYMBOL_PRESENT(fDrawArraysInstanced);
2542     mSymbols.fDrawArraysInstanced(mode, first, count, primcount);
2543     AFTER_GL_CALL;
2544   }
2545
2546   void raw_fDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type,
2547                                   const GLvoid* indices, GLsizei primcount) {
2548     BEFORE_GL_CALL;
2549     ASSERT_SYMBOL_PRESENT(fDrawElementsInstanced);
2550     mSymbols.fDrawElementsInstanced(mode, count, type, indices, primcount);
2551     AFTER_GL_CALL;
2552   }
2553
2554   // -----------------------------------------------------------------------------
2555   // Package XXX_framebuffer_blit
2556  public:
2557   // Draw/Read
2558   void fBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
2559                         GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
2560                         GLbitfield mask, GLenum filter) {
2561     BeforeGLDrawCall();
2562     BeforeGLReadCall();
2563     raw_fBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
2564                          mask, filter);
2565     AfterGLReadCall();
2566     AfterGLDrawCall();
2567   }
2568
2569  private:
2570   void raw_fBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
2571                             GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
2572                             GLbitfield mask, GLenum filter) {
2573     BEFORE_GL_CALL;
2574     ASSERT_SYMBOL_PRESENT(fBlitFramebuffer);
2575     mSymbols.fBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
2576                               dstY1, mask, filter);
2577     AFTER_GL_CALL;
2578   }
2579
2580   // -----------------------------------------------------------------------------
2581   // Package XXX_framebuffer_multisample
2582  public:
2583   void fRenderbufferStorageMultisample(GLenum target, GLsizei samples,
2584                                        GLenum internalFormat, GLsizei width,
2585                                        GLsizei height) {
2586     BEFORE_GL_CALL;
2587     ASSERT_SYMBOL_PRESENT(fRenderbufferStorageMultisample);
2588     mSymbols.fRenderbufferStorageMultisample(target, samples, internalFormat,
2589                                              width, height);
2590     AFTER_GL_CALL;
2591   }
2592
2593   // -----------------------------------------------------------------------------
2594   //  GL 3.0, GL ES 3.0 & EXT_gpu_shader4
2595  public:
2596   void fGetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) {
2597     ASSERT_SYMBOL_PRESENT(fGetVertexAttribIiv);
2598     BEFORE_GL_CALL;
2599     mSymbols.fGetVertexAttribIiv(index, pname, params);
2600     OnSyncCall();
2601     AFTER_GL_CALL;
2602   }
2603
2604   void fGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) {
2605     ASSERT_SYMBOL_PRESENT(fGetVertexAttribIuiv);
2606     BEFORE_GL_CALL;
2607     mSymbols.fGetVertexAttribIuiv(index, pname, params);
2608     OnSyncCall();
2609     AFTER_GL_CALL;
2610   }
2611
2612   void fVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) {
2613     BEFORE_GL_CALL;
2614     ASSERT_SYMBOL_PRESENT(fVertexAttribI4i);
2615     mSymbols.fVertexAttribI4i(index, x, y, z, w);
2616     AFTER_GL_CALL;
2617   }
2618
2619   void fVertexAttribI4iv(GLuint index, const GLint* v) {
2620     BEFORE_GL_CALL;
2621     ASSERT_SYMBOL_PRESENT(fVertexAttribI4iv);
2622     mSymbols.fVertexAttribI4iv(index, v);
2623     AFTER_GL_CALL;
2624   }
2625
2626   void fVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) {
2627     BEFORE_GL_CALL;
2628     ASSERT_SYMBOL_PRESENT(fVertexAttribI4ui);
2629     mSymbols.fVertexAttribI4ui(index, x, y, z, w);
2630     AFTER_GL_CALL;
2631   }
2632
2633   void fVertexAttribI4uiv(GLuint index, const GLuint* v) {
2634     BEFORE_GL_CALL;
2635     ASSERT_SYMBOL_PRESENT(fVertexAttribI4uiv);
2636     mSymbols.fVertexAttribI4uiv(index, v);
2637     AFTER_GL_CALL;
2638   }
2639
2640   void fVertexAttribIPointer(GLuint index, GLint size, GLenum type,
2641                              GLsizei stride, const GLvoid* offset) {
2642     BEFORE_GL_CALL;
2643     ASSERT_SYMBOL_PRESENT(fVertexAttribIPointer);
2644     mSymbols.fVertexAttribIPointer(index, size, type, stride, offset);
2645     AFTER_GL_CALL;
2646   }
2647
2648   void fUniform1ui(GLint location, GLuint v0) {
2649     BEFORE_GL_CALL;
2650     ASSERT_SYMBOL_PRESENT(fUniform1ui);
2651     mSymbols.fUniform1ui(location, v0);
2652     AFTER_GL_CALL;
2653   }
2654
2655   void fUniform2ui(GLint location, GLuint v0, GLuint v1) {
2656     BEFORE_GL_CALL;
2657     ASSERT_SYMBOL_PRESENT(fUniform2ui);
2658     mSymbols.fUniform2ui(location, v0, v1);
2659     AFTER_GL_CALL;
2660   }
2661
2662   void fUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) {
2663     BEFORE_GL_CALL;
2664     ASSERT_SYMBOL_PRESENT(fUniform3ui);
2665     mSymbols.fUniform3ui(location, v0, v1, v2);
2666     AFTER_GL_CALL;
2667   }
2668
2669   void fUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {
2670     BEFORE_GL_CALL;
2671     ASSERT_SYMBOL_PRESENT(fUniform4ui);
2672     mSymbols.fUniform4ui(location, v0, v1, v2, v3);
2673     AFTER_GL_CALL;
2674   }
2675
2676   void fUniform1uiv(GLint location, GLsizei count, const GLuint* value) {
2677     BEFORE_GL_CALL;
2678     ASSERT_SYMBOL_PRESENT(fUniform1uiv);
2679     mSymbols.fUniform1uiv(location, count, value);
2680     AFTER_GL_CALL;
2681   }
2682
2683   void fUniform2uiv(GLint location, GLsizei count, const GLuint* value) {
2684     BEFORE_GL_CALL;
2685     ASSERT_SYMBOL_PRESENT(fUniform2uiv);
2686     mSymbols.fUniform2uiv(location, count, value);
2687     AFTER_GL_CALL;
2688   }
2689
2690   void fUniform3uiv(GLint location, GLsizei count, const GLuint* value) {
2691     BEFORE_GL_CALL;
2692     ASSERT_SYMBOL_PRESENT(fUniform3uiv);
2693     mSymbols.fUniform3uiv(location, count, value);
2694     AFTER_GL_CALL;
2695   }
2696
2697   void fUniform4uiv(GLint location, GLsizei count, const GLuint* value) {
2698     BEFORE_GL_CALL;
2699     ASSERT_SYMBOL_PRESENT(fUniform4uiv);
2700     mSymbols.fUniform4uiv(location, count, value);
2701     AFTER_GL_CALL;
2702   }
2703
2704   GLint fGetFragDataLocation(GLuint program, const GLchar* name) {
2705     GLint result = 0;
2706     BEFORE_GL_CALL;
2707     ASSERT_SYMBOL_PRESENT(fGetFragDataLocation);
2708     result = mSymbols.fGetFragDataLocation(program, name);
2709     OnSyncCall();
2710     AFTER_GL_CALL;
2711     return result;
2712   }
2713
2714   // -----------------------------------------------------------------------------
2715   // Package XXX_instanced_arrays
2716  public:
2717   void fVertexAttribDivisor(GLuint index, GLuint divisor) {
2718     BEFORE_GL_CALL;
2719     ASSERT_SYMBOL_PRESENT(fVertexAttribDivisor);
2720     mSymbols.fVertexAttribDivisor(index, divisor);
2721     AFTER_GL_CALL;
2722   }
2723
2724   // -----------------------------------------------------------------------------
2725   // Feature internalformat_query
2726  public:
2727   void fGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname,
2728                             GLsizei bufSize, GLint* params) {
2729     BEFORE_GL_CALL;
2730     ASSERT_SYMBOL_PRESENT(fGetInternalformativ);
2731     mSymbols.fGetInternalformativ(target, internalformat, pname, bufSize,
2732                                   params);
2733     OnSyncCall();
2734     AFTER_GL_CALL;
2735   }
2736
2737   // -----------------------------------------------------------------------------
2738   // Package XXX_query_counter
2739   /**
2740    * XXX_query_counter:
2741    *  - depends on XXX_query_objects
2742    *  - provide all followed entry points
2743    *  - provide GL_TIMESTAMP
2744    */
2745  public:
2746   void fQueryCounter(GLuint id, GLenum target) {
2747     BEFORE_GL_CALL;
2748     ASSERT_SYMBOL_PRESENT(fQueryCounter);
2749     mSymbols.fQueryCounter(id, target);
2750     AFTER_GL_CALL;
2751   }
2752
2753   // -----------------------------------------------------------------------------
2754   // Package XXX_query_objects
2755   /**
2756    * XXX_query_objects:
2757    *  - provide all followed entry points
2758    *
2759    * XXX_occlusion_query2:
2760    *  - depends on XXX_query_objects
2761    *  - provide ANY_SAMPLES_PASSED
2762    *
2763    * XXX_occlusion_query_boolean:
2764    *  - depends on XXX_occlusion_query2
2765    *  - provide ANY_SAMPLES_PASSED_CONSERVATIVE
2766    */
2767  public:
2768   void fDeleteQueries(GLsizei n, const GLuint* names) {
2769     BEFORE_GL_CALL;
2770     ASSERT_SYMBOL_PRESENT(fDeleteQueries);
2771     mSymbols.fDeleteQueries(n, names);
2772     AFTER_GL_CALL;
2773     TRACKING_CONTEXT(DeletedQueries(this, n, names));
2774   }
2775
2776   void fGenQueries(GLsizei n, GLuint* names) {
2777     BEFORE_GL_CALL;
2778     ASSERT_SYMBOL_PRESENT(fGenQueries);
2779     mSymbols.fGenQueries(n, names);
2780     AFTER_GL_CALL;
2781     TRACKING_CONTEXT(CreatedQueries(this, n, names));
2782   }
2783
2784   void fGetQueryiv(GLenum target, GLenum pname, GLint* params) {
2785     BEFORE_GL_CALL;
2786     ASSERT_SYMBOL_PRESENT(fGetQueryiv);
2787     mSymbols.fGetQueryiv(target, pname, params);
2788     OnSyncCall();
2789     AFTER_GL_CALL;
2790   }
2791
2792   void fGetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) {
2793     BEFORE_GL_CALL;
2794     ASSERT_SYMBOL_PRESENT(fGetQueryObjectuiv);
2795     mSymbols.fGetQueryObjectuiv(id, pname, params);
2796     OnSyncCall();
2797     AFTER_GL_CALL;
2798   }
2799
2800   realGLboolean fIsQuery(GLuint query) {
2801     realGLboolean retval = false;
2802     BEFORE_GL_CALL;
2803     ASSERT_SYMBOL_PRESENT(fIsQuery);
2804     retval = mSymbols.fIsQuery(query);
2805     OnSyncCall();
2806     AFTER_GL_CALL;
2807     return retval;
2808   }
2809
2810   // -----------------------------------------------------------------------------
2811   // Package XXX_get_query_object_i64v
2812   /**
2813    * XXX_get_query_object_i64v:
2814    *  - depends on XXX_query_objects
2815    *  - provide the followed entry point
2816    */
2817  public:
2818   void fGetQueryObjecti64v(GLuint id, GLenum pname, GLint64* params) {
2819     BEFORE_GL_CALL;
2820     ASSERT_SYMBOL_PRESENT(fGetQueryObjecti64v);
2821     mSymbols.fGetQueryObjecti64v(id, pname, params);
2822     OnSyncCall();
2823     AFTER_GL_CALL;
2824   }
2825
2826   void fGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params) {
2827     BEFORE_GL_CALL;
2828     ASSERT_SYMBOL_PRESENT(fGetQueryObjectui64v);
2829     mSymbols.fGetQueryObjectui64v(id, pname, params);
2830     OnSyncCall();
2831     AFTER_GL_CALL;
2832   }
2833
2834   // -----------------------------------------------------------------------------
2835   // Package XXX_get_query_object_iv
2836   /**
2837    * XXX_get_query_object_iv:
2838    *  - depends on XXX_query_objects
2839    *  - provide the followed entry point
2840    *
2841    * XXX_occlusion_query:
2842    *  - depends on XXX_get_query_object_iv
2843    *  - provide LOCAL_GL_SAMPLES_PASSED
2844    */
2845  public:
2846   void fGetQueryObjectiv(GLuint id, GLenum pname, GLint* params) {
2847     BEFORE_GL_CALL;
2848     ASSERT_SYMBOL_PRESENT(fGetQueryObjectiv);
2849     mSymbols.fGetQueryObjectiv(id, pname, params);
2850     OnSyncCall();
2851     AFTER_GL_CALL;
2852   }
2853
2854   // -----------------------------------------------------------------------------
2855   // GL 4.0, GL ES 3.0, ARB_transform_feedback2, NV_transform_feedback2
2856  public:
2857   void fBindBufferBase(GLenum target, GLuint index, GLuint buffer) {
2858     BEFORE_GL_CALL;
2859     ASSERT_SYMBOL_PRESENT(fBindBufferBase);
2860     mSymbols.fBindBufferBase(target, index, buffer);
2861     AFTER_GL_CALL;
2862   }
2863
2864   void fBindBufferRange(GLenum target, GLuint index, GLuint buffer,
2865                         GLintptr offset, GLsizeiptr size) {
2866     BEFORE_GL_CALL;
2867     ASSERT_SYMBOL_PRESENT(fBindBufferRange);
2868     mSymbols.fBindBufferRange(target, index, buffer, offset, size);
2869     AFTER_GL_CALL;
2870   }
2871
2872   void fGenTransformFeedbacks(GLsizei n, GLuint* ids) {
2873     BEFORE_GL_CALL;
2874     ASSERT_SYMBOL_PRESENT(fGenTransformFeedbacks);
2875     mSymbols.fGenTransformFeedbacks(n, ids);
2876     OnSyncCall();
2877     AFTER_GL_CALL;
2878   }
2879
2880   void fDeleteTransformFeedbacks(GLsizei n, const GLuint* ids) {
2881     BEFORE_GL_CALL;
2882     ASSERT_SYMBOL_PRESENT(fDeleteTransformFeedbacks);
2883     mSymbols.fDeleteTransformFeedbacks(n, ids);
2884     AFTER_GL_CALL;
2885   }
2886
2887   realGLboolean fIsTransformFeedback(GLuint id) {
2888     realGLboolean result = false;
2889     BEFORE_GL_CALL;
2890     ASSERT_SYMBOL_PRESENT(fIsTransformFeedback);
2891     result = mSymbols.fIsTransformFeedback(id);
2892     OnSyncCall();
2893     AFTER_GL_CALL;
2894     return result;
2895   }
2896
2897   void fBindTransformFeedback(GLenum target, GLuint id) {
2898     BEFORE_GL_CALL;
2899     ASSERT_SYMBOL_PRESENT(fBindTransformFeedback);
2900     mSymbols.fBindTransformFeedback(target, id);
2901     AFTER_GL_CALL;
2902   }
2903
2904   void fBeginTransformFeedback(GLenum primitiveMode) {
2905     BEFORE_GL_CALL;
2906     ASSERT_SYMBOL_PRESENT(fBeginTransformFeedback);
2907     mSymbols.fBeginTransformFeedback(primitiveMode);
2908     AFTER_GL_CALL;
2909   }
2910
2911   void fEndTransformFeedback() {
2912     BEFORE_GL_CALL;
2913     ASSERT_SYMBOL_PRESENT(fEndTransformFeedback);
2914     mSymbols.fEndTransformFeedback();
2915     AFTER_GL_CALL;
2916   }
2917
2918   void fTransformFeedbackVaryings(GLuint program, GLsizei count,
2919                                   const GLchar* const* varyings,
2920                                   GLenum bufferMode) {
2921     BEFORE_GL_CALL;
2922     ASSERT_SYMBOL_PRESENT(fTransformFeedbackVaryings);
2923     mSymbols.fTransformFeedbackVaryings(program, count, varyings, bufferMode);
2924     AFTER_GL_CALL;
2925   }
2926
2927   void fGetTransformFeedbackVarying(GLuint program, GLuint index,
2928                                     GLsizei bufSize, GLsizei* length,
2929                                     GLsizei* size, GLenum* type, GLchar* name) {
2930     BEFORE_GL_CALL;
2931     ASSERT_SYMBOL_PRESENT(fGetTransformFeedbackVarying);
2932     mSymbols.fGetTransformFeedbackVarying(program, index, bufSize, length, size,
2933                                           type, name);
2934     OnSyncCall();
2935     AFTER_GL_CALL;
2936   }
2937
2938   void fPauseTransformFeedback() {
2939     BEFORE_GL_CALL;
2940     ASSERT_SYMBOL_PRESENT(fPauseTransformFeedback);
2941     mSymbols.fPauseTransformFeedback();
2942     AFTER_GL_CALL;
2943   }
2944
2945   void fResumeTransformFeedback() {
2946     BEFORE_GL_CALL;
2947     ASSERT_SYMBOL_PRESENT(fResumeTransformFeedback);
2948     mSymbols.fResumeTransformFeedback();
2949     AFTER_GL_CALL;
2950   }
2951
2952   void fGetIntegeri_v(GLenum param, GLuint index, GLint* values) {
2953     BEFORE_GL_CALL;
2954     ASSERT_SYMBOL_PRESENT(fGetIntegeri_v);
2955     mSymbols.fGetIntegeri_v(param, index, values);
2956     OnSyncCall();
2957     AFTER_GL_CALL;
2958   }
2959
2960   void fGetInteger64i_v(GLenum target, GLuint index, GLint64* data) {
2961     ASSERT_SYMBOL_PRESENT(fGetInteger64i_v);
2962     BEFORE_GL_CALL;
2963     mSymbols.fGetInteger64i_v(target, index, data);
2964     OnSyncCall();
2965     AFTER_GL_CALL;
2966   }
2967
2968   // -----------------------------------------------------------------------------
2969   // Package XXX_vertex_array_object
2970  public:
2971   void fBindVertexArray(GLuint array) {
2972     BEFORE_GL_CALL;
2973     ASSERT_SYMBOL_PRESENT(fBindVertexArray);
2974     mSymbols.fBindVertexArray(array);
2975     AFTER_GL_CALL;
2976   }
2977
2978   void fDeleteVertexArrays(GLsizei n, const GLuint* arrays) {
2979     BEFORE_GL_CALL;
2980     ASSERT_SYMBOL_PRESENT(fDeleteVertexArrays);
2981     mSymbols.fDeleteVertexArrays(n, arrays);
2982     AFTER_GL_CALL;
2983   }
2984
2985   void fGenVertexArrays(GLsizei n, GLuint* arrays) {
2986     BEFORE_GL_CALL;
2987     ASSERT_SYMBOL_PRESENT(fGenVertexArrays);
2988     mSymbols.fGenVertexArrays(n, arrays);
2989     AFTER_GL_CALL;
2990   }
2991
2992   realGLboolean fIsVertexArray(GLuint array) {
2993     realGLboolean ret = false;
2994     BEFORE_GL_CALL;
2995     ASSERT_SYMBOL_PRESENT(fIsVertexArray);
2996     ret = mSymbols.fIsVertexArray(array);
2997     OnSyncCall();
2998     AFTER_GL_CALL;
2999     return ret;
3000   }
3001
3002   // -----------------------------------------------------------------------------
3003   // Extension NV_fence
3004  public:
3005   void fGenFences(GLsizei n, GLuint* fences) {
3006     ASSERT_SYMBOL_PRESENT(fGenFences);
3007     BEFORE_GL_CALL;
3008     mSymbols.fGenFences(n, fences);
3009     AFTER_GL_CALL;
3010   }
3011
3012   void fDeleteFences(GLsizei n, const GLuint* fences) {
3013     ASSERT_SYMBOL_PRESENT(fDeleteFences);
3014     BEFORE_GL_CALL;
3015     mSymbols.fDeleteFences(n, fences);
3016     AFTER_GL_CALL;
3017   }
3018
3019   void fSetFence(GLuint fence, GLenum condition) {
3020     ASSERT_SYMBOL_PRESENT(fSetFence);
3021     BEFORE_GL_CALL;
3022     mSymbols.fSetFence(fence, condition);
3023     AFTER_GL_CALL;
3024   }
3025
3026   realGLboolean fTestFence(GLuint fence) {
3027     realGLboolean ret = false;
3028     ASSERT_SYMBOL_PRESENT(fTestFence);
3029     BEFORE_GL_CALL;
3030     ret = mSymbols.fTestFence(fence);
3031     OnSyncCall();
3032     AFTER_GL_CALL;
3033     return ret;
3034   }
3035
3036   void fFinishFence(GLuint fence) {
3037     ASSERT_SYMBOL_PRESENT(fFinishFence);
3038     BEFORE_GL_CALL;
3039     mSymbols.fFinishFence(fence);
3040     OnSyncCall();
3041     AFTER_GL_CALL;
3042   }
3043
3044   realGLboolean fIsFence(GLuint fence) {
3045     realGLboolean ret = false;
3046     ASSERT_SYMBOL_PRESENT(fIsFence);
3047     BEFORE_GL_CALL;
3048     ret = mSymbols.fIsFence(fence);
3049     OnSyncCall();
3050     AFTER_GL_CALL;
3051     return ret;
3052   }
3053
3054   void fGetFenceiv(GLuint fence, GLenum pname, GLint* params) {
3055     ASSERT_SYMBOL_PRESENT(fGetFenceiv);
3056     BEFORE_GL_CALL;
3057     mSymbols.fGetFenceiv(fence, pname, params);
3058     OnSyncCall();
3059     AFTER_GL_CALL;
3060   }
3061
3062   // -----------------------------------------------------------------------------
3063   // Extension NV_texture_barrier
3064  public:
3065   void fTextureBarrier() {
3066     ASSERT_SYMBOL_PRESENT(fTextureBarrier);
3067     BEFORE_GL_CALL;
3068     mSymbols.fTextureBarrier();
3069     AFTER_GL_CALL;
3070   }
3071
3072   // Core GL & Extension ARB_copy_buffer
3073  public:
3074   void fCopyBufferSubData(GLenum readtarget, GLenum writetarget,
3075                           GLintptr readoffset, GLintptr writeoffset,
3076                           GLsizeiptr size) {
3077     BEFORE_GL_CALL;
3078     ASSERT_SYMBOL_PRESENT(fCopyBufferSubData);
3079     mSymbols.fCopyBufferSubData(readtarget, writetarget, readoffset,
3080                                 writeoffset, size);
3081     AFTER_GL_CALL;
3082   }
3083
3084   // -----------------------------------------------------------------------------
3085   // Core GL & Extension ARB_map_buffer_range
3086  public:
3087   void* fMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
3088                         GLbitfield access) {
3089     void* data = nullptr;
3090     ASSERT_SYMBOL_PRESENT(fMapBufferRange);
3091     BEFORE_GL_CALL;
3092     data = mSymbols.fMapBufferRange(target, offset, length, access);
3093     OnSyncCall();
3094     AFTER_GL_CALL;
3095     return data;
3096   }
3097
3098   void fFlushMappedBufferRange(GLenum target, GLintptr offset,
3099                                GLsizeiptr length) {
3100     ASSERT_SYMBOL_PRESENT(fFlushMappedBufferRange);
3101     BEFORE_GL_CALL;
3102     mSymbols.fFlushMappedBufferRange(target, offset, length);
3103     AFTER_GL_CALL;
3104   }
3105
3106   // -----------------------------------------------------------------------------
3107   // Core GL & Extension ARB_sampler_objects
3108  public:
3109   void fGenSamplers(GLsizei count, GLuint* samplers) {
3110     BEFORE_GL_CALL;
3111     ASSERT_SYMBOL_PRESENT(fGenSamplers);
3112     mSymbols.fGenSamplers(count, samplers);
3113     AFTER_GL_CALL;
3114   }
3115
3116   void fDeleteSamplers(GLsizei count, const GLuint* samplers) {
3117     BEFORE_GL_CALL;
3118     ASSERT_SYMBOL_PRESENT(fDeleteSamplers);
3119     mSymbols.fDeleteSamplers(count, samplers);
3120     AFTER_GL_CALL;
3121   }
3122
3123   realGLboolean fIsSampler(GLuint sampler) {
3124     realGLboolean result = false;
3125     BEFORE_GL_CALL;
3126     ASSERT_SYMBOL_PRESENT(fIsSampler);
3127     result = mSymbols.fIsSampler(sampler);
3128     OnSyncCall();
3129     AFTER_GL_CALL;
3130     return result;
3131   }
3132
3133   void fBindSampler(GLuint unit, GLuint sampler) {
3134     BEFORE_GL_CALL;
3135     ASSERT_SYMBOL_PRESENT(fBindSampler);
3136     mSymbols.fBindSampler(unit, sampler);
3137     AFTER_GL_CALL;
3138   }
3139
3140   void fSamplerParameteri(GLuint sampler, GLenum pname, GLint param) {
3141     BEFORE_GL_CALL;
3142     ASSERT_SYMBOL_PRESENT(fSamplerParameteri);
3143     mSymbols.fSamplerParameteri(sampler, pname, param);
3144     AFTER_GL_CALL;
3145   }
3146
3147   void fSamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) {
3148     BEFORE_GL_CALL;
3149     ASSERT_SYMBOL_PRESENT(fSamplerParameteriv);
3150     mSymbols.fSamplerParameteriv(sampler, pname, param);
3151     AFTER_GL_CALL;
3152   }
3153
3154   void fSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) {
3155     BEFORE_GL_CALL;
3156     ASSERT_SYMBOL_PRESENT(fSamplerParameterf);
3157     mSymbols.fSamplerParameterf(sampler, pname, param);
3158     AFTER_GL_CALL;
3159   }
3160
3161   void fSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) {
3162     BEFORE_GL_CALL;
3163     ASSERT_SYMBOL_PRESENT(fSamplerParameterfv);
3164     mSymbols.fSamplerParameterfv(sampler, pname, param);
3165     AFTER_GL_CALL;
3166   }
3167
3168   void fGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) {
3169     BEFORE_GL_CALL;
3170     ASSERT_SYMBOL_PRESENT(fGetSamplerParameteriv);
3171     mSymbols.fGetSamplerParameteriv(sampler, pname, params);
3172     AFTER_GL_CALL;
3173   }
3174
3175   void fGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) {
3176     BEFORE_GL_CALL;
3177     ASSERT_SYMBOL_PRESENT(fGetSamplerParameterfv);
3178     mSymbols.fGetSamplerParameterfv(sampler, pname, params);
3179     AFTER_GL_CALL;
3180   }
3181
3182   // -----------------------------------------------------------------------------
3183   // Core GL & Extension ARB_uniform_buffer_object
3184  public:
3185   void fGetUniformIndices(GLuint program, GLsizei uniformCount,
3186                           const GLchar* const* uniformNames,
3187                           GLuint* uniformIndices) {
3188     ASSERT_SYMBOL_PRESENT(fGetUniformIndices);
3189     BEFORE_GL_CALL;
3190     mSymbols.fGetUniformIndices(program, uniformCount, uniformNames,
3191                                 uniformIndices);
3192     OnSyncCall();
3193     AFTER_GL_CALL;
3194   }
3195
3196   void fGetActiveUniformsiv(GLuint program, GLsizei uniformCount,
3197                             const GLuint* uniformIndices, GLenum pname,
3198                             GLint* params) {
3199     ASSERT_SYMBOL_PRESENT(fGetActiveUniformsiv);
3200     BEFORE_GL_CALL;
3201     mSymbols.fGetActiveUniformsiv(program, uniformCount, uniformIndices, pname,
3202                                   params);
3203     OnSyncCall();
3204     AFTER_GL_CALL;
3205   }
3206
3207   GLuint fGetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) {
3208     GLuint result = 0;
3209     ASSERT_SYMBOL_PRESENT(fGetUniformBlockIndex);
3210     BEFORE_GL_CALL;
3211     result = mSymbols.fGetUniformBlockIndex(program, uniformBlockName);
3212     OnSyncCall();
3213     AFTER_GL_CALL;
3214     return result;
3215   }
3216
3217   void fGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex,
3218                                 GLenum pname, GLint* params) {
3219     ASSERT_SYMBOL_PRESENT(fGetActiveUniformBlockiv);
3220     BEFORE_GL_CALL;
3221     mSymbols.fGetActiveUniformBlockiv(program, uniformBlockIndex, pname,
3222                                       params);
3223     OnSyncCall();
3224     AFTER_GL_CALL;
3225   }
3226
3227   void fGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex,
3228                                   GLsizei bufSize, GLsizei* length,
3229                                   GLchar* uniformBlockName) {
3230     ASSERT_SYMBOL_PRESENT(fGetActiveUniformBlockName);
3231     BEFORE_GL_CALL;
3232     mSymbols.fGetActiveUniformBlockName(program, uniformBlockIndex, bufSize,
3233                                         length, uniformBlockName);
3234     OnSyncCall();
3235     AFTER_GL_CALL;
3236   }
3237
3238   void fUniformBlockBinding(GLuint program, GLuint uniformBlockIndex,
3239                             GLuint uniformBlockBinding) {
3240     ASSERT_SYMBOL_PRESENT(fUniformBlockBinding);
3241     BEFORE_GL_CALL;
3242     mSymbols.fUniformBlockBinding(program, uniformBlockIndex,
3243                                   uniformBlockBinding);
3244     AFTER_GL_CALL;
3245   }
3246
3247   // -----------------------------------------------------------------------------
3248   // Core GL 4.2, GL ES 3.0 & Extension ARB_texture_storage/EXT_texture_storage
3249   void fTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat,
3250                      GLsizei width, GLsizei height) {
3251     BEFORE_GL_CALL;
3252     ASSERT_SYMBOL_PRESENT(fTexStorage2D);
3253     mSymbols.fTexStorage2D(target, levels, internalformat, width, height);
3254     OnSyncCall();
3255     AFTER_GL_CALL;
3256   }
3257
3258   void fTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat,
3259                      GLsizei width, GLsizei height, GLsizei depth) {
3260     BEFORE_GL_CALL;
3261     ASSERT_SYMBOL_PRESENT(fTexStorage3D);
3262     mSymbols.fTexStorage3D(target, levels, internalformat, width, height,
3263                            depth);
3264     OnSyncCall();
3265     AFTER_GL_CALL;
3266   }
3267
3268   // -----------------------------------------------------------------------------
3269   // 3D Textures
3270   void fTexImage3D(GLenum target, GLint level, GLint internalFormat,
3271                    GLsizei width, GLsizei height, GLsizei depth, GLint border,
3272                    GLenum format, GLenum type, const GLvoid* data) {
3273     BEFORE_GL_CALL;
3274     ASSERT_SYMBOL_PRESENT(fTexImage3D);
3275     mSymbols.fTexImage3D(target, level, internalFormat, width, height, depth,
3276                          border, format, type, data);
3277     OnSyncCall();
3278     AFTER_GL_CALL;
3279   }
3280
3281   void fTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
3282                       GLint zoffset, GLsizei width, GLsizei height,
3283                       GLsizei depth, GLenum format, GLenum type,
3284                       const GLvoid* pixels) {
3285     BEFORE_GL_CALL;
3286     ASSERT_SYMBOL_PRESENT(fTexSubImage3D);
3287     mSymbols.fTexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
3288                             height, depth, format, type, pixels);
3289     OnSyncCall();
3290     AFTER_GL_CALL;
3291   }
3292
3293   void fCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset,
3294                           GLint yoffset, GLint zoffset, GLint x, GLint y,
3295                           GLsizei width, GLsizei height) {
3296     BeforeGLReadCall();
3297     BEFORE_GL_CALL;
3298     ASSERT_SYMBOL_PRESENT(fCopyTexSubImage3D);
3299     mSymbols.fCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y,
3300                                 width, height);
3301     AFTER_GL_CALL;
3302     AfterGLReadCall();
3303   }
3304
3305   void fCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat,
3306                              GLsizei width, GLsizei height, GLsizei depth,
3307                              GLint border, GLsizei imageSize,
3308                              const GLvoid* data) {
3309     BEFORE_GL_CALL;
3310     ASSERT_SYMBOL_PRESENT(fCompressedTexImage3D);
3311     mSymbols.fCompressedTexImage3D(target, level, internalformat, width, height,
3312                                    depth, border, imageSize, data);
3313     AFTER_GL_CALL;
3314   }
3315
3316   void fCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset,
3317                                 GLint yoffset, GLint zoffset, GLsizei width,
3318                                 GLsizei height, GLsizei depth, GLenum format,
3319                                 GLsizei imageSize, const GLvoid* data) {
3320     BEFORE_GL_CALL;
3321     ASSERT_SYMBOL_PRESENT(fCompressedTexSubImage3D);
3322     mSymbols.fCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset,
3323                                       width, height, depth, format, imageSize,
3324                                       data);
3325     AFTER_GL_CALL;
3326   }
3327
3328   // -----------------------------------------------------------------------------
3329   // GL3+, ES3+
3330
3331   const GLubyte* fGetStringi(GLenum name, GLuint index) {
3332     const GLubyte* ret = nullptr;
3333     BEFORE_GL_CALL;
3334     ASSERT_SYMBOL_PRESENT(fGetStringi);
3335     ret = mSymbols.fGetStringi(name, index);
3336     OnSyncCall();
3337     AFTER_GL_CALL;
3338     return ret;
3339   }
3340
3341   // -----------------------------------------------------------------------------
3342   // APPLE_framebuffer_multisample
3343
3344   void fResolveMultisampleFramebufferAPPLE() {
3345     BEFORE_GL_CALL;
3346     ASSERT_SYMBOL_PRESENT(fResolveMultisampleFramebufferAPPLE);
3347     mSymbols.fResolveMultisampleFramebufferAPPLE();
3348     AFTER_GL_CALL;
3349   }
3350
3351   // -----------------------------------------------------------------------------
3352   // APPLE_fence
3353
3354   void fFinishObjectAPPLE(GLenum object, GLint name) {
3355     BEFORE_GL_CALL;
3356     ASSERT_SYMBOL_PRESENT(fFinishObjectAPPLE);
3357     mSymbols.fFinishObjectAPPLE(object, name);
3358     AFTER_GL_CALL;
3359   }
3360
3361   realGLboolean fTestObjectAPPLE(GLenum object, GLint name) {
3362     realGLboolean ret = false;
3363     BEFORE_GL_CALL;
3364     ASSERT_SYMBOL_PRESENT(fTestObjectAPPLE);
3365     ret = mSymbols.fTestObjectAPPLE(object, name);
3366     AFTER_GL_CALL;
3367     return ret;
3368   }
3369
3370   // -----------------------------------------------------------------------------
3371   // prim_restart
3372
3373   void fPrimitiveRestartIndex(GLuint index) {
3374     BEFORE_GL_CALL;
3375     ASSERT_SYMBOL_PRESENT(fPrimitiveRestartIndex);
3376     mSymbols.fPrimitiveRestartIndex(index);
3377     AFTER_GL_CALL;
3378   }
3379
3380   // -----------------------------------------------------------------------------
3381   // multiview
3382
3383   void fFramebufferTextureMultiview(GLenum target, GLenum attachment,
3384                                     GLuint texture, GLint level,
3385                                     GLint baseViewIndex,
3386                                     GLsizei numViews) const {
3387     BEFORE_GL_CALL;
3388     ASSERT_SYMBOL_PRESENT(fFramebufferTextureMultiview);
3389     mSymbols.fFramebufferTextureMultiview(target, attachment, texture, level,
3390                                           baseViewIndex, numViews);
3391     AFTER_GL_CALL;
3392   }
3393
3394   // -
3395   // draw_buffers_indexed
3396
3397   void fBlendEquationSeparatei(GLuint i, GLenum modeRGB,
3398                                GLenum modeAlpha) const {
3399     BEFORE_GL_CALL;
3400     mSymbols.fBlendEquationSeparatei(i, modeRGB, modeAlpha);
3401     AFTER_GL_CALL;
3402   }
3403
3404   void fBlendFuncSeparatei(GLuint i, GLenum sfactorRGB, GLenum dfactorRGB,
3405                            GLenum sfactorAlpha, GLenum dfactorAlpha) const {
3406     BEFORE_GL_CALL;
3407     mSymbols.fBlendFuncSeparatei(i, sfactorRGB, dfactorRGB, sfactorAlpha,
3408                                  dfactorAlpha);
3409     AFTER_GL_CALL;
3410   }
3411
3412   void fColorMaski(GLuint i, realGLboolean red, realGLboolean green,
3413                    realGLboolean blue, realGLboolean alpha) const {
3414     BEFORE_GL_CALL;
3415     mSymbols.fColorMaski(i, red, green, blue, alpha);
3416     AFTER_GL_CALL;
3417   }
3418
3419   void fDisablei(GLenum capability, GLuint i) const {
3420     BEFORE_GL_CALL;
3421     mSymbols.fDisablei(capability, i);
3422     AFTER_GL_CALL;
3423   }
3424
3425   void fEnablei(GLenum capability, GLuint i) const {
3426     BEFORE_GL_CALL;
3427     mSymbols.fEnablei(capability, i);
3428     AFTER_GL_CALL;
3429   }
3430
3431   // -
3432
3433   void fProvokingVertex(GLenum mode) const {
3434     BEFORE_GL_CALL;
3435     mSymbols.fProvokingVertex(mode);
3436     AFTER_GL_CALL;
3437   }
3438
3439   // -----------------------------------------------------------------------------
3440   // GL_EXT_semaphore
3441   void fDeleteSemaphoresEXT(GLsizei n, const GLuint* semaphores) {
3442     BEFORE_GL_CALL;
3443     mSymbols.fDeleteSemaphoresEXT(n, semaphores);
3444     AFTER_GL_CALL;
3445   }
3446
3447   void fGenSemaphoresEXT(GLsizei n, GLuint* semaphores) {
3448     BEFORE_GL_CALL;
3449     mSymbols.fGenSemaphoresEXT(n, semaphores);
3450     AFTER_GL_CALL;
3451   }
3452
3453   void fGetSemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname,
3454                                       GLuint64* params) {
3455     BEFORE_GL_CALL;
3456     mSymbols.fGetSemaphoreParameterui64vEXT(semaphore, pname, params);
3457     AFTER_GL_CALL;
3458   }
3459
3460   realGLboolean fIsSemaphoreEXT(GLuint semaphore) {
3461     realGLboolean ret = false;
3462     BEFORE_GL_CALL;
3463     ret = mSymbols.fIsSemaphoreEXT(semaphore);
3464     AFTER_GL_CALL;
3465     return ret;
3466   }
3467
3468   void fSemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname,
3469                                    const GLuint64* params) {
3470     BEFORE_GL_CALL;
3471     mSymbols.fSemaphoreParameterui64vEXT(semaphore, pname, params);
3472     AFTER_GL_CALL;
3473   }
3474
3475   void fSignalSemaphoreEXT(GLuint semaphore, GLuint numBufferBarriers,
3476                            const GLuint* buffers, GLuint numTextureBarriers,
3477                            const GLuint* textures, const GLenum* dstLayouts) {
3478     BEFORE_GL_CALL;
3479     mSymbols.fSignalSemaphoreEXT(semaphore, numBufferBarriers, buffers,
3480                                  numTextureBarriers, textures, dstLayouts);
3481     AFTER_GL_CALL;
3482   }
3483
3484   void fWaitSemaphoreEXT(GLuint semaphore, GLuint numBufferBarriers,
3485                          const GLuint* buffers, GLuint numTextureBarriers,
3486                          const GLuint* textures, const GLenum* srcLayouts) {
3487     BEFORE_GL_CALL;
3488     mSymbols.fWaitSemaphoreEXT(semaphore, numBufferBarriers, buffers,
3489                                numTextureBarriers, textures, srcLayouts);
3490     AFTER_GL_CALL;
3491   }
3492
3493   // -----------------------------------------------------------------------------
3494   // GL_EXT_semaphore_fd
3495   void fImportSemaphoreFdEXT(GLuint semaphore, GLenum handleType, GLint fd) {
3496     BEFORE_GL_CALL;
3497     mSymbols.fImportSemaphoreFdEXT(semaphore, handleType, fd);
3498     AFTER_GL_CALL;
3499   }
3500
3501   // -----------------------------------------------------------------------------
3502   // Extension EXT_memory_object
3503   void fGetUnsignedBytevEXT(GLenum pname, GLubyte* data) {
3504     BEFORE_GL_CALL;
3505     mSymbols.fGetUnsignedBytevEXT(pname, data);
3506     AFTER_GL_CALL;
3507   }
3508
3509   void fGetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte* data) {
3510     BEFORE_GL_CALL;
3511     mSymbols.fGetUnsignedBytei_vEXT(target, index, data);
3512     AFTER_GL_CALL;
3513   }
3514
3515   void fDeleteMemoryObjectsEXT(GLsizei n, const GLuint* memoryObjects) {
3516     BEFORE_GL_CALL;
3517     mSymbols.fDeleteMemoryObjectsEXT(n, memoryObjects);
3518     AFTER_GL_CALL;
3519   }
3520
3521   void fIsMemoryObjectEXT(GLuint memoryObject) {
3522     BEFORE_GL_CALL;
3523     mSymbols.fIsMemoryObjectEXT(memoryObject);
3524     AFTER_GL_CALL;
3525   }
3526
3527   void fCreateMemoryObjectsEXT(GLsizei n, GLuint* memoryObjects) {
3528     BEFORE_GL_CALL;
3529     mSymbols.fCreateMemoryObjectsEXT(n, memoryObjects);
3530     AFTER_GL_CALL;
3531   }
3532
3533   void fMemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname,
3534                                    const GLint* params) {
3535     BEFORE_GL_CALL;
3536     mSymbols.fMemoryObjectParameterivEXT(memoryObject, pname, params);
3537     AFTER_GL_CALL;
3538   }
3539
3540   void fGetMemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname,
3541                                       GLint* params) {
3542     BEFORE_GL_CALL;
3543     mSymbols.fGetMemoryObjectParameterivEXT(memoryObject, pname, params);
3544     AFTER_GL_CALL;
3545   }
3546
3547   void fTexStorageMem2DEXT(GLenum target, GLsizei levels, GLenum internalFormat,
3548                            GLsizei width, GLsizei height, GLuint memory,
3549                            GLuint64 offset) {
3550     BEFORE_GL_CALL;
3551     mSymbols.fTexStorageMem2DEXT(target, levels, internalFormat, width, height,
3552                                  memory, offset);
3553     AFTER_GL_CALL;
3554   }
3555
3556   void fTexStorageMem2DMultisampleEXT(GLenum target, GLsizei samples,
3557                                       GLenum internalFormat, GLsizei width,
3558                                       GLsizei height,
3559                                       realGLboolean fixedSampleLocations,
3560                                       GLuint memory, GLuint64 offset) {
3561     BEFORE_GL_CALL;
3562     mSymbols.fTexStorageMem2DMultisampleEXT(target, samples, internalFormat,
3563                                             width, height, fixedSampleLocations,
3564                                             memory, offset);
3565     AFTER_GL_CALL;
3566   }
3567
3568   void fTexStorageMem3DEXT(GLenum target, GLsizei levels, GLenum internalFormat,
3569                            GLsizei width, GLsizei height, GLsizei depth,
3570                            GLuint memory, GLuint64 offset) {
3571     BEFORE_GL_CALL;
3572     mSymbols.fTexStorageMem3DEXT(target, levels, internalFormat, width, height,
3573                                  depth, memory, offset);
3574     AFTER_GL_CALL;
3575   }
3576
3577   void fTexStorageMem3DMultisampleEXT(GLenum target, GLsizei samples,
3578                                       GLenum internalFormat, GLsizei width,
3579                                       GLsizei height, GLsizei depth,
3580                                       realGLboolean fixedSampleLocations,
3581                                       GLuint memory, GLuint64 offset) {
3582     BEFORE_GL_CALL;
3583     mSymbols.fTexStorageMem3DMultisampleEXT(
3584         target, samples, internalFormat, width, height, depth,
3585         fixedSampleLocations, memory, offset);
3586     AFTER_GL_CALL;
3587   }
3588
3589   void fBufferStorageMemEXT(GLenum target, GLsizeiptr size, GLuint memory,
3590                             GLuint64 offset) {
3591     BEFORE_GL_CALL;
3592     mSymbols.fBufferStorageMemEXT(target, size, memory, offset);
3593     AFTER_GL_CALL;
3594   }
3595
3596   void fTextureStorageMem2DEXT(GLuint texture, GLsizei levels,
3597                                GLenum internalFormat, GLsizei width,
3598                                GLsizei height, GLuint memory, GLuint64 offset) {
3599     BEFORE_GL_CALL;
3600     mSymbols.fTextureStorageMem2DEXT(texture, levels, internalFormat, width,
3601                                      height, memory, offset);
3602     AFTER_GL_CALL;
3603   }
3604
3605   void fTextureStorageMem2DMultisampleEXT(GLuint texture, GLsizei samples,
3606                                           GLenum internalFormat, GLsizei width,
3607                                           GLsizei height,
3608                                           realGLboolean fixedSampleLocations,
3609                                           GLuint memory, GLuint64 offset) {
3610     BEFORE_GL_CALL;
3611     mSymbols.fTextureStorageMem2DMultisampleEXT(
3612         texture, samples, internalFormat, width, height, fixedSampleLocations,
3613         memory, offset);
3614     AFTER_GL_CALL;
3615   }
3616
3617   void fTextureStorageMem3DEXT(GLuint texture, GLsizei levels,
3618                                GLenum internalFormat, GLsizei width,
3619                                GLsizei height, GLsizei depth, GLuint memory,
3620                                GLuint64 offset) {
3621     BEFORE_GL_CALL;
3622     mSymbols.fTextureStorageMem3DEXT(texture, levels, internalFormat, width,
3623                                      height, depth, memory, offset);
3624     AFTER_GL_CALL;
3625   }
3626
3627   void fTextureStorageMem3DMultisampleEXT(GLuint texture, GLsizei samples,
3628                                           GLenum internalFormat, GLsizei width,
3629                                           GLsizei height, GLsizei depth,
3630                                           realGLboolean fixedSampleLocations,
3631                                           GLuint memory, GLuint64 offset) {
3632     BEFORE_GL_CALL;
3633     mSymbols.fTextureStorageMem3DMultisampleEXT(
3634         texture, samples, internalFormat, width, height, depth,
3635         fixedSampleLocations, memory, offset);
3636     AFTER_GL_CALL;
3637   }
3638
3639   void fNamedBufferStorageMemEXT(GLuint buffer, GLsizeiptr size, GLuint memory,
3640                                  GLuint64 offset) {
3641     BEFORE_GL_CALL;
3642     mSymbols.fNamedBufferStorageMemEXT(buffer, size, memory, offset);
3643     AFTER_GL_CALL;
3644   }
3645
3646   // -----------------------------------------------------------------------------
3647   // Extension EXT_memory_object_fd
3648
3649   void fImportMemoryFdEXT(GLuint memory, GLuint64 size, GLenum handleType,
3650                           GLint fd) {
3651     BEFORE_GL_CALL;
3652     mSymbols.fImportMemoryFdEXT(memory, size, handleType, fd);
3653     AFTER_GL_CALL;
3654   }
3655
3656   // -
3657
3658 #undef BEFORE_GL_CALL
3659 #undef AFTER_GL_CALL
3660 #undef ASSERT_SYMBOL_PRESENT
3661 // #undef TRACKING_CONTEXT // Needed in GLContext.cpp
3662 #undef ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL
3663
3664   // -----------------------------------------------------------------------------
3665   // Constructor
3666  protected:
3667   explicit GLContext(const GLContextDesc&, GLContext* sharedContext = nullptr,
3668                      bool canUseTLSIsCurrent = false);
3669
3670   // -----------------------------------------------------------------------------
3671   // Destructor
3672  public:
3673   virtual ~GLContext();
3674
3675   // Mark this context as destroyed.  This will nullptr out all
3676   // the GL function pointers!
3677   void MarkDestroyed();
3678
3679  protected:
3680   virtual void OnMarkDestroyed() {}
3681
3682   // -----------------------------------------------------------------------------
3683   // Everything that isn't standard GL APIs
3684  protected:
3685   typedef gfx::SurfaceFormat SurfaceFormat;
3686
3687  public:
3688   virtual void ReleaseSurface() {}
3689
3690   bool IsDestroyed() const {
3691     // MarkDestroyed will mark all these as null.
3692     return mContextLost && mSymbols.fUseProgram == nullptr;
3693   }
3694
3695   GLContext* GetSharedContext() { return mSharedContext; }
3696
3697   /**
3698    * Returns true if the thread on which this context was created is the
3699    * currently executing thread.
3700    */
3701   bool IsValidOwningThread() const;
3702
3703   static void PlatformStartup();
3704
3705  public:
3706   /**
3707    * If this context wraps a double-buffered target, swap the back
3708    * and front buffers.  It should be assumed that after a swap, the
3709    * contents of the new back buffer are undefined.
3710    */
3711   virtual bool SwapBuffers() { return false; }
3712
3713   /**
3714    * Stores a damage region (in origin bottom left coordinates), which
3715    * makes the next SwapBuffers call do eglSwapBuffersWithDamage if supported.
3716    *
3717    * Note that even if only part of the context is damaged, the entire buffer
3718    * needs to be filled with up-to-date contents. This region is only a hint
3719    * telling the system compositor which parts of the buffer were updated.
3720    */
3721   virtual void SetDamage(const nsIntRegion& aDamageRegion) {}
3722
3723   /**
3724    * Get the buffer age. If it returns 0, that indicates the buffer state is
3725    * unknown and the entire frame should be redrawn.
3726    */
3727   virtual GLint GetBufferAge() const { return 0; }
3728
3729   /**
3730    * Defines a two-dimensional texture image for context target surface
3731    */
3732   virtual bool BindTexImage() { return false; }
3733   /*
3734    * Releases a color buffer that is being used as a texture
3735    */
3736   virtual bool ReleaseTexImage() { return false; }
3737
3738   virtual Maybe<SymbolLoader> GetSymbolLoader() const = 0;
3739
3740   void BindFB(GLuint fb) {
3741     fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, fb);
3742     MOZ_GL_ASSERT(this, !fb || fIsFramebuffer(fb));
3743   }
3744
3745   void BindDrawFB(GLuint fb) {
3746     fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER_EXT, fb);
3747   }
3748
3749   void BindReadFB(GLuint fb) {
3750     fBindFramebuffer(LOCAL_GL_READ_FRAMEBUFFER_EXT, fb);
3751   }
3752
3753   GLuint GetDrawFB() const {
3754     return GetIntAs<GLuint>(LOCAL_GL_DRAW_FRAMEBUFFER_BINDING_EXT);
3755   }
3756
3757   GLuint GetReadFB() const {
3758     auto bindEnum = LOCAL_GL_READ_FRAMEBUFFER_BINDING_EXT;
3759     if (!IsSupported(GLFeature::split_framebuffer)) {
3760       bindEnum = LOCAL_GL_FRAMEBUFFER_BINDING;
3761     }
3762     return GetIntAs<GLuint>(bindEnum);
3763   }
3764
3765   GLuint GetFB() const {
3766     const auto ret = GetDrawFB();
3767     MOZ_ASSERT(ret == GetReadFB());
3768     return ret;
3769   }
3770
3771  private:
3772   void GetShaderPrecisionFormatNonES2(GLenum shadertype, GLenum precisiontype,
3773                                       GLint* range, GLint* precision) {
3774     switch (precisiontype) {
3775       case LOCAL_GL_LOW_FLOAT:
3776       case LOCAL_GL_MEDIUM_FLOAT:
3777       case LOCAL_GL_HIGH_FLOAT:
3778         // Assume IEEE 754 precision
3779         range[0] = 127;
3780         range[1] = 127;
3781         *precision = 23;
3782         break;
3783       case LOCAL_GL_LOW_INT:
3784       case LOCAL_GL_MEDIUM_INT:
3785       case LOCAL_GL_HIGH_INT:
3786         // Some (most) hardware only supports single-precision floating-point
3787         // numbers, which can accurately represent integers up to +/-16777216
3788         range[0] = 24;
3789         range[1] = 24;
3790         *precision = 0;
3791         break;
3792     }
3793   }
3794
3795  public:
3796   virtual GLenum GetPreferredARGB32Format() const { return LOCAL_GL_RGBA; }
3797
3798   virtual GLenum GetPreferredEGLImageTextureTarget() const {
3799 #ifdef MOZ_WIDGET_GTK
3800     return LOCAL_GL_TEXTURE_2D;
3801 #else
3802     if (IsExtensionSupported(OES_EGL_image_external) &&
3803         mRenderer != GLRenderer::AndroidEmulator) {
3804       return LOCAL_GL_TEXTURE_EXTERNAL;
3805     }
3806     return LOCAL_GL_TEXTURE_2D;
3807 #endif
3808   }
3809
3810   virtual bool RenewSurface(widget::CompositorWidget* aWidget) { return false; }
3811
3812   // Shared code for GL extensions and GLX extensions.
3813   static bool ListHasExtension(const GLubyte* extensions,
3814                                const char* extension);
3815
3816  public:
3817   enum {
3818     DebugFlagEnabled = 1 << 0,
3819     DebugFlagTrace = 1 << 1,
3820     DebugFlagAbortOnError = 1 << 2
3821   };
3822
3823   const uint8_t mDebugFlags;
3824   static uint8_t ChooseDebugFlags(CreateContextFlags createFlags);
3825
3826  protected:
3827   RefPtr<GLContext> mSharedContext;
3828
3829  public:
3830   // The thread id which this context was created.
3831   Maybe<PlatformThreadId> mOwningThreadId;
3832
3833  protected:
3834   GLContextSymbols mSymbols = {};
3835
3836   UniquePtr<GLBlitHelper> mBlitHelper;
3837   UniquePtr<GLReadTexImageHelper> mReadTexImageHelper;
3838
3839  public:
3840   GLBlitHelper* BlitHelper();
3841   GLReadTexImageHelper* ReadTexImageHelper();
3842
3843   // Assumes shares are created by all sharing with the same global context.
3844   bool SharesWith(const GLContext* other) const {
3845     MOZ_ASSERT(!this->mSharedContext || !this->mSharedContext->mSharedContext);
3846     MOZ_ASSERT(!other->mSharedContext ||
3847                !other->mSharedContext->mSharedContext);
3848     MOZ_ASSERT(!this->mSharedContext || !other->mSharedContext ||
3849                this->mSharedContext == other->mSharedContext);
3850
3851     const GLContext* thisShared =
3852         this->mSharedContext ? this->mSharedContext : this;
3853     const GLContext* otherShared =
3854         other->mSharedContext ? other->mSharedContext : other;
3855
3856     return thisShared == otherShared;
3857   }
3858
3859   bool IsFramebufferComplete(GLuint fb, GLenum* status = nullptr);
3860
3861   // Does not check completeness.
3862   void AttachBuffersToFB(GLuint colorTex, GLuint colorRB, GLuint depthRB,
3863                          GLuint stencilRB, GLuint fb,
3864                          GLenum target = LOCAL_GL_TEXTURE_2D);
3865
3866   // Passing null is fine if the value you'd get is 0.
3867   bool AssembleOffscreenFBs(const GLuint colorMSRB, const GLuint depthRB,
3868                             const GLuint stencilRB, const GLuint texture,
3869                             GLuint* drawFB, GLuint* readFB);
3870
3871  protected:
3872   SharedSurface* mLockedSurface = nullptr;
3873
3874  public:
3875   void LockSurface(SharedSurface* surf) { mLockedSurface = surf; }
3876
3877   void UnlockSurface(SharedSurface* surf) {
3878     MOZ_ASSERT(mLockedSurface == surf);
3879     mLockedSurface = nullptr;
3880   }
3881
3882   SharedSurface* GetLockedSurface() const { return mLockedSurface; }
3883
3884   bool IsOffscreen() const { return mDesc.isOffscreen; }
3885
3886   bool WorkAroundDriverBugs() const { return mWorkAroundDriverBugs; }
3887
3888   bool IsOffscreenSizeAllowed(const gfx::IntSize& aSize) const;
3889
3890   virtual bool Init();
3891
3892  private:
3893   bool InitImpl();
3894   void LoadMoreSymbols(const SymbolLoader& loader);
3895   bool LoadExtSymbols(const SymbolLoader& loader, const SymLoadStruct* list,
3896                       GLExtensions ext);
3897   bool LoadFeatureSymbols(const SymbolLoader& loader, const SymLoadStruct* list,
3898                           GLFeature feature);
3899
3900  protected:
3901   void InitExtensions();
3902
3903   GLint mViewportRect[4] = {};
3904   GLint mScissorRect[4] = {};
3905
3906   uint32_t mMaxTexOrRbSize = 0;
3907   GLint mMaxTextureSize = 0;
3908   GLint mMaxCubeMapTextureSize = 0;
3909   GLint mMaxRenderbufferSize = 0;
3910   GLint mMaxViewportDims[2] = {};
3911   GLsizei mMaxSamples = 0;
3912   bool mNeedsTextureSizeChecks = false;
3913   bool mNeedsFlushBeforeDeleteFB = false;
3914   bool mTextureAllocCrashesOnMapFailure = false;
3915   const bool mWorkAroundDriverBugs;
3916   mutable uint64_t mSyncGLCallCount = 0;
3917
3918   bool IsTextureSizeSafeToPassToDriver(GLenum target, GLsizei width,
3919                                        GLsizei height) const {
3920     if (mNeedsTextureSizeChecks) {
3921       // some drivers incorrectly handle some large texture sizes that are below
3922       // the max texture size that they report. So we check ourselves against
3923       // our own values (mMax[CubeMap]TextureSize). see bug 737182 for Mac Intel
3924       // 2D textures see bug 684882 for Mac Intel cube map textures see bug
3925       // 814716 for Mesa Nouveau
3926       GLsizei maxSize =
3927           target == LOCAL_GL_TEXTURE_CUBE_MAP ||
3928                   (target >= LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X &&
3929                    target <= LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z)
3930               ? mMaxCubeMapTextureSize
3931               : mMaxTextureSize;
3932       return width <= maxSize && height <= maxSize;
3933     }
3934     return true;
3935   }
3936
3937  public:
3938   auto MaxSamples() const { return uint32_t(mMaxSamples); }
3939   auto MaxTextureSize() const { return uint32_t(mMaxTextureSize); }
3940   auto MaxRenderbufferSize() const { return uint32_t(mMaxRenderbufferSize); }
3941   auto MaxTexOrRbSize() const { return mMaxTexOrRbSize; }
3942
3943 #ifdef MOZ_GL_DEBUG_BUILD
3944   void CreatedProgram(GLContext* aOrigin, GLuint aName);
3945   void CreatedShader(GLContext* aOrigin, GLuint aName);
3946   void CreatedBuffers(GLContext* aOrigin, GLsizei aCount, GLuint* aNames);
3947   void CreatedQueries(GLContext* aOrigin, GLsizei aCount, GLuint* aNames);
3948   void CreatedTextures(GLContext* aOrigin, GLsizei aCount, GLuint* aNames);
3949   void CreatedFramebuffers(GLContext* aOrigin, GLsizei aCount, GLuint* aNames);
3950   void CreatedRenderbuffers(GLContext* aOrigin, GLsizei aCount, GLuint* aNames);
3951   void DeletedProgram(GLContext* aOrigin, GLuint aName);
3952   void DeletedShader(GLContext* aOrigin, GLuint aName);
3953   void DeletedBuffers(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames);
3954   void DeletedQueries(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames);
3955   void DeletedTextures(GLContext* aOrigin, GLsizei aCount,
3956                        const GLuint* aNames);
3957   void DeletedFramebuffers(GLContext* aOrigin, GLsizei aCount,
3958                            const GLuint* aNames);
3959   void DeletedRenderbuffers(GLContext* aOrigin, GLsizei aCount,
3960                             const GLuint* aNames);
3961
3962   void SharedContextDestroyed(GLContext* aChild);
3963   void ReportOutstandingNames();
3964
3965   struct NamedResource {
3966     NamedResource() : origin(nullptr), name(0), originDeleted(false) {}
3967
3968     NamedResource(GLContext* aOrigin, GLuint aName)
3969         : origin(aOrigin), name(aName), originDeleted(false) {}
3970
3971     GLContext* origin;
3972     GLuint name;
3973     bool originDeleted;
3974
3975     // for sorting
3976     bool operator<(const NamedResource& aOther) const {
3977       if (intptr_t(origin) < intptr_t(aOther.origin)) return true;
3978       if (name < aOther.name) return true;
3979       return false;
3980     }
3981     bool operator==(const NamedResource& aOther) const {
3982       return origin == aOther.origin && name == aOther.name &&
3983              originDeleted == aOther.originDeleted;
3984     }
3985   };
3986
3987   nsTArray<NamedResource> mTrackedPrograms;
3988   nsTArray<NamedResource> mTrackedShaders;
3989   nsTArray<NamedResource> mTrackedTextures;
3990   nsTArray<NamedResource> mTrackedFramebuffers;
3991   nsTArray<NamedResource> mTrackedRenderbuffers;
3992   nsTArray<NamedResource> mTrackedBuffers;
3993   nsTArray<NamedResource> mTrackedQueries;
3994 #endif
3995
3996  protected:
3997   bool mHeavyGLCallsSinceLastFlush = false;
3998
3999  public:
4000   void FlushIfHeavyGLCallsSinceLastFlush();
4001   static bool ShouldSpew();
4002   static bool ShouldDumpExts();
4003
4004   // --
4005
4006   void TexParams_SetClampNoMips(GLenum target = LOCAL_GL_TEXTURE_2D) {
4007     fTexParameteri(target, LOCAL_GL_TEXTURE_WRAP_S, LOCAL_GL_CLAMP_TO_EDGE);
4008     fTexParameteri(target, LOCAL_GL_TEXTURE_WRAP_T, LOCAL_GL_CLAMP_TO_EDGE);
4009     fTexParameteri(target, LOCAL_GL_TEXTURE_MAG_FILTER, LOCAL_GL_NEAREST);
4010     fTexParameteri(target, LOCAL_GL_TEXTURE_MIN_FILTER, LOCAL_GL_NEAREST);
4011   }
4012
4013   // --
4014
4015   GLuint CreateFramebuffer() {
4016     GLuint x = 0;
4017     fGenFramebuffers(1, &x);
4018     return x;
4019   }
4020   GLuint CreateRenderbuffer() {
4021     GLuint x = 0;
4022     fGenRenderbuffers(1, &x);
4023     return x;
4024   }
4025   GLuint CreateTexture() {
4026     GLuint x = 0;
4027     fGenTextures(1, &x);
4028     return x;
4029   }
4030
4031   void DeleteFramebuffer(const GLuint x) { fDeleteFramebuffers(1, &x); }
4032   void DeleteRenderbuffer(const GLuint x) { fDeleteRenderbuffers(1, &x); }
4033   void DeleteTexture(const GLuint x) { fDeleteTextures(1, &x); }
4034 };
4035
4036 bool DoesStringMatch(const char* aString, const char* aWantedString);
4037
4038 void SplitByChar(const nsACString& str, const char delim,
4039                  std::vector<nsCString>* const out);
4040
4041 template <size_t N>
4042 bool MarkBitfieldByString(const nsACString& str,
4043                           const char* const (&markStrList)[N],
4044                           std::bitset<N>* const out_markList) {
4045   for (size_t i = 0; i < N; i++) {
4046     if (str.Equals(markStrList[i])) {
4047       (*out_markList)[i] = 1;
4048       return true;
4049     }
4050   }
4051   return false;
4052 }
4053
4054 template <size_t N>
4055 void MarkBitfieldByStrings(const std::vector<nsCString>& strList,
4056                            bool dumpStrings,
4057                            const char* const (&markStrList)[N],
4058                            std::bitset<N>* const out_markList) {
4059   for (auto itr = strList.begin(); itr != strList.end(); ++itr) {
4060     const nsACString& str = *itr;
4061     const bool wasMarked = MarkBitfieldByString(str, markStrList, out_markList);
4062     if (dumpStrings)
4063       printf_stderr("  %s%s\n", str.BeginReading(), wasMarked ? "(*)" : "");
4064   }
4065 }
4066
4067 // -
4068
4069 class Renderbuffer final {
4070  public:
4071   const WeakPtr<GLContext> weakGl;
4072   const GLuint name;
4073
4074  private:
4075   static GLuint Create(GLContext& gl) {
4076     GLuint ret = 0;
4077     gl.fGenRenderbuffers(1, &ret);
4078     return ret;
4079   }
4080
4081  public:
4082   explicit Renderbuffer(GLContext& gl) : weakGl(&gl), name(Create(gl)) {}
4083
4084   ~Renderbuffer() {
4085     const RefPtr<GLContext> gl = weakGl.get();
4086     if (!gl || !gl->MakeCurrent()) return;
4087     gl->fDeleteRenderbuffers(1, &name);
4088   }
4089 };
4090
4091 // -
4092
4093 class Texture final {
4094  public:
4095   const WeakPtr<GLContext> weakGl;
4096   const GLuint name;
4097
4098  private:
4099   static GLuint Create(GLContext& gl) {
4100     GLuint ret = 0;
4101     gl.fGenTextures(1, &ret);
4102     return ret;
4103   }
4104
4105  public:
4106   explicit Texture(GLContext& gl) : weakGl(&gl), name(Create(gl)) {}
4107
4108   ~Texture() {
4109     const RefPtr<GLContext> gl = weakGl.get();
4110     if (!gl || !gl->MakeCurrent()) return;
4111     gl->fDeleteTextures(1, &name);
4112   }
4113 };
4114
4115 // -
4116
4117 class Sampler final {
4118  public:
4119   const WeakPtr<GLContext> weakGl;
4120   const GLuint name;
4121
4122  private:
4123   static GLuint Create(GLContext& gl) {
4124     GLuint ret = 0;
4125     gl.fGenSamplers(1, &ret);
4126     return ret;
4127   }
4128
4129  public:
4130   explicit Sampler(GLContext& gl) : weakGl(&gl), name(Create(gl)) {}
4131
4132   ~Sampler() {
4133     const RefPtr<GLContext> gl = weakGl.get();
4134     if (!gl || !gl->MakeCurrent()) return;
4135     gl->fDeleteSamplers(1, &name);
4136   }
4137 };
4138
4139 /**
4140  * Helper function that creates a 2D texture aSize.width x aSize.height with
4141  * storage type specified by aFormats. Returns GL texture object id.
4142  *
4143  * See mozilla::gl::CreateTexture.
4144  */
4145 UniquePtr<Texture> CreateTexture(GLContext&, const gfx::IntSize& size);
4146
4147 /**
4148  * Helper function that calculates the number of bytes required per
4149  * texel for a texture from its format and type.
4150  */
4151 uint32_t GetBytesPerTexel(GLenum format, GLenum type);
4152
4153 void MesaMemoryLeakWorkaround();
4154
4155 } /* namespace gl */
4156 } /* namespace mozilla */
4157
4158 #endif /* GLCONTEXT_H_ */