Load the GL_ANGLE_robust_client_memory entry points.

ui/gl/gl_bindings_autogen_mock.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // This file is auto-generated from
 // ui/gl/generate_bindings.py
 // It's formatted by clang-format using chromium coding style:
 //    clang-format -i -style=chromium filename
 // DO NOT EDIT!
 
@@ skipping 1234 matching lines @@
 void GL_BINDING_CALL
 MockGLInterface::Mock_glGetActiveUniformBlockiv(GLuint program,
                                                 GLuint uniformBlockIndex,
                                                 GLenum pname,
                                                 GLint* params) {
   MakeFunctionUnique("glGetActiveUniformBlockiv");
   interface_->GetActiveUniformBlockiv(program, uniformBlockIndex, pname,
                                       params);
 }
 
+void GL_BINDING_CALL MockGLInterface::Mock_glGetActiveUniformBlockivRobustANGLE(
+    GLuint program,
+    GLuint uniformBlockIndex,
+    GLenum pname,
+    GLsizei bufSize,
+    GLsizei* length,
+    GLint* params) {
+  MakeFunctionUnique("glGetActiveUniformBlockivRobustANGLE");
+  interface_->GetActiveUniformBlockivRobustANGLE(
+      program, uniformBlockIndex, pname, bufSize, length, params);
+}
+
 void GL_BINDING_CALL
 MockGLInterface::Mock_glGetActiveUniformsiv(GLuint program,
                                             GLsizei uniformCount,
                                             const GLuint* uniformIndices,
                                             GLenum pname,
                                             GLint* params) {
   MakeFunctionUnique("glGetActiveUniformsiv");
   interface_->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname,
                                   params);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glGetAttachedShaders(GLuint program,
                                            GLsizei maxcount,
                                            GLsizei* count,
                                            GLuint* shaders) {
   MakeFunctionUnique("glGetAttachedShaders");
   interface_->GetAttachedShaders(program, maxcount, count, shaders);
 }
 
 GLint GL_BINDING_CALL
 MockGLInterface::Mock_glGetAttribLocation(GLuint program, const char* name) {
   MakeFunctionUnique("glGetAttribLocation");
   return interface_->GetAttribLocation(program, name);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetBooleani_vRobustANGLE(GLenum target,
+                                                 GLuint index,
+                                                 GLsizei bufSize,
+                                                 GLsizei* length,
+                                                 GLboolean* data) {
+  MakeFunctionUnique("glGetBooleani_vRobustANGLE");
+  interface_->GetBooleani_vRobustANGLE(target, index, bufSize, length, data);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glGetBooleanv(GLenum pname,
                                                          GLboolean* params) {
   MakeFunctionUnique("glGetBooleanv");
   interface_->GetBooleanv(pname, params);
 }
 
 void GL_BINDING_CALL
+MockGLInterface::Mock_glGetBooleanvRobustANGLE(GLenum pname,
+                                               GLsizei bufSize,
+                                               GLsizei* length,
+                                               GLboolean* data) {
+  MakeFunctionUnique("glGetBooleanvRobustANGLE");
+  interface_->GetBooleanvRobustANGLE(pname, bufSize, length, data);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetBufferParameteri64vRobustANGLE(GLenum target,
+                                                          GLenum pname,
+                                                          GLsizei bufSize,
+                                                          GLsizei* length,
+                                                          GLint64* params) {
+  MakeFunctionUnique("glGetBufferParameteri64vRobustANGLE");
+  interface_->GetBufferParameteri64vRobustANGLE(target, pname, bufSize, length,
+                                                params);
+}
+
+void GL_BINDING_CALL
 MockGLInterface::Mock_glGetBufferParameteriv(GLenum target,
                                              GLenum pname,
                                              GLint* params) {
   MakeFunctionUnique("glGetBufferParameteriv");
   interface_->GetBufferParameteriv(target, pname, params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetBufferParameterivRobustANGLE(GLenum target,
+                                                        GLenum pname,
+                                                        GLsizei bufSize,
+                                                        GLsizei* length,
+                                                        GLint* params) {
+  MakeFunctionUnique("glGetBufferParameterivRobustANGLE");
+  interface_->GetBufferParameterivRobustANGLE(target, pname, bufSize, length,
+                                              params);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetBufferPointervRobustANGLE(GLenum target,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei* length,
+                                                     void** params) {
+  MakeFunctionUnique("glGetBufferPointervRobustANGLE");
+  interface_->GetBufferPointervRobustANGLE(target, pname, bufSize, length,
+                                           params);
+}
+
 GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetError(void) {
   MakeFunctionUnique("glGetError");
   return interface_->GetError();
 }
 
 void GL_BINDING_CALL MockGLInterface::Mock_glGetFenceivNV(GLuint fence,
                                                           GLenum pname,
                                                           GLint* params) {
   MakeFunctionUnique("glGetFenceivNV");
   interface_->GetFenceivNV(fence, pname, params);
 }
 
 void GL_BINDING_CALL MockGLInterface::Mock_glGetFloatv(GLenum pname,
                                                        GLfloat* params) {
   MakeFunctionUnique("glGetFloatv");
   interface_->GetFloatv(pname, params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetFloatvRobustANGLE(GLenum pname,
+                                             GLsizei bufSize,
+                                             GLsizei* length,
+                                             GLfloat* data) {
+  MakeFunctionUnique("glGetFloatvRobustANGLE");
+  interface_->GetFloatvRobustANGLE(pname, bufSize, length, data);
+}
+
 GLint GL_BINDING_CALL
 MockGLInterface::Mock_glGetFragDataIndex(GLuint program, const char* name) {
   MakeFunctionUnique("glGetFragDataIndex");
   return interface_->GetFragDataIndex(program, name);
 }
 
 GLint GL_BINDING_CALL
 MockGLInterface::Mock_glGetFragDataIndexEXT(GLuint program, const char* name) {
   MakeFunctionUnique("glGetFragDataIndexEXT");
   return interface_->GetFragDataIndex(program, name);
@@ skipping 19 matching lines @@
 MockGLInterface::Mock_glGetFramebufferAttachmentParameterivEXT(
     GLenum target,
     GLenum attachment,
     GLenum pname,
     GLint* params) {
   MakeFunctionUnique("glGetFramebufferAttachmentParameterivEXT");
   interface_->GetFramebufferAttachmentParameterivEXT(target, attachment, pname,
                                                      params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetFramebufferAttachmentParameterivRobustANGLE(
+    GLenum target,
+    GLenum attachment,
+    GLenum pname,
+    GLsizei bufSize,
+    GLsizei* length,
+    GLint* params) {
+  MakeFunctionUnique("glGetFramebufferAttachmentParameterivRobustANGLE");
+  interface_->GetFramebufferAttachmentParameterivRobustANGLE(
+      target, attachment, pname, bufSize, length, params);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetFramebufferParameterivRobustANGLE(GLenum target,
+                                                             GLenum pname,
+                                                             GLsizei bufSize,
+                                                             GLsizei* length,
+                                                             GLint* params) {
+  MakeFunctionUnique("glGetFramebufferParameterivRobustANGLE");
+  interface_->GetFramebufferParameterivRobustANGLE(target, pname, bufSize,
+                                                   length, params);
+}
+
 GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatus(void) {
   MakeFunctionUnique("glGetGraphicsResetStatus");
   return interface_->GetGraphicsResetStatusARB();
 }
 
 GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatusARB(void) {
   MakeFunctionUnique("glGetGraphicsResetStatusARB");
   return interface_->GetGraphicsResetStatusARB();
 }
 
 GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatusEXT(void) {
   MakeFunctionUnique("glGetGraphicsResetStatusEXT");
   return interface_->GetGraphicsResetStatusARB();
 }
 
 GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatusKHR(void) {
   MakeFunctionUnique("glGetGraphicsResetStatusKHR");
   return interface_->GetGraphicsResetStatusARB();
 }
 
 void GL_BINDING_CALL MockGLInterface::Mock_glGetInteger64i_v(GLenum target,
                                                              GLuint index,
                                                              GLint64* data) {
   MakeFunctionUnique("glGetInteger64i_v");
   interface_->GetInteger64i_v(target, index, data);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetInteger64i_vRobustANGLE(GLenum target,
+                                                   GLuint index,
+                                                   GLsizei bufSize,
+                                                   GLsizei* length,
+                                                   GLint64* data) {
+  MakeFunctionUnique("glGetInteger64i_vRobustANGLE");
+  interface_->GetInteger64i_vRobustANGLE(target, index, bufSize, length, data);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glGetInteger64v(GLenum pname,
                                                            GLint64* params) {
   MakeFunctionUnique("glGetInteger64v");
   interface_->GetInteger64v(pname, params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetInteger64vRobustANGLE(GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei* length,
+                                                 GLint64* data) {
+  MakeFunctionUnique("glGetInteger64vRobustANGLE");
+  interface_->GetInteger64vRobustANGLE(pname, bufSize, length, data);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glGetIntegeri_v(GLenum target,
                                                            GLuint index,
                                                            GLint* data) {
   MakeFunctionUnique("glGetIntegeri_v");
   interface_->GetIntegeri_v(target, index, data);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetIntegeri_vRobustANGLE(GLenum target,
+                                                 GLuint index,
+                                                 GLsizei bufSize,
+                                                 GLsizei* length,
+                                                 GLint* data) {
+  MakeFunctionUnique("glGetIntegeri_vRobustANGLE");
+  interface_->GetIntegeri_vRobustANGLE(target, index, bufSize, length, data);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glGetIntegerv(GLenum pname,
                                                          GLint* params) {
   MakeFunctionUnique("glGetIntegerv");
   interface_->GetIntegerv(pname, params);
 }
 
 void GL_BINDING_CALL
+MockGLInterface::Mock_glGetIntegervRobustANGLE(GLenum pname,
+                                               GLsizei bufSize,
+                                               GLsizei* length,
+                                               GLint* data) {
+  MakeFunctionUnique("glGetIntegervRobustANGLE");
+  interface_->GetIntegervRobustANGLE(pname, bufSize, length, data);
+}
+
+void GL_BINDING_CALL
 MockGLInterface::Mock_glGetInternalformativ(GLenum target,
                                             GLenum internalformat,
                                             GLenum pname,
                                             GLsizei bufSize,
                                             GLint* params) {
   MakeFunctionUnique("glGetInternalformativ");
   interface_->GetInternalformativ(target, internalformat, pname, bufSize,
                                   params);
 }
 
 void GL_BINDING_CALL
+MockGLInterface::Mock_glGetMultisamplefvRobustANGLE(GLenum pname,
+                                                    GLuint index,
+                                                    GLsizei bufSize,
+                                                    GLsizei* length,
+                                                    GLfloat* val) {
+  MakeFunctionUnique("glGetMultisamplefvRobustANGLE");
+  interface_->GetMultisamplefvRobustANGLE(pname, index, bufSize, length, val);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetPointervRobustANGLERobustANGLE(GLenum pname,
+                                                          GLsizei bufSize,
+                                                          GLsizei* length,
+                                                          void** params) {
+  MakeFunctionUnique("glGetPointervRobustANGLERobustANGLE");
+  interface_->GetPointervRobustANGLERobustANGLE(pname, bufSize, length, params);
+}
+
+void GL_BINDING_CALL
 MockGLInterface::Mock_glGetProgramBinary(GLuint program,
                                          GLsizei bufSize,
                                          GLsizei* length,
                                          GLenum* binaryFormat,
                                          GLvoid* binary) {
   MakeFunctionUnique("glGetProgramBinary");
   interface_->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
 }
 
 void GL_BINDING_CALL
@@ skipping 16 matching lines @@
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glGetProgramInterfaceiv(GLuint program,
                                               GLenum programInterface,
                                               GLenum pname,
                                               GLint* params) {
   MakeFunctionUnique("glGetProgramInterfaceiv");
   interface_->GetProgramInterfaceiv(program, programInterface, pname, params);
 }
 
+void GL_BINDING_CALL MockGLInterface::Mock_glGetProgramInterfaceivRobustANGLE(
+    GLuint program,
+    GLenum programInterface,
+    GLenum pname,
+    GLsizei bufSize,
+    GLsizei* length,
+    GLint* params) {
+  MakeFunctionUnique("glGetProgramInterfaceivRobustANGLE");
+  interface_->GetProgramInterfaceivRobustANGLE(program, programInterface, pname,
+                                               bufSize, length, params);
+}
+
 GLint GL_BINDING_CALL
 MockGLInterface::Mock_glGetProgramResourceLocation(GLuint program,
                                                    GLenum programInterface,
                                                    const char* name) {
   MakeFunctionUnique("glGetProgramResourceLocation");
   return interface_->GetProgramResourceLocation(program, programInterface,
                                                 name);
 }
 
 void GL_BINDING_CALL
@@ skipping 23 matching lines @@
 }
 
 void GL_BINDING_CALL MockGLInterface::Mock_glGetProgramiv(GLuint program,
                                                           GLenum pname,
                                                           GLint* params) {
   MakeFunctionUnique("glGetProgramiv");
   interface_->GetProgramiv(program, pname, params);
 }
 
 void GL_BINDING_CALL
+MockGLInterface::Mock_glGetProgramivRobustANGLE(GLuint program,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei* length,
+                                                GLint* params) {
+  MakeFunctionUnique("glGetProgramivRobustANGLE");
+  interface_->GetProgramivRobustANGLE(program, pname, bufSize, length, params);
+}
+
+void GL_BINDING_CALL
 MockGLInterface::Mock_glGetQueryObjecti64v(GLuint id,
                                            GLenum pname,
                                            GLint64* params) {
   MakeFunctionUnique("glGetQueryObjecti64v");
   interface_->GetQueryObjecti64v(id, pname, params);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glGetQueryObjecti64vEXT(GLuint id,
                                               GLenum pname,
                                               GLint64* params) {
   MakeFunctionUnique("glGetQueryObjecti64vEXT");
   interface_->GetQueryObjecti64v(id, pname, params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetQueryObjecti64vRobustANGLE(GLuint id,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei* length,
+                                                      GLint64* params) {
+  MakeFunctionUnique("glGetQueryObjecti64vRobustANGLE");
+  interface_->GetQueryObjecti64vRobustANGLE(id, pname, bufSize, length, params);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryObjectiv(GLuint id,
                                                               GLenum pname,
                                                               GLint* params) {
   MakeFunctionUnique("glGetQueryObjectiv");
   interface_->GetQueryObjectiv(id, pname, params);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glGetQueryObjectivARB(GLuint id,
                                             GLenum pname,
                                             GLint* params) {
   MakeFunctionUnique("glGetQueryObjectivARB");
   interface_->GetQueryObjectiv(id, pname, params);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glGetQueryObjectivEXT(GLuint id,
                                             GLenum pname,
                                             GLint* params) {
   MakeFunctionUnique("glGetQueryObjectivEXT");
   interface_->GetQueryObjectiv(id, pname, params);
 }
 
 void GL_BINDING_CALL
+MockGLInterface::Mock_glGetQueryObjectivRobustANGLE(GLuint id,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei* length,
+                                                    GLint* params) {
+  MakeFunctionUnique("glGetQueryObjectivRobustANGLE");
+  interface_->GetQueryObjectivRobustANGLE(id, pname, bufSize, length, params);
+}
+
+void GL_BINDING_CALL
 MockGLInterface::Mock_glGetQueryObjectui64v(GLuint id,
                                             GLenum pname,
                                             GLuint64* params) {
   MakeFunctionUnique("glGetQueryObjectui64v");
   interface_->GetQueryObjectui64v(id, pname, params);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glGetQueryObjectui64vEXT(GLuint id,
                                                GLenum pname,
                                                GLuint64* params) {
   MakeFunctionUnique("glGetQueryObjectui64vEXT");
   interface_->GetQueryObjectui64v(id, pname, params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetQueryObjectui64vRobustANGLE(GLuint id,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei* length,
+                                                       GLuint64* params) {
+  MakeFunctionUnique("glGetQueryObjectui64vRobustANGLE");
+  interface_->GetQueryObjectui64vRobustANGLE(id, pname, bufSize, length,
+                                             params);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryObjectuiv(GLuint id,
                                                                GLenum pname,
                                                                GLuint* params) {
   MakeFunctionUnique("glGetQueryObjectuiv");
   interface_->GetQueryObjectuiv(id, pname, params);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glGetQueryObjectuivARB(GLuint id,
                                              GLenum pname,
                                              GLuint* params) {
   MakeFunctionUnique("glGetQueryObjectuivARB");
   interface_->GetQueryObjectuiv(id, pname, params);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glGetQueryObjectuivEXT(GLuint id,
                                              GLenum pname,
                                              GLuint* params) {
   MakeFunctionUnique("glGetQueryObjectuivEXT");
   interface_->GetQueryObjectuiv(id, pname, params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetQueryObjectuivRobustANGLE(GLuint id,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei* length,
+                                                     GLuint* params) {
+  MakeFunctionUnique("glGetQueryObjectuivRobustANGLE");
+  interface_->GetQueryObjectuivRobustANGLE(id, pname, bufSize, length, params);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryiv(GLenum target,
                                                         GLenum pname,
                                                         GLint* params) {
   MakeFunctionUnique("glGetQueryiv");
   interface_->GetQueryiv(target, pname, params);
 }
 
 void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryivARB(GLenum target,
                                                            GLenum pname,
                                                            GLint* params) {
   MakeFunctionUnique("glGetQueryivARB");
   interface_->GetQueryiv(target, pname, params);
 }
 
 void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryivEXT(GLenum target,
                                                            GLenum pname,
                                                            GLint* params) {
   MakeFunctionUnique("glGetQueryivEXT");
   interface_->GetQueryiv(target, pname, params);
 }
 
 void GL_BINDING_CALL
+MockGLInterface::Mock_glGetQueryivRobustANGLE(GLenum target,
+                                              GLenum pname,
+                                              GLsizei bufSize,
+                                              GLsizei* length,
+                                              GLint* params) {
+  MakeFunctionUnique("glGetQueryivRobustANGLE");
+  interface_->GetQueryivRobustANGLE(target, pname, bufSize, length, params);
+}
+
+void GL_BINDING_CALL
 MockGLInterface::Mock_glGetRenderbufferParameteriv(GLenum target,
                                                    GLenum pname,
                                                    GLint* params) {
   MakeFunctionUnique("glGetRenderbufferParameteriv");
   interface_->GetRenderbufferParameterivEXT(target, pname, params);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glGetRenderbufferParameterivEXT(GLenum target,
                                                       GLenum pname,
                                                       GLint* params) {
   MakeFunctionUnique("glGetRenderbufferParameterivEXT");
   interface_->GetRenderbufferParameterivEXT(target, pname, params);
 }
 
 void GL_BINDING_CALL
+MockGLInterface::Mock_glGetRenderbufferParameterivRobustANGLE(GLenum target,
+                                                              GLenum pname,
+                                                              GLsizei bufSize,
+                                                              GLsizei* length,
+                                                              GLint* params) {
+  MakeFunctionUnique("glGetRenderbufferParameterivRobustANGLE");
+  interface_->GetRenderbufferParameterivRobustANGLE(target, pname, bufSize,
+                                                    length, params);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetSamplerParameterIivRobustANGLE(GLuint sampler,
+                                                          GLenum pname,
+                                                          GLsizei bufSize,
+                                                          GLsizei* length,
+                                                          GLint* params) {
+  MakeFunctionUnique("glGetSamplerParameterIivRobustANGLE");
+  interface_->GetSamplerParameterIivRobustANGLE(sampler, pname, bufSize, length,
+                                                params);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetSamplerParameterIuivRobustANGLE(GLuint sampler,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           GLsizei* length,
+                                                           GLuint* params) {
+  MakeFunctionUnique("glGetSamplerParameterIuivRobustANGLE");
+  interface_->GetSamplerParameterIuivRobustANGLE(sampler, pname, bufSize,
+                                                 length, params);
+}
+
+void GL_BINDING_CALL
 MockGLInterface::Mock_glGetSamplerParameterfv(GLuint sampler,
                                               GLenum pname,
                                               GLfloat* params) {
   MakeFunctionUnique("glGetSamplerParameterfv");
   interface_->GetSamplerParameterfv(sampler, pname, params);
 }
 
 void GL_BINDING_CALL
+MockGLInterface::Mock_glGetSamplerParameterfvRobustANGLE(GLuint sampler,
+                                                         GLenum pname,
+                                                         GLsizei bufSize,
+                                                         GLsizei* length,
+                                                         GLfloat* params) {
+  MakeFunctionUnique("glGetSamplerParameterfvRobustANGLE");
+  interface_->GetSamplerParameterfvRobustANGLE(sampler, pname, bufSize, length,
+                                               params);
+}
+
+void GL_BINDING_CALL
 MockGLInterface::Mock_glGetSamplerParameteriv(GLuint sampler,
                                               GLenum pname,
                                               GLint* params) {
   MakeFunctionUnique("glGetSamplerParameteriv");
   interface_->GetSamplerParameteriv(sampler, pname, params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetSamplerParameterivRobustANGLE(GLuint sampler,
+                                                         GLenum pname,
+                                                         GLsizei bufSize,
+                                                         GLsizei* length,
+                                                         GLint* params) {
+  MakeFunctionUnique("glGetSamplerParameterivRobustANGLE");
+  interface_->GetSamplerParameterivRobustANGLE(sampler, pname, bufSize, length,
+                                               params);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glGetShaderInfoLog(GLuint shader,
                                                               GLsizei bufsize,
                                                               GLsizei* length,
                                                               char* infolog) {
   MakeFunctionUnique("glGetShaderInfoLog");
   interface_->GetShaderInfoLog(shader, bufsize, length, infolog);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glGetShaderPrecisionFormat(GLenum shadertype,
@@ skipping 13 matching lines @@
   interface_->GetShaderSource(shader, bufsize, length, source);
 }
 
 void GL_BINDING_CALL MockGLInterface::Mock_glGetShaderiv(GLuint shader,
                                                          GLenum pname,
                                                          GLint* params) {
   MakeFunctionUnique("glGetShaderiv");
   interface_->GetShaderiv(shader, pname, params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetShaderivRobustANGLE(GLuint shader,
+                                               GLenum pname,
+                                               GLsizei bufSize,
+                                               GLsizei* length,
+                                               GLint* params) {
+  MakeFunctionUnique("glGetShaderivRobustANGLE");
+  interface_->GetShaderivRobustANGLE(shader, pname, bufSize, length, params);
+}
+
 const GLubyte* GL_BINDING_CALL MockGLInterface::Mock_glGetString(GLenum name) {
   MakeFunctionUnique("glGetString");
   return interface_->GetString(name);
 }
 
 const GLubyte* GL_BINDING_CALL
 MockGLInterface::Mock_glGetStringi(GLenum name, GLuint index) {
   MakeFunctionUnique("glGetStringi");
   return interface_->GetStringi(name, index);
 }
@@ skipping 10 matching lines @@
 void GL_BINDING_CALL
 MockGLInterface::Mock_glGetTexLevelParameterfv(GLenum target,
                                                GLint level,
                                                GLenum pname,
                                                GLfloat* params) {
   MakeFunctionUnique("glGetTexLevelParameterfv");
   interface_->GetTexLevelParameterfv(target, level, pname, params);
 }
 
 void GL_BINDING_CALL
+MockGLInterface::Mock_glGetTexLevelParameterfvRobustANGLE(GLenum target,
+                                                          GLint level,
+                                                          GLenum pname,
+                                                          GLsizei bufSize,
+                                                          GLsizei* length,
+                                                          GLfloat* params) {
+  MakeFunctionUnique("glGetTexLevelParameterfvRobustANGLE");
+  interface_->GetTexLevelParameterfvRobustANGLE(target, level, pname, bufSize,
+                                                length, params);
+}
+
+void GL_BINDING_CALL
 MockGLInterface::Mock_glGetTexLevelParameteriv(GLenum target,
                                                GLint level,
                                                GLenum pname,
                                                GLint* params) {
   MakeFunctionUnique("glGetTexLevelParameteriv");
   interface_->GetTexLevelParameteriv(target, level, pname, params);
 }
 
 void GL_BINDING_CALL
+MockGLInterface::Mock_glGetTexLevelParameterivRobustANGLE(GLenum target,
+                                                          GLint level,
+                                                          GLenum pname,
+                                                          GLsizei bufSize,
+                                                          GLsizei* length,
+                                                          GLint* params) {
+  MakeFunctionUnique("glGetTexLevelParameterivRobustANGLE");
+  interface_->GetTexLevelParameterivRobustANGLE(target, level, pname, bufSize,
+                                                length, params);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetTexParameterIivRobustANGLE(GLenum target,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei* length,
+                                                      GLint* params) {
+  MakeFunctionUnique("glGetTexParameterIivRobustANGLE");
+  interface_->GetTexParameterIivRobustANGLE(target, pname, bufSize, length,
+                                            params);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetTexParameterIuivRobustANGLE(GLenum target,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei* length,
+                                                       GLuint* params) {
+  MakeFunctionUnique("glGetTexParameterIuivRobustANGLE");
+  interface_->GetTexParameterIuivRobustANGLE(target, pname, bufSize, length,
+                                             params);
+}
+
+void GL_BINDING_CALL
 MockGLInterface::Mock_glGetTexParameterfv(GLenum target,
                                           GLenum pname,
                                           GLfloat* params) {
   MakeFunctionUnique("glGetTexParameterfv");
   interface_->GetTexParameterfv(target, pname, params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetTexParameterfvRobustANGLE(GLenum target,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei* length,
+                                                     GLfloat* params) {
+  MakeFunctionUnique("glGetTexParameterfvRobustANGLE");
+  interface_->GetTexParameterfvRobustANGLE(target, pname, bufSize, length,
+                                           params);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glGetTexParameteriv(GLenum target,
                                                                GLenum pname,
                                                                GLint* params) {
   MakeFunctionUnique("glGetTexParameteriv");
   interface_->GetTexParameteriv(target, pname, params);
 }
 
 void GL_BINDING_CALL
+MockGLInterface::Mock_glGetTexParameterivRobustANGLE(GLenum target,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei* length,
+                                                     GLint* params) {
+  MakeFunctionUnique("glGetTexParameterivRobustANGLE");
+  interface_->GetTexParameterivRobustANGLE(target, pname, bufSize, length,
+                                           params);
+}
+
+void GL_BINDING_CALL
 MockGLInterface::Mock_glGetTransformFeedbackVarying(GLuint program,
                                                     GLuint index,
                                                     GLsizei bufSize,
                                                     GLsizei* length,
                                                     GLsizei* size,
                                                     GLenum* type,
                                                     char* name) {
   MakeFunctionUnique("glGetTransformFeedbackVarying");
   interface_->GetTransformFeedbackVarying(program, index, bufSize, length, size,
                                           type, name);
@@ skipping 44 matching lines @@
   return interface_->GetUniformLocation(program, name);
 }
 
 void GL_BINDING_CALL MockGLInterface::Mock_glGetUniformfv(GLuint program,
                                                           GLint location,
                                                           GLfloat* params) {
   MakeFunctionUnique("glGetUniformfv");
   interface_->GetUniformfv(program, location, params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetUniformfvRobustANGLE(GLuint program,
+                                                GLint location,
+                                                GLsizei bufSize,
+                                                GLsizei* length,
+                                                GLfloat* params) {
+  MakeFunctionUnique("glGetUniformfvRobustANGLE");
+  interface_->GetUniformfvRobustANGLE(program, location, bufSize, length,
+                                      params);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glGetUniformiv(GLuint program,
                                                           GLint location,
                                                           GLint* params) {
   MakeFunctionUnique("glGetUniformiv");
   interface_->GetUniformiv(program, location, params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetUniformivRobustANGLE(GLuint program,
+                                                GLint location,
+                                                GLsizei bufSize,
+                                                GLsizei* length,
+                                                GLint* params) {
+  MakeFunctionUnique("glGetUniformivRobustANGLE");
+  interface_->GetUniformivRobustANGLE(program, location, bufSize, length,
+                                      params);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glGetUniformuiv(GLuint program,
                                                            GLint location,
                                                            GLuint* params) {
   MakeFunctionUnique("glGetUniformuiv");
   interface_->GetUniformuiv(program, location, params);
 }
 
 void GL_BINDING_CALL
+MockGLInterface::Mock_glGetUniformuivRobustANGLE(GLuint program,
+                                                 GLint location,
+                                                 GLsizei bufSize,
+                                                 GLsizei* length,
+                                                 GLuint* params) {
+  MakeFunctionUnique("glGetUniformuivRobustANGLE");
+  interface_->GetUniformuivRobustANGLE(program, location, bufSize, length,
+                                       params);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetVertexAttribIivRobustANGLE(GLuint index,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei* length,
+                                                      GLint* params) {
+  MakeFunctionUnique("glGetVertexAttribIivRobustANGLE");
+  interface_->GetVertexAttribIivRobustANGLE(index, pname, bufSize, length,
+                                            params);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetVertexAttribIuivRobustANGLE(GLuint index,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei* length,
+                                                       GLuint* params) {
+  MakeFunctionUnique("glGetVertexAttribIuivRobustANGLE");
+  interface_->GetVertexAttribIuivRobustANGLE(index, pname, bufSize, length,
+                                             params);
+}
+
+void GL_BINDING_CALL
 MockGLInterface::Mock_glGetVertexAttribPointerv(GLuint index,
                                                 GLenum pname,
                                                 void** pointer) {
   MakeFunctionUnique("glGetVertexAttribPointerv");
   interface_->GetVertexAttribPointerv(index, pname, pointer);
 }
 
 void GL_BINDING_CALL
+MockGLInterface::Mock_glGetVertexAttribPointervRobustANGLE(GLuint index,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           GLsizei* length,
+                                                           void** pointer) {
+  MakeFunctionUnique("glGetVertexAttribPointervRobustANGLE");
+  interface_->GetVertexAttribPointervRobustANGLE(index, pname, bufSize, length,
+                                                 pointer);
+}
+
+void GL_BINDING_CALL
 MockGLInterface::Mock_glGetVertexAttribfv(GLuint index,
                                           GLenum pname,
                                           GLfloat* params) {
   MakeFunctionUnique("glGetVertexAttribfv");
   interface_->GetVertexAttribfv(index, pname, params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetVertexAttribfvRobustANGLE(GLuint index,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei* length,
+                                                     GLfloat* params) {
+  MakeFunctionUnique("glGetVertexAttribfvRobustANGLE");
+  interface_->GetVertexAttribfvRobustANGLE(index, pname, bufSize, length,
+                                           params);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glGetVertexAttribiv(GLuint index,
                                                                GLenum pname,
                                                                GLint* params) {
   MakeFunctionUnique("glGetVertexAttribiv");
   interface_->GetVertexAttribiv(index, pname, params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetVertexAttribivRobustANGLE(GLuint index,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei* length,
+                                                     GLint* params) {
+  MakeFunctionUnique("glGetVertexAttribivRobustANGLE");
+  interface_->GetVertexAttribivRobustANGLE(index, pname, bufSize, length,
+                                           params);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetnUniformfvRobustANGLE(GLuint program,
+                                                 GLint location,
+                                                 GLsizei bufSize,
+                                                 GLsizei* length,
+                                                 GLfloat* params) {
+  MakeFunctionUnique("glGetnUniformfvRobustANGLE");
+  interface_->GetnUniformfvRobustANGLE(program, location, bufSize, length,
+                                       params);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetnUniformivRobustANGLE(GLuint program,
+                                                 GLint location,
+                                                 GLsizei bufSize,
+                                                 GLsizei* length,
+                                                 GLint* params) {
+  MakeFunctionUnique("glGetnUniformivRobustANGLE");
+  interface_->GetnUniformivRobustANGLE(program, location, bufSize, length,
+                                       params);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glGetnUniformuivRobustANGLE(GLuint program,
+                                                  GLint location,
+                                                  GLsizei bufSize,
+                                                  GLsizei* length,
+                                                  GLuint* params) {
+  MakeFunctionUnique("glGetnUniformuivRobustANGLE");
+  interface_->GetnUniformuivRobustANGLE(program, location, bufSize, length,
+                                        params);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glHint(GLenum target, GLenum mode) {
   MakeFunctionUnique("glHint");
   interface_->Hint(target, mode);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glInsertEventMarkerEXT(GLsizei length,
                                              const char* marker) {
   MakeFunctionUnique("glInsertEventMarkerEXT");
   interface_->InsertEventMarkerEXT(length, marker);
@@ skipping 325 matching lines @@
                                                         GLint y,
                                                         GLsizei width,
                                                         GLsizei height,
                                                         GLenum format,
                                                         GLenum type,
                                                         void* pixels) {
   MakeFunctionUnique("glReadPixels");
   interface_->ReadPixels(x, y, width, height, format, type, pixels);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glReadPixelsRobustANGLE(GLint x,
+                                              GLint y,
+                                              GLsizei width,
+                                              GLsizei height,
+                                              GLenum format,
+                                              GLenum type,
+                                              GLsizei bufSize,
+                                              GLsizei* length,
+                                              void* pixels) {
+  MakeFunctionUnique("glReadPixelsRobustANGLE");
+  interface_->ReadPixelsRobustANGLE(x, y, width, height, format, type, bufSize,
+                                    length, pixels);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glReadnPixelsRobustANGLE(GLint x,
+                                               GLint y,
+                                               GLsizei width,
+                                               GLsizei height,
+                                               GLenum format,
+                                               GLenum type,
+                                               GLsizei bufSize,
+                                               GLsizei* length,
+                                               void* data) {
+  MakeFunctionUnique("glReadnPixelsRobustANGLE");
+  interface_->ReadnPixelsRobustANGLE(x, y, width, height, format, type, bufSize,
+                                     length, data);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glReleaseShaderCompiler(void) {
   MakeFunctionUnique("glReleaseShaderCompiler");
   interface_->ReleaseShaderCompiler();
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glRenderbufferStorage(GLenum target,
                                             GLenum internalformat,
                                             GLsizei width,
                                             GLsizei height) {
@@ skipping 59 matching lines @@
   MakeFunctionUnique("glResumeTransformFeedback");
   interface_->ResumeTransformFeedback();
 }
 
 void GL_BINDING_CALL MockGLInterface::Mock_glSampleCoverage(GLclampf value,
                                                             GLboolean invert) {
   MakeFunctionUnique("glSampleCoverage");
   interface_->SampleCoverage(value, invert);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glSamplerParameterIivRobustANGLE(GLuint sampler,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       const GLint* param) {
+  MakeFunctionUnique("glSamplerParameterIivRobustANGLE");
+  interface_->SamplerParameterIivRobustANGLE(sampler, pname, bufSize, param);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glSamplerParameterIuivRobustANGLE(GLuint sampler,
+                                                        GLenum pname,
+                                                        GLsizei bufSize,
+                                                        const GLuint* param) {
+  MakeFunctionUnique("glSamplerParameterIuivRobustANGLE");
+  interface_->SamplerParameterIuivRobustANGLE(sampler, pname, bufSize, param);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glSamplerParameterf(GLuint sampler,
                                                                GLenum pname,
                                                                GLfloat param) {
   MakeFunctionUnique("glSamplerParameterf");
   interface_->SamplerParameterf(sampler, pname, param);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glSamplerParameterfv(GLuint sampler,
                                            GLenum pname,
                                            const GLfloat* params) {
   MakeFunctionUnique("glSamplerParameterfv");
   interface_->SamplerParameterfv(sampler, pname, params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glSamplerParameterfvRobustANGLE(GLuint sampler,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      const GLfloat* param) {
+  MakeFunctionUnique("glSamplerParameterfvRobustANGLE");
+  interface_->SamplerParameterfvRobustANGLE(sampler, pname, bufSize, param);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glSamplerParameteri(GLuint sampler,
                                                                GLenum pname,
                                                                GLint param) {
   MakeFunctionUnique("glSamplerParameteri");
   interface_->SamplerParameteri(sampler, pname, param);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glSamplerParameteriv(GLuint sampler,
                                            GLenum pname,
                                            const GLint* params) {
   MakeFunctionUnique("glSamplerParameteriv");
   interface_->SamplerParameteriv(sampler, pname, params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glSamplerParameterivRobustANGLE(GLuint sampler,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      const GLint* param) {
+  MakeFunctionUnique("glSamplerParameterivRobustANGLE");
+  interface_->SamplerParameterivRobustANGLE(sampler, pname, bufSize, param);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glScissor(GLint x,
                                                      GLint y,
                                                      GLsizei width,
                                                      GLsizei height) {
   MakeFunctionUnique("glScissor");
   interface_->Scissor(x, y, width, height);
 }
 
 void GL_BINDING_CALL MockGLInterface::Mock_glSetFenceAPPLE(GLuint fence) {
   MakeFunctionUnique("glSetFenceAPPLE");
@@ skipping 179 matching lines @@
                                                         GLsizei height,
                                                         GLint border,
                                                         GLenum format,
                                                         GLenum type,
                                                         const void* pixels) {
   MakeFunctionUnique("glTexImage2D");
   interface_->TexImage2D(target, level, internalformat, width, height, border,
                          format, type, pixels);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glTexImage2DRobustANGLE(GLenum target,
+                                              GLint level,
+                                              GLint internalformat,
+                                              GLsizei width,
+                                              GLsizei height,
+                                              GLint border,
+                                              GLenum format,
+                                              GLenum type,
+                                              GLsizei bufSize,
+                                              const void* pixels) {
+  MakeFunctionUnique("glTexImage2DRobustANGLE");
+  interface_->TexImage2DRobustANGLE(target, level, internalformat, width,
+                                    height, border, format, type, bufSize,
+                                    pixels);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glTexImage3D(GLenum target,
                                                         GLint level,
                                                         GLint internalformat,
                                                         GLsizei width,
                                                         GLsizei height,
                                                         GLsizei depth,
                                                         GLint border,
                                                         GLenum format,
                                                         GLenum type,
                                                         const void* pixels) {
   MakeFunctionUnique("glTexImage3D");
   interface_->TexImage3D(target, level, internalformat, width, height, depth,
                          border, format, type, pixels);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glTexImage3DRobustANGLE(GLenum target,
+                                              GLint level,
+                                              GLint internalformat,
+                                              GLsizei width,
+                                              GLsizei height,
+                                              GLsizei depth,
+                                              GLint border,
+                                              GLenum format,
+                                              GLenum type,
+                                              GLsizei bufSize,
+                                              const void* pixels) {
+  MakeFunctionUnique("glTexImage3DRobustANGLE");
+  interface_->TexImage3DRobustANGLE(target, level, internalformat, width,
+                                    height, depth, border, format, type,
+                                    bufSize, pixels);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glTexParameterIivRobustANGLE(GLenum target,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   const GLint* params) {
+  MakeFunctionUnique("glTexParameterIivRobustANGLE");
+  interface_->TexParameterIivRobustANGLE(target, pname, bufSize, params);
+}
+
+void GL_BINDING_CALL
+MockGLInterface::Mock_glTexParameterIuivRobustANGLE(GLenum target,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    const GLuint* params) {
+  MakeFunctionUnique("glTexParameterIuivRobustANGLE");
+  interface_->TexParameterIuivRobustANGLE(target, pname, bufSize, params);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glTexParameterf(GLenum target,
                                                            GLenum pname,
                                                            GLfloat param) {
   MakeFunctionUnique("glTexParameterf");
   interface_->TexParameterf(target, pname, param);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glTexParameterfv(GLenum target,
                                        GLenum pname,
                                        const GLfloat* params) {
   MakeFunctionUnique("glTexParameterfv");
   interface_->TexParameterfv(target, pname, params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glTexParameterfvRobustANGLE(GLenum target,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  const GLfloat* params) {
+  MakeFunctionUnique("glTexParameterfvRobustANGLE");
+  interface_->TexParameterfvRobustANGLE(target, pname, bufSize, params);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glTexParameteri(GLenum target,
                                                            GLenum pname,
                                                            GLint param) {
   MakeFunctionUnique("glTexParameteri");
   interface_->TexParameteri(target, pname, param);
 }
 
 void GL_BINDING_CALL
 MockGLInterface::Mock_glTexParameteriv(GLenum target,
                                        GLenum pname,
                                        const GLint* params) {
   MakeFunctionUnique("glTexParameteriv");
   interface_->TexParameteriv(target, pname, params);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glTexParameterivRobustANGLE(GLenum target,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  const GLint* params) {
+  MakeFunctionUnique("glTexParameterivRobustANGLE");
+  interface_->TexParameterivRobustANGLE(target, pname, bufSize, params);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glTexStorage2D(GLenum target,
                                                           GLsizei levels,
                                                           GLenum internalformat,
                                                           GLsizei width,
                                                           GLsizei height) {
   MakeFunctionUnique("glTexStorage2D");
   interface_->TexStorage2DEXT(target, levels, internalformat, width, height);
 }
 
 void GL_BINDING_CALL
@@ skipping 24 matching lines @@
                                                            GLsizei width,
                                                            GLsizei height,
                                                            GLenum format,
                                                            GLenum type,
                                                            const void* pixels) {
   MakeFunctionUnique("glTexSubImage2D");
   interface_->TexSubImage2D(target, level, xoffset, yoffset, width, height,
                             format, type, pixels);
 }
 
+void GL_BINDING_CALL
+MockGLInterface::Mock_glTexSubImage2DRobustANGLE(GLenum target,
+                                                 GLint level,
+                                                 GLint xoffset,
+                                                 GLint yoffset,
+                                                 GLsizei width,
+                                                 GLsizei height,
+                                                 GLenum format,
+                                                 GLenum type,
+                                                 GLsizei bufSize,
+                                                 const void* pixels) {
+  MakeFunctionUnique("glTexSubImage2DRobustANGLE");
+  interface_->TexSubImage2DRobustANGLE(target, level, xoffset, yoffset, width,
+                                       height, format, type, bufSize, pixels);
+}
+
 void GL_BINDING_CALL MockGLInterface::Mock_glTexSubImage3D(GLenum target,
                                                            GLint level,
                                                            GLint xoffset,
                                                            GLint yoffset,
                                                            GLint zoffset,
                                                            GLsizei width,
                                                            GLsizei height,
                                                            GLsizei depth,
                                                            GLenum format,
                                                            GLenum type,
                                                            const void* pixels) {
   MakeFunctionUnique("glTexSubImage3D");
   interface_->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
                             height, depth, format, type, pixels);
 }
 
 void GL_BINDING_CALL
+MockGLInterface::Mock_glTexSubImage3DRobustANGLE(GLenum target,
+                                                 GLint level,
+                                                 GLint xoffset,
+                                                 GLint yoffset,
+                                                 GLint zoffset,
+                                                 GLsizei width,
+                                                 GLsizei height,
+                                                 GLsizei depth,
+                                                 GLenum format,
+                                                 GLenum type,
+                                                 GLsizei bufSize,
+                                                 const void* pixels) {
+  MakeFunctionUnique("glTexSubImage3DRobustANGLE");
+  interface_->TexSubImage3DRobustANGLE(target, level, xoffset, yoffset, zoffset,
+                                       width, height, depth, format, type,
+                                       bufSize, pixels);
+}
+
+void GL_BINDING_CALL
 MockGLInterface::Mock_glTransformFeedbackVaryings(GLuint program,
                                                   GLsizei count,
                                                   const char* const* varyings,
                                                   GLenum bufferMode) {
   MakeFunctionUnique("glTransformFeedbackVaryings");
   interface_->TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 void GL_BINDING_CALL MockGLInterface::Mock_glTransformFeedbackVaryingsEXT(
     GLuint program,
@@ skipping 751 matching lines @@
   if (strcmp(name, "glGenerateMipmapEXT") == 0)
     return reinterpret_cast<void*>(Mock_glGenerateMipmapEXT);
   if (strcmp(name, "glGetActiveAttrib") == 0)
     return reinterpret_cast<void*>(Mock_glGetActiveAttrib);
   if (strcmp(name, "glGetActiveUniform") == 0)
     return reinterpret_cast<void*>(Mock_glGetActiveUniform);
   if (strcmp(name, "glGetActiveUniformBlockName") == 0)
     return reinterpret_cast<void*>(Mock_glGetActiveUniformBlockName);
   if (strcmp(name, "glGetActiveUniformBlockiv") == 0)
     return reinterpret_cast<void*>(Mock_glGetActiveUniformBlockiv);
+  if (strcmp(name, "glGetActiveUniformBlockivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetActiveUniformBlockivRobustANGLE);
   if (strcmp(name, "glGetActiveUniformsiv") == 0)
     return reinterpret_cast<void*>(Mock_glGetActiveUniformsiv);
   if (strcmp(name, "glGetAttachedShaders") == 0)
     return reinterpret_cast<void*>(Mock_glGetAttachedShaders);
   if (strcmp(name, "glGetAttribLocation") == 0)
     return reinterpret_cast<void*>(Mock_glGetAttribLocation);
+  if (strcmp(name, "glGetBooleani_vRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetBooleani_vRobustANGLE);
   if (strcmp(name, "glGetBooleanv") == 0)
     return reinterpret_cast<void*>(Mock_glGetBooleanv);
+  if (strcmp(name, "glGetBooleanvRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetBooleanvRobustANGLE);
+  if (strcmp(name, "glGetBufferParameteri64vRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetBufferParameteri64vRobustANGLE);
   if (strcmp(name, "glGetBufferParameteriv") == 0)
     return reinterpret_cast<void*>(Mock_glGetBufferParameteriv);
+  if (strcmp(name, "glGetBufferParameterivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetBufferParameterivRobustANGLE);
+  if (strcmp(name, "glGetBufferPointervRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetBufferPointervRobustANGLE);
   if (strcmp(name, "glGetError") == 0)
     return reinterpret_cast<void*>(Mock_glGetError);
   if (strcmp(name, "glGetFenceivNV") == 0)
     return reinterpret_cast<void*>(Mock_glGetFenceivNV);
   if (strcmp(name, "glGetFloatv") == 0)
     return reinterpret_cast<void*>(Mock_glGetFloatv);
+  if (strcmp(name, "glGetFloatvRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetFloatvRobustANGLE);
   if (strcmp(name, "glGetFragDataIndex") == 0)
     return reinterpret_cast<void*>(Mock_glGetFragDataIndex);
   if (strcmp(name, "glGetFragDataIndexEXT") == 0)
     return reinterpret_cast<void*>(Mock_glGetFragDataIndexEXT);
   if (strcmp(name, "glGetFragDataLocation") == 0)
     return reinterpret_cast<void*>(Mock_glGetFragDataLocation);
   if (strcmp(name, "glGetFramebufferAttachmentParameteriv") == 0)
     return reinterpret_cast<void*>(Mock_glGetFramebufferAttachmentParameteriv);
   if (strcmp(name, "glGetFramebufferAttachmentParameterivEXT") == 0)
     return reinterpret_cast<void*>(
         Mock_glGetFramebufferAttachmentParameterivEXT);
+  if (strcmp(name, "glGetFramebufferAttachmentParameterivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(
+        Mock_glGetFramebufferAttachmentParameterivRobustANGLE);
+  if (strcmp(name, "glGetFramebufferParameterivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetFramebufferParameterivRobustANGLE);
   if (strcmp(name, "glGetGraphicsResetStatus") == 0)
     return reinterpret_cast<void*>(Mock_glGetGraphicsResetStatus);
   if (strcmp(name, "glGetGraphicsResetStatusARB") == 0)
     return reinterpret_cast<void*>(Mock_glGetGraphicsResetStatusARB);
   if (strcmp(name, "glGetGraphicsResetStatusEXT") == 0)
     return reinterpret_cast<void*>(Mock_glGetGraphicsResetStatusEXT);
   if (strcmp(name, "glGetGraphicsResetStatusKHR") == 0)
     return reinterpret_cast<void*>(Mock_glGetGraphicsResetStatusKHR);
   if (strcmp(name, "glGetInteger64i_v") == 0)
     return reinterpret_cast<void*>(Mock_glGetInteger64i_v);
+  if (strcmp(name, "glGetInteger64i_vRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetInteger64i_vRobustANGLE);
   if (strcmp(name, "glGetInteger64v") == 0)
     return reinterpret_cast<void*>(Mock_glGetInteger64v);
+  if (strcmp(name, "glGetInteger64vRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetInteger64vRobustANGLE);
   if (strcmp(name, "glGetIntegeri_v") == 0)
     return reinterpret_cast<void*>(Mock_glGetIntegeri_v);
+  if (strcmp(name, "glGetIntegeri_vRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetIntegeri_vRobustANGLE);
   if (strcmp(name, "glGetIntegerv") == 0)
     return reinterpret_cast<void*>(Mock_glGetIntegerv);
+  if (strcmp(name, "glGetIntegervRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetIntegervRobustANGLE);
   if (strcmp(name, "glGetInternalformativ") == 0)
     return reinterpret_cast<void*>(Mock_glGetInternalformativ);
+  if (strcmp(name, "glGetMultisamplefvRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetMultisamplefvRobustANGLE);
+  if (strcmp(name, "glGetPointervRobustANGLERobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetPointervRobustANGLERobustANGLE);
   if (strcmp(name, "glGetProgramBinary") == 0)
     return reinterpret_cast<void*>(Mock_glGetProgramBinary);
   if (strcmp(name, "glGetProgramBinaryOES") == 0)
     return reinterpret_cast<void*>(Mock_glGetProgramBinaryOES);
   if (strcmp(name, "glGetProgramInfoLog") == 0)
     return reinterpret_cast<void*>(Mock_glGetProgramInfoLog);
   if (strcmp(name, "glGetProgramInterfaceiv") == 0)
     return reinterpret_cast<void*>(Mock_glGetProgramInterfaceiv);
+  if (strcmp(name, "glGetProgramInterfaceivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetProgramInterfaceivRobustANGLE);
   if (strcmp(name, "glGetProgramResourceLocation") == 0)
     return reinterpret_cast<void*>(Mock_glGetProgramResourceLocation);
   if (strcmp(name, "glGetProgramResourceName") == 0)
     return reinterpret_cast<void*>(Mock_glGetProgramResourceName);
   if (strcmp(name, "glGetProgramResourceiv") == 0)
     return reinterpret_cast<void*>(Mock_glGetProgramResourceiv);
   if (strcmp(name, "glGetProgramiv") == 0)
     return reinterpret_cast<void*>(Mock_glGetProgramiv);
+  if (strcmp(name, "glGetProgramivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetProgramivRobustANGLE);
   if (strcmp(name, "glGetQueryObjecti64v") == 0)
     return reinterpret_cast<void*>(Mock_glGetQueryObjecti64v);
   if (strcmp(name, "glGetQueryObjecti64vEXT") == 0)
     return reinterpret_cast<void*>(Mock_glGetQueryObjecti64vEXT);
+  if (strcmp(name, "glGetQueryObjecti64vRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetQueryObjecti64vRobustANGLE);
   if (strcmp(name, "glGetQueryObjectiv") == 0)
     return reinterpret_cast<void*>(Mock_glGetQueryObjectiv);
   if (strcmp(name, "glGetQueryObjectivARB") == 0)
     return reinterpret_cast<void*>(Mock_glGetQueryObjectivARB);
   if (strcmp(name, "glGetQueryObjectivEXT") == 0)
     return reinterpret_cast<void*>(Mock_glGetQueryObjectivEXT);
+  if (strcmp(name, "glGetQueryObjectivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetQueryObjectivRobustANGLE);
   if (strcmp(name, "glGetQueryObjectui64v") == 0)
     return reinterpret_cast<void*>(Mock_glGetQueryObjectui64v);
   if (strcmp(name, "glGetQueryObjectui64vEXT") == 0)
     return reinterpret_cast<void*>(Mock_glGetQueryObjectui64vEXT);
+  if (strcmp(name, "glGetQueryObjectui64vRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetQueryObjectui64vRobustANGLE);
   if (strcmp(name, "glGetQueryObjectuiv") == 0)
     return reinterpret_cast<void*>(Mock_glGetQueryObjectuiv);
   if (strcmp(name, "glGetQueryObjectuivARB") == 0)
     return reinterpret_cast<void*>(Mock_glGetQueryObjectuivARB);
   if (strcmp(name, "glGetQueryObjectuivEXT") == 0)
     return reinterpret_cast<void*>(Mock_glGetQueryObjectuivEXT);
+  if (strcmp(name, "glGetQueryObjectuivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetQueryObjectuivRobustANGLE);
   if (strcmp(name, "glGetQueryiv") == 0)
     return reinterpret_cast<void*>(Mock_glGetQueryiv);
   if (strcmp(name, "glGetQueryivARB") == 0)
     return reinterpret_cast<void*>(Mock_glGetQueryivARB);
   if (strcmp(name, "glGetQueryivEXT") == 0)
     return reinterpret_cast<void*>(Mock_glGetQueryivEXT);
+  if (strcmp(name, "glGetQueryivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetQueryivRobustANGLE);
   if (strcmp(name, "glGetRenderbufferParameteriv") == 0)
     return reinterpret_cast<void*>(Mock_glGetRenderbufferParameteriv);
   if (strcmp(name, "glGetRenderbufferParameterivEXT") == 0)
     return reinterpret_cast<void*>(Mock_glGetRenderbufferParameterivEXT);
+  if (strcmp(name, "glGetRenderbufferParameterivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(
+        Mock_glGetRenderbufferParameterivRobustANGLE);
+  if (strcmp(name, "glGetSamplerParameterIivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetSamplerParameterIivRobustANGLE);
+  if (strcmp(name, "glGetSamplerParameterIuivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetSamplerParameterIuivRobustANGLE);
   if (strcmp(name, "glGetSamplerParameterfv") == 0)
     return reinterpret_cast<void*>(Mock_glGetSamplerParameterfv);
+  if (strcmp(name, "glGetSamplerParameterfvRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetSamplerParameterfvRobustANGLE);
   if (strcmp(name, "glGetSamplerParameteriv") == 0)
     return reinterpret_cast<void*>(Mock_glGetSamplerParameteriv);
+  if (strcmp(name, "glGetSamplerParameterivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetSamplerParameterivRobustANGLE);
   if (strcmp(name, "glGetShaderInfoLog") == 0)
     return reinterpret_cast<void*>(Mock_glGetShaderInfoLog);
   if (strcmp(name, "glGetShaderPrecisionFormat") == 0)
     return reinterpret_cast<void*>(Mock_glGetShaderPrecisionFormat);
   if (strcmp(name, "glGetShaderSource") == 0)
     return reinterpret_cast<void*>(Mock_glGetShaderSource);
   if (strcmp(name, "glGetShaderiv") == 0)
     return reinterpret_cast<void*>(Mock_glGetShaderiv);
+  if (strcmp(name, "glGetShaderivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetShaderivRobustANGLE);
   if (strcmp(name, "glGetString") == 0)
     return reinterpret_cast<void*>(Mock_glGetString);
   if (strcmp(name, "glGetStringi") == 0)
     return reinterpret_cast<void*>(Mock_glGetStringi);
   if (strcmp(name, "glGetSynciv") == 0)
     return reinterpret_cast<void*>(Mock_glGetSynciv);
   if (strcmp(name, "glGetTexLevelParameterfv") == 0)
     return reinterpret_cast<void*>(Mock_glGetTexLevelParameterfv);
+  if (strcmp(name, "glGetTexLevelParameterfvRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetTexLevelParameterfvRobustANGLE);
   if (strcmp(name, "glGetTexLevelParameteriv") == 0)
     return reinterpret_cast<void*>(Mock_glGetTexLevelParameteriv);
+  if (strcmp(name, "glGetTexLevelParameterivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetTexLevelParameterivRobustANGLE);
+  if (strcmp(name, "glGetTexParameterIivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetTexParameterIivRobustANGLE);
+  if (strcmp(name, "glGetTexParameterIuivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetTexParameterIuivRobustANGLE);
   if (strcmp(name, "glGetTexParameterfv") == 0)
     return reinterpret_cast<void*>(Mock_glGetTexParameterfv);
+  if (strcmp(name, "glGetTexParameterfvRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetTexParameterfvRobustANGLE);
   if (strcmp(name, "glGetTexParameteriv") == 0)
     return reinterpret_cast<void*>(Mock_glGetTexParameteriv);
+  if (strcmp(name, "glGetTexParameterivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetTexParameterivRobustANGLE);
   if (strcmp(name, "glGetTransformFeedbackVarying") == 0)
     return reinterpret_cast<void*>(Mock_glGetTransformFeedbackVarying);
   if (strcmp(name, "glGetTransformFeedbackVaryingEXT") == 0)
     return reinterpret_cast<void*>(Mock_glGetTransformFeedbackVaryingEXT);
   if (strcmp(name, "glGetTranslatedShaderSourceANGLE") == 0)
     return reinterpret_cast<void*>(Mock_glGetTranslatedShaderSourceANGLE);
   if (strcmp(name, "glGetUniformBlockIndex") == 0)
     return reinterpret_cast<void*>(Mock_glGetUniformBlockIndex);
   if (strcmp(name, "glGetUniformIndices") == 0)
     return reinterpret_cast<void*>(Mock_glGetUniformIndices);
   if (strcmp(name, "glGetUniformLocation") == 0)
     return reinterpret_cast<void*>(Mock_glGetUniformLocation);
   if (strcmp(name, "glGetUniformfv") == 0)
     return reinterpret_cast<void*>(Mock_glGetUniformfv);
+  if (strcmp(name, "glGetUniformfvRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetUniformfvRobustANGLE);
   if (strcmp(name, "glGetUniformiv") == 0)
     return reinterpret_cast<void*>(Mock_glGetUniformiv);
+  if (strcmp(name, "glGetUniformivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetUniformivRobustANGLE);
   if (strcmp(name, "glGetUniformuiv") == 0)
     return reinterpret_cast<void*>(Mock_glGetUniformuiv);
+  if (strcmp(name, "glGetUniformuivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetUniformuivRobustANGLE);
+  if (strcmp(name, "glGetVertexAttribIivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetVertexAttribIivRobustANGLE);
+  if (strcmp(name, "glGetVertexAttribIuivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetVertexAttribIuivRobustANGLE);
   if (strcmp(name, "glGetVertexAttribPointerv") == 0)
     return reinterpret_cast<void*>(Mock_glGetVertexAttribPointerv);
+  if (strcmp(name, "glGetVertexAttribPointervRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetVertexAttribPointervRobustANGLE);
   if (strcmp(name, "glGetVertexAttribfv") == 0)
     return reinterpret_cast<void*>(Mock_glGetVertexAttribfv);
+  if (strcmp(name, "glGetVertexAttribfvRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetVertexAttribfvRobustANGLE);
   if (strcmp(name, "glGetVertexAttribiv") == 0)
     return reinterpret_cast<void*>(Mock_glGetVertexAttribiv);
+  if (strcmp(name, "glGetVertexAttribivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetVertexAttribivRobustANGLE);
+  if (strcmp(name, "glGetnUniformfvRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetnUniformfvRobustANGLE);
+  if (strcmp(name, "glGetnUniformivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetnUniformivRobustANGLE);
+  if (strcmp(name, "glGetnUniformuivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glGetnUniformuivRobustANGLE);
   if (strcmp(name, "glHint") == 0)
     return reinterpret_cast<void*>(Mock_glHint);
   if (strcmp(name, "glInsertEventMarkerEXT") == 0)
     return reinterpret_cast<void*>(Mock_glInsertEventMarkerEXT);
   if (strcmp(name, "glInvalidateFramebuffer") == 0)
     return reinterpret_cast<void*>(Mock_glInvalidateFramebuffer);
   if (strcmp(name, "glInvalidateSubFramebuffer") == 0)
     return reinterpret_cast<void*>(Mock_glInvalidateSubFramebuffer);
   if (strcmp(name, "glIsBuffer") == 0)
     return reinterpret_cast<void*>(Mock_glIsBuffer);
@@ skipping 88 matching lines @@
   if (strcmp(name, "glPushGroupMarkerEXT") == 0)
     return reinterpret_cast<void*>(Mock_glPushGroupMarkerEXT);
   if (strcmp(name, "glQueryCounter") == 0)
     return reinterpret_cast<void*>(Mock_glQueryCounter);
   if (strcmp(name, "glQueryCounterEXT") == 0)
     return reinterpret_cast<void*>(Mock_glQueryCounterEXT);
   if (strcmp(name, "glReadBuffer") == 0)
     return reinterpret_cast<void*>(Mock_glReadBuffer);
   if (strcmp(name, "glReadPixels") == 0)
     return reinterpret_cast<void*>(Mock_glReadPixels);
+  if (strcmp(name, "glReadPixelsRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glReadPixelsRobustANGLE);
+  if (strcmp(name, "glReadnPixelsRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glReadnPixelsRobustANGLE);
   if (strcmp(name, "glReleaseShaderCompiler") == 0)
     return reinterpret_cast<void*>(Mock_glReleaseShaderCompiler);
   if (strcmp(name, "glRenderbufferStorage") == 0)
     return reinterpret_cast<void*>(Mock_glRenderbufferStorage);
   if (strcmp(name, "glRenderbufferStorageEXT") == 0)
     return reinterpret_cast<void*>(Mock_glRenderbufferStorageEXT);
   if (strcmp(name, "glRenderbufferStorageMultisample") == 0)
     return reinterpret_cast<void*>(Mock_glRenderbufferStorageMultisample);
   if (strcmp(name, "glRenderbufferStorageMultisampleANGLE") == 0)
     return reinterpret_cast<void*>(Mock_glRenderbufferStorageMultisampleANGLE);
   if (strcmp(name, "glRenderbufferStorageMultisampleEXT") == 0)
     return reinterpret_cast<void*>(Mock_glRenderbufferStorageMultisampleEXT);
   if (strcmp(name, "glRenderbufferStorageMultisampleIMG") == 0)
     return reinterpret_cast<void*>(Mock_glRenderbufferStorageMultisampleIMG);
   if (strcmp(name, "glResumeTransformFeedback") == 0)
     return reinterpret_cast<void*>(Mock_glResumeTransformFeedback);
   if (strcmp(name, "glSampleCoverage") == 0)
     return reinterpret_cast<void*>(Mock_glSampleCoverage);
+  if (strcmp(name, "glSamplerParameterIivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glSamplerParameterIivRobustANGLE);
+  if (strcmp(name, "glSamplerParameterIuivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glSamplerParameterIuivRobustANGLE);
   if (strcmp(name, "glSamplerParameterf") == 0)
     return reinterpret_cast<void*>(Mock_glSamplerParameterf);
   if (strcmp(name, "glSamplerParameterfv") == 0)
     return reinterpret_cast<void*>(Mock_glSamplerParameterfv);
+  if (strcmp(name, "glSamplerParameterfvRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glSamplerParameterfvRobustANGLE);
   if (strcmp(name, "glSamplerParameteri") == 0)
     return reinterpret_cast<void*>(Mock_glSamplerParameteri);
   if (strcmp(name, "glSamplerParameteriv") == 0)
     return reinterpret_cast<void*>(Mock_glSamplerParameteriv);
+  if (strcmp(name, "glSamplerParameterivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glSamplerParameterivRobustANGLE);
   if (strcmp(name, "glScissor") == 0)
     return reinterpret_cast<void*>(Mock_glScissor);
   if (strcmp(name, "glSetFenceAPPLE") == 0)
     return reinterpret_cast<void*>(Mock_glSetFenceAPPLE);
   if (strcmp(name, "glSetFenceNV") == 0)
     return reinterpret_cast<void*>(Mock_glSetFenceNV);
   if (strcmp(name, "glShaderBinary") == 0)
     return reinterpret_cast<void*>(Mock_glShaderBinary);
   if (strcmp(name, "glShaderSource") == 0)
     return reinterpret_cast<void*>(Mock_glShaderSource);
@@ skipping 25 matching lines @@
     return reinterpret_cast<void*>(
         Mock_glStencilThenCoverStrokePathInstancedNV);
   if (strcmp(name, "glStencilThenCoverStrokePathNV") == 0)
     return reinterpret_cast<void*>(Mock_glStencilThenCoverStrokePathNV);
   if (strcmp(name, "glTestFenceAPPLE") == 0)
     return reinterpret_cast<void*>(Mock_glTestFenceAPPLE);
   if (strcmp(name, "glTestFenceNV") == 0)
     return reinterpret_cast<void*>(Mock_glTestFenceNV);
   if (strcmp(name, "glTexImage2D") == 0)
     return reinterpret_cast<void*>(Mock_glTexImage2D);
+  if (strcmp(name, "glTexImage2DRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glTexImage2DRobustANGLE);
   if (strcmp(name, "glTexImage3D") == 0)
     return reinterpret_cast<void*>(Mock_glTexImage3D);
+  if (strcmp(name, "glTexImage3DRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glTexImage3DRobustANGLE);
+  if (strcmp(name, "glTexParameterIivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glTexParameterIivRobustANGLE);
+  if (strcmp(name, "glTexParameterIuivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glTexParameterIuivRobustANGLE);
   if (strcmp(name, "glTexParameterf") == 0)
     return reinterpret_cast<void*>(Mock_glTexParameterf);
   if (strcmp(name, "glTexParameterfv") == 0)
     return reinterpret_cast<void*>(Mock_glTexParameterfv);
+  if (strcmp(name, "glTexParameterfvRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glTexParameterfvRobustANGLE);
   if (strcmp(name, "glTexParameteri") == 0)
     return reinterpret_cast<void*>(Mock_glTexParameteri);
   if (strcmp(name, "glTexParameteriv") == 0)
     return reinterpret_cast<void*>(Mock_glTexParameteriv);
+  if (strcmp(name, "glTexParameterivRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glTexParameterivRobustANGLE);
   if (strcmp(name, "glTexStorage2D") == 0)
     return reinterpret_cast<void*>(Mock_glTexStorage2D);
   if (strcmp(name, "glTexStorage2DEXT") == 0)
     return reinterpret_cast<void*>(Mock_glTexStorage2DEXT);
   if (strcmp(name, "glTexStorage3D") == 0)
     return reinterpret_cast<void*>(Mock_glTexStorage3D);
   if (strcmp(name, "glTexSubImage2D") == 0)
     return reinterpret_cast<void*>(Mock_glTexSubImage2D);
+  if (strcmp(name, "glTexSubImage2DRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glTexSubImage2DRobustANGLE);
   if (strcmp(name, "glTexSubImage3D") == 0)
     return reinterpret_cast<void*>(Mock_glTexSubImage3D);
+  if (strcmp(name, "glTexSubImage3DRobustANGLE") == 0)
+    return reinterpret_cast<void*>(Mock_glTexSubImage3DRobustANGLE);
   if (strcmp(name, "glTransformFeedbackVaryings") == 0)
     return reinterpret_cast<void*>(Mock_glTransformFeedbackVaryings);
   if (strcmp(name, "glTransformFeedbackVaryingsEXT") == 0)
     return reinterpret_cast<void*>(Mock_glTransformFeedbackVaryingsEXT);
   if (strcmp(name, "glUniform1f") == 0)
     return reinterpret_cast<void*>(Mock_glUniform1f);
   if (strcmp(name, "glUniform1fv") == 0)
     return reinterpret_cast<void*>(Mock_glUniform1fv);
   if (strcmp(name, "glUniform1i") == 0)
     return reinterpret_cast<void*>(Mock_glUniform1i);
@@ skipping 102 matching lines @@
   if (strcmp(name, "glVertexAttribPointer") == 0)
     return reinterpret_cast<void*>(Mock_glVertexAttribPointer);
   if (strcmp(name, "glViewport") == 0)
     return reinterpret_cast<void*>(Mock_glViewport);
   if (strcmp(name, "glWaitSync") == 0)
     return reinterpret_cast<void*>(Mock_glWaitSync);
   return reinterpret_cast<void*>(&MockInvalidFunction);
 }
 
 }  // namespace gl