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