1 /*
2  * Copyright 2014 Google Inc.
3  *
4  * Use of this source code is governed by a BSD-style license that can be
5  * found in the LICENSE file.
6  */
7 
8 
9 #include "gl/GrGLAssembleInterface.h"
10 #include "GrGLUtil.h"
11 
12 #define GET_PROC(F) functions->f ## F = (GrGL ## F ## Proc) get(ctx, "gl" #F)
13 #define GET_PROC_SUFFIX(F, S) functions->f ## F = (GrGL ## F ## Proc) get(ctx, "gl" #F #S)
14 #define GET_PROC_LOCAL(F) GrGL ## F ## Proc F = (GrGL ## F ## Proc) get(ctx, "gl" #F)
15 
16 #define GET_EGL_PROC_SUFFIX(F, S) functions->fEGL ## F = (GrEGL ## F ## Proc) get(ctx, "egl" #F #S)
17 
GrGLAssembleInterface(void * ctx,GrGLGetProc get)18 const GrGLInterface* GrGLAssembleInterface(void* ctx, GrGLGetProc get) {
19     GET_PROC_LOCAL(GetString);
20     if (nullptr == GetString) {
21         return nullptr;
22     }
23 
24     const char* verStr = reinterpret_cast<const char*>(GetString(GR_GL_VERSION));
25     if (nullptr == verStr) {
26         return nullptr;
27     }
28 
29     GrGLStandard standard = GrGLGetStandardInUseFromString(verStr);
30 
31     if (kGLES_GrGLStandard == standard) {
32         return GrGLAssembleGLESInterface(ctx, get);
33     } else if (kGL_GrGLStandard == standard) {
34         return GrGLAssembleGLInterface(ctx, get);
35     }
36     return nullptr;
37 }
38 
get_egl_query_and_display(GrEGLQueryStringProc * queryString,GrEGLDisplay * display,void * ctx,GrGLGetProc get)39 static void get_egl_query_and_display(GrEGLQueryStringProc* queryString, GrEGLDisplay* display,
40                                       void* ctx, GrGLGetProc get) {
41     *queryString = (GrEGLQueryStringProc) get(ctx, "eglQueryString");
42     *display = GR_EGL_NO_DISPLAY;
43     if (*queryString) {
44         GrEGLGetCurrentDisplayProc getCurrentDisplay =
45             (GrEGLGetCurrentDisplayProc) get(ctx, "eglGetCurrentDisplay");
46         if (getCurrentDisplay) {
47             *display = getCurrentDisplay();
48         } else {
49             *queryString = nullptr;
50         }
51     }
52 }
53 
GrGLAssembleGLInterface(void * ctx,GrGLGetProc get)54 const GrGLInterface* GrGLAssembleGLInterface(void* ctx, GrGLGetProc get) {
55     GET_PROC_LOCAL(GetString);
56     GET_PROC_LOCAL(GetStringi);
57     GET_PROC_LOCAL(GetIntegerv);
58 
59     // GetStringi may be nullptr depending on the GL version.
60     if (nullptr == GetString || nullptr == GetIntegerv) {
61         return nullptr;
62     }
63 
64     const char* versionString = (const char*) GetString(GR_GL_VERSION);
65     GrGLVersion glVer = GrGLGetVersionFromString(versionString);
66 
67     if (glVer < GR_GL_VER(1,5) || GR_GL_INVALID_VER == glVer) {
68         // We must have array and element_array buffer objects.
69         return nullptr;
70     }
71 
72     GrEGLQueryStringProc queryString;
73     GrEGLDisplay display;
74     get_egl_query_and_display(&queryString, &display, ctx, get);
75     GrGLExtensions extensions;
76     if (!extensions.init(kGL_GrGLStandard, GetString, GetStringi, GetIntegerv, queryString,
77                          display)) {
78         return nullptr;
79     }
80 
81     GrGLInterface* interface = new GrGLInterface();
82     GrGLInterface::Functions* functions = &interface->fFunctions;
83 
84     GET_PROC(ActiveTexture);
85     GET_PROC(AttachShader);
86     GET_PROC(BindAttribLocation);
87     GET_PROC(BindBuffer);
88     if (glVer >= GR_GL_VER(3,0)) {
89         GET_PROC(BindFragDataLocation);
90     }
91     GET_PROC(BeginQuery);
92     GET_PROC(BindTexture);
93 
94     if (extensions.has("GL_KHR_blend_equation_advanced")) {
95         GET_PROC_SUFFIX(BlendBarrier, KHR);
96     } else if (extensions.has("GL_NV_blend_equation_advanced")) {
97         GET_PROC_SUFFIX(BlendBarrier, NV);
98     }
99 
100     if (glVer >= GR_GL_VER(1,4) ||
101         extensions.has("GL_ARB_imaging")) {
102         GET_PROC(BlendColor);
103     } else if (extensions.has("GL_EXT_blend_color")) {
104         GET_PROC_SUFFIX(BlendColor, EXT);
105     }
106 
107     if (glVer >= GR_GL_VER(1,4) ||
108         extensions.has("GL_ARB_imaging")) {
109         GET_PROC(BlendEquation);
110     } else if (extensions.has("GL_EXT_blend_subtract")) {
111         GET_PROC_SUFFIX(BlendEquation, EXT);
112     }
113 
114     GET_PROC(BlendFunc);
115     GET_PROC(BufferData);
116     GET_PROC(BufferSubData);
117     GET_PROC(Clear);
118     GET_PROC(ClearColor);
119     GET_PROC(ClearStencil);
120     GET_PROC(ColorMask);
121     GET_PROC(CompileShader);
122     GET_PROC(CompressedTexImage2D);
123     GET_PROC(CompressedTexSubImage2D);
124     GET_PROC(CopyTexSubImage2D);
125     GET_PROC(CreateProgram);
126     GET_PROC(CreateShader);
127     GET_PROC(CullFace);
128     GET_PROC(DeleteBuffers);
129     GET_PROC(DeleteProgram);
130     GET_PROC(DeleteQueries);
131     GET_PROC(DeleteShader);
132     GET_PROC(DeleteTextures);
133     GET_PROC(DepthMask);
134     GET_PROC(Disable);
135     GET_PROC(DisableVertexAttribArray);
136     GET_PROC(DrawArrays);
137     GET_PROC(DrawBuffer);
138     GET_PROC(DrawBuffers);
139     GET_PROC(DrawElements);
140 
141     if (glVer >= GR_GL_VER(3,1) || extensions.has("GL_ARB_draw_instanced") ||
142         extensions.has("GL_EXT_draw_instanced")) {
143         GET_PROC(DrawArraysInstanced);
144         GET_PROC(DrawElementsInstanced);
145     }
146 
147     if (glVer >= GR_GL_VER(4,0) || extensions.has("GL_ARB_draw_indirect")) {
148         GET_PROC(DrawArraysIndirect);
149         GET_PROC(DrawElementsIndirect);
150     }
151     if (glVer >= GR_GL_VER(2,0)) {
152         GET_PROC(DrawRangeElements);
153     }
154     GET_PROC(Enable);
155     GET_PROC(EnableVertexAttribArray);
156     GET_PROC(EndQuery);
157     GET_PROC(Finish);
158     GET_PROC(Flush);
159     GET_PROC(FrontFace);
160     GET_PROC(GenBuffers);
161     GET_PROC(GetBufferParameteriv);
162     GET_PROC(GetError);
163     GET_PROC(GetIntegerv);
164     if (glVer >= GR_GL_VER(3,2) || extensions.has("GL_ARB_texture_multisample")) {
165         GET_PROC(GetMultisamplefv);
166     }
167     GET_PROC(GetQueryObjectiv);
168     GET_PROC(GetQueryObjectuiv);
169     if (glVer >= GR_GL_VER(3,3) || extensions.has("GL_ARB_timer_query")) {
170         GET_PROC(GetQueryObjecti64v);
171         GET_PROC(GetQueryObjectui64v);
172         GET_PROC(QueryCounter);
173     } else if (extensions.has("GL_EXT_timer_query")) {
174         GET_PROC_SUFFIX(GetQueryObjecti64v, EXT);
175         GET_PROC_SUFFIX(GetQueryObjectui64v, EXT);
176     }
177     GET_PROC(GetQueryiv);
178     GET_PROC(GetProgramInfoLog);
179     GET_PROC(GetProgramiv);
180     GET_PROC(GetShaderInfoLog);
181     GET_PROC(GetShaderiv);
182     GET_PROC(GetString);
183     GET_PROC(GetStringi);
184     GET_PROC(GetShaderPrecisionFormat);
185     GET_PROC(GetTexLevelParameteriv);
186     GET_PROC(GenQueries);
187     GET_PROC(GenTextures);
188     GET_PROC(GetUniformLocation);
189     GET_PROC(IsTexture);
190     GET_PROC(LineWidth);
191     GET_PROC(LinkProgram);
192     GET_PROC(MapBuffer);
193 
194     if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_multi_draw_indirect")) {
195         GET_PROC(MultiDrawArraysIndirect);
196         GET_PROC(MultiDrawElementsIndirect);
197     }
198 
199     GET_PROC(PixelStorei);
200     if (extensions.has("GL_EXT_raster_multisample")) {
201         GET_PROC_SUFFIX(RasterSamples, EXT);
202     }
203     GET_PROC(ReadBuffer);
204     GET_PROC(ReadPixels);
205     GET_PROC(Scissor);
206     GET_PROC(ShaderSource);
207     GET_PROC(StencilFunc);
208     GET_PROC(StencilFuncSeparate);
209     GET_PROC(StencilMask);
210     GET_PROC(StencilMaskSeparate);
211     GET_PROC(StencilOp);
212     GET_PROC(StencilOpSeparate);
213     if (glVer >= GR_GL_VER(3,1)) {
214         GET_PROC(TexBuffer);
215     }
216     if (glVer >= GR_GL_VER(4,3)) {
217         GET_PROC(TexBufferRange);
218     }
219     GET_PROC(TexImage2D);
220     GET_PROC(TexParameteri);
221     GET_PROC(TexParameteriv);
222     if (glVer >= GR_GL_VER(4,2) || extensions.has("GL_ARB_texture_storage")) {
223         GET_PROC(TexStorage2D);
224     } else if (extensions.has("GL_EXT_texture_storage")) {
225         GET_PROC_SUFFIX(TexStorage2D, EXT);
226     }
227     GET_PROC(TexSubImage2D);
228     if (glVer >= GR_GL_VER(4,5) || extensions.has("GL_ARB_texture_barrier")) {
229         GET_PROC(TextureBarrier);
230     } else if (extensions.has("GL_NV_texture_barrier")) {
231         GET_PROC_SUFFIX(TextureBarrier, NV);
232     }
233     GET_PROC(Uniform1f);
234     GET_PROC(Uniform1i);
235     GET_PROC(Uniform1fv);
236     GET_PROC(Uniform1iv);
237     GET_PROC(Uniform2f);
238     GET_PROC(Uniform2i);
239     GET_PROC(Uniform2fv);
240     GET_PROC(Uniform2iv);
241     GET_PROC(Uniform3f);
242     GET_PROC(Uniform3i);
243     GET_PROC(Uniform3fv);
244     GET_PROC(Uniform3iv);
245     GET_PROC(Uniform4f);
246     GET_PROC(Uniform4i);
247     GET_PROC(Uniform4fv);
248     GET_PROC(Uniform4iv);
249     GET_PROC(UniformMatrix2fv);
250     GET_PROC(UniformMatrix3fv);
251     GET_PROC(UniformMatrix4fv);
252     GET_PROC(UnmapBuffer);
253     GET_PROC(UseProgram);
254     GET_PROC(VertexAttrib1f);
255     GET_PROC(VertexAttrib2fv);
256     GET_PROC(VertexAttrib3fv);
257     GET_PROC(VertexAttrib4fv);
258 
259     if (glVer >= GR_GL_VER(3,2) || extensions.has("GL_ARB_instanced_arrays")) {
260         GET_PROC(VertexAttribDivisor);
261     }
262 
263     if (glVer >= GR_GL_VER(3,0)) {
264         GET_PROC(VertexAttribIPointer);
265     }
266 
267     GET_PROC(VertexAttribPointer);
268     GET_PROC(Viewport);
269     GET_PROC(BindFragDataLocationIndexed);
270 
271     if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_vertex_array_object")) {
272         // no ARB suffix for GL_ARB_vertex_array_object
273         GET_PROC(BindVertexArray);
274         GET_PROC(GenVertexArrays);
275         GET_PROC(DeleteVertexArrays);
276     } else if (extensions.has("GL_APPLE_vertex_array_object")) {
277         GET_PROC_SUFFIX(BindVertexArray, APPLE);
278         GET_PROC_SUFFIX(GenVertexArrays, APPLE);
279         GET_PROC_SUFFIX(DeleteVertexArrays, APPLE);
280     }
281 
282     if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_map_buffer_range")) {
283         GET_PROC(MapBufferRange);
284         GET_PROC(FlushMappedBufferRange);
285     }
286 
287     // First look for GL3.0 FBO or GL_ARB_framebuffer_object (same since
288     // GL_ARB_framebuffer_object doesn't use ARB suffix.)
289     if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_framebuffer_object")) {
290         GET_PROC(GenerateMipmap);
291         GET_PROC(GenFramebuffers);
292         GET_PROC(GetFramebufferAttachmentParameteriv);
293         GET_PROC(GetRenderbufferParameteriv);
294         GET_PROC(BindFramebuffer);
295         GET_PROC(FramebufferTexture2D);
296         GET_PROC(CheckFramebufferStatus);
297         GET_PROC(DeleteFramebuffers);
298         GET_PROC(RenderbufferStorage);
299         GET_PROC(GenRenderbuffers);
300         GET_PROC(DeleteRenderbuffers);
301         GET_PROC(FramebufferRenderbuffer);
302         GET_PROC(BindRenderbuffer);
303         GET_PROC(RenderbufferStorageMultisample);
304         GET_PROC(BlitFramebuffer);
305     } else if (extensions.has("GL_EXT_framebuffer_object")) {
306         GET_PROC_SUFFIX(GenerateMipmap, EXT);
307         GET_PROC_SUFFIX(GenFramebuffers, EXT);
308         GET_PROC_SUFFIX(GetFramebufferAttachmentParameteriv, EXT);
309         GET_PROC_SUFFIX(GetRenderbufferParameteriv, EXT);
310         GET_PROC_SUFFIX(BindFramebuffer, EXT);
311         GET_PROC_SUFFIX(FramebufferTexture2D, EXT);
312         GET_PROC_SUFFIX(CheckFramebufferStatus, EXT);
313         GET_PROC_SUFFIX(DeleteFramebuffers, EXT);
314         GET_PROC_SUFFIX(RenderbufferStorage, EXT);
315         GET_PROC_SUFFIX(GenRenderbuffers, EXT);
316         GET_PROC_SUFFIX(DeleteRenderbuffers, EXT);
317         GET_PROC_SUFFIX(FramebufferRenderbuffer, EXT);
318         GET_PROC_SUFFIX(BindRenderbuffer, EXT);
319         if (extensions.has("GL_EXT_framebuffer_multisample")) {
320             GET_PROC_SUFFIX(RenderbufferStorageMultisample, EXT);
321         }
322         if (extensions.has("GL_EXT_framebuffer_blit")) {
323             GET_PROC_SUFFIX(BlitFramebuffer, EXT);
324         }
325     } else {
326         // we must have FBOs
327         delete interface;
328         return nullptr;
329     }
330 
331     if (extensions.has("GL_NV_path_rendering")) {
332         GET_PROC_SUFFIX(MatrixLoadf, EXT);
333         GET_PROC_SUFFIX(MatrixLoadIdentity, EXT);
334         GET_PROC_SUFFIX(PathCommands, NV);
335         GET_PROC_SUFFIX(PathParameteri, NV);
336         GET_PROC_SUFFIX(PathParameterf, NV);
337         GET_PROC_SUFFIX(GenPaths, NV);
338         GET_PROC_SUFFIX(DeletePaths, NV);
339         GET_PROC_SUFFIX(IsPath, NV);
340         GET_PROC_SUFFIX(PathStencilFunc, NV);
341         GET_PROC_SUFFIX(StencilFillPath, NV);
342         GET_PROC_SUFFIX(StencilStrokePath, NV);
343         GET_PROC_SUFFIX(StencilFillPathInstanced, NV);
344         GET_PROC_SUFFIX(StencilStrokePathInstanced, NV);
345         GET_PROC_SUFFIX(CoverFillPath, NV);
346         GET_PROC_SUFFIX(CoverStrokePath, NV);
347         GET_PROC_SUFFIX(CoverFillPathInstanced, NV);
348         GET_PROC_SUFFIX(CoverStrokePathInstanced, NV);
349         GET_PROC_SUFFIX(StencilThenCoverFillPath, NV);
350         GET_PROC_SUFFIX(StencilThenCoverStrokePath, NV);
351         GET_PROC_SUFFIX(StencilThenCoverFillPathInstanced, NV);
352         GET_PROC_SUFFIX(StencilThenCoverStrokePathInstanced, NV);
353         GET_PROC_SUFFIX(ProgramPathFragmentInputGen, NV);
354     }
355 
356     if (extensions.has("GL_NV_framebuffer_mixed_samples")) {
357         GET_PROC_SUFFIX(CoverageModulation, NV);
358     }
359 
360     if (extensions.has("GL_EXT_debug_marker")) {
361         GET_PROC_SUFFIX(InsertEventMarker, EXT);
362         GET_PROC_SUFFIX(PushGroupMarker, EXT);
363         GET_PROC_SUFFIX(PopGroupMarker, EXT);
364     }
365 
366     if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_invalidate_subdata")) {
367         GET_PROC(InvalidateBufferData);
368         GET_PROC(InvalidateBufferSubData);
369         GET_PROC(InvalidateFramebuffer);
370         GET_PROC(InvalidateSubFramebuffer);
371         GET_PROC(InvalidateTexImage);
372         GET_PROC(InvalidateTexSubImage);
373     }
374 
375     if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_program_interface_query")) {
376         GET_PROC(GetProgramResourceLocation);
377     }
378 
379     if (extensions.has("GL_NV_bindless_texture")) {
380         GET_PROC_SUFFIX(GetTextureHandle, NV);
381         GET_PROC_SUFFIX(GetTextureSamplerHandle, NV);
382         GET_PROC_SUFFIX(MakeTextureHandleResident, NV);
383         GET_PROC_SUFFIX(MakeTextureHandleNonResident, NV);
384         GET_PROC_SUFFIX(GetImageHandle, NV);
385         GET_PROC_SUFFIX(MakeImageHandleResident, NV);
386         GET_PROC_SUFFIX(MakeImageHandleNonResident, NV);
387         GET_PROC_SUFFIX(IsTextureHandleResident, NV);
388         GET_PROC_SUFFIX(IsImageHandleResident, NV);
389         GET_PROC_SUFFIX(UniformHandleui64, NV);
390         GET_PROC_SUFFIX(UniformHandleui64v, NV);
391         GET_PROC_SUFFIX(ProgramUniformHandleui64, NV);
392         GET_PROC_SUFFIX(ProgramUniformHandleui64v, NV);
393     }
394 
395     if (extensions.has("GL_EXT_direct_state_access")) {
396         GET_PROC_SUFFIX(TextureParameteri, EXT);
397         GET_PROC_SUFFIX(TextureParameteriv, EXT);
398         GET_PROC_SUFFIX(TextureParameterf, EXT);
399         GET_PROC_SUFFIX(TextureParameterfv, EXT);
400         GET_PROC_SUFFIX(TextureImage1D, EXT);
401         GET_PROC_SUFFIX(TextureImage2D, EXT);
402         GET_PROC_SUFFIX(TextureSubImage1D, EXT);
403         GET_PROC_SUFFIX(TextureSubImage2D, EXT);
404         GET_PROC_SUFFIX(CopyTextureImage1D, EXT);
405         GET_PROC_SUFFIX(CopyTextureImage2D, EXT);
406         GET_PROC_SUFFIX(CopyTextureSubImage1D, EXT);
407         GET_PROC_SUFFIX(CopyTextureSubImage2D, EXT);
408         GET_PROC_SUFFIX(GetTextureImage, EXT);
409         GET_PROC_SUFFIX(GetTextureParameterfv, EXT);
410         GET_PROC_SUFFIX(GetTextureParameteriv, EXT);
411         GET_PROC_SUFFIX(GetTextureLevelParameterfv, EXT);
412         GET_PROC_SUFFIX(GetTextureLevelParameteriv, EXT);
413         if (glVer >= GR_GL_VER(1,2)) {
414             GET_PROC_SUFFIX(TextureImage3D, EXT);
415             GET_PROC_SUFFIX(TextureSubImage3D, EXT);
416             GET_PROC_SUFFIX(CopyTextureSubImage3D, EXT);
417             GET_PROC_SUFFIX(CompressedTextureImage3D, EXT);
418             GET_PROC_SUFFIX(CompressedTextureImage2D, EXT);
419             GET_PROC_SUFFIX(CompressedTextureImage1D, EXT);
420             GET_PROC_SUFFIX(CompressedTextureSubImage3D, EXT);
421             GET_PROC_SUFFIX(CompressedTextureSubImage2D, EXT);
422             GET_PROC_SUFFIX(CompressedTextureSubImage1D, EXT);
423             GET_PROC_SUFFIX(GetCompressedTextureImage, EXT);
424         }
425         if (glVer >= GR_GL_VER(1,5)) {
426             GET_PROC_SUFFIX(NamedBufferData, EXT);
427             GET_PROC_SUFFIX(NamedBufferSubData, EXT);
428             GET_PROC_SUFFIX(MapNamedBuffer, EXT);
429             GET_PROC_SUFFIX(UnmapNamedBuffer, EXT);
430             GET_PROC_SUFFIX(GetNamedBufferParameteriv, EXT);
431             GET_PROC_SUFFIX(GetNamedBufferPointerv, EXT);
432             GET_PROC_SUFFIX(GetNamedBufferSubData, EXT);
433         }
434         if (glVer >= GR_GL_VER(2,0)) {
435             GET_PROC_SUFFIX(ProgramUniform1f, EXT);
436             GET_PROC_SUFFIX(ProgramUniform2f, EXT);
437             GET_PROC_SUFFIX(ProgramUniform3f, EXT);
438             GET_PROC_SUFFIX(ProgramUniform4f, EXT);
439             GET_PROC_SUFFIX(ProgramUniform1i, EXT);
440             GET_PROC_SUFFIX(ProgramUniform2i, EXT);
441             GET_PROC_SUFFIX(ProgramUniform3i, EXT);
442             GET_PROC_SUFFIX(ProgramUniform4i, EXT);
443             GET_PROC_SUFFIX(ProgramUniform1fv, EXT);
444             GET_PROC_SUFFIX(ProgramUniform2fv, EXT);
445             GET_PROC_SUFFIX(ProgramUniform3fv, EXT);
446             GET_PROC_SUFFIX(ProgramUniform4fv, EXT);
447             GET_PROC_SUFFIX(ProgramUniform1iv, EXT);
448             GET_PROC_SUFFIX(ProgramUniform2iv, EXT);
449             GET_PROC_SUFFIX(ProgramUniform3iv, EXT);
450             GET_PROC_SUFFIX(ProgramUniform4iv, EXT);
451             GET_PROC_SUFFIX(ProgramUniformMatrix2fv, EXT);
452             GET_PROC_SUFFIX(ProgramUniformMatrix3fv, EXT);
453             GET_PROC_SUFFIX(ProgramUniformMatrix4fv, EXT);
454         }
455         if (glVer >= GR_GL_VER(2,1)) {
456             GET_PROC_SUFFIX(ProgramUniformMatrix2x3fv, EXT);
457             GET_PROC_SUFFIX(ProgramUniformMatrix3x2fv, EXT);
458             GET_PROC_SUFFIX(ProgramUniformMatrix2x4fv, EXT);
459             GET_PROC_SUFFIX(ProgramUniformMatrix4x2fv, EXT);
460             GET_PROC_SUFFIX(ProgramUniformMatrix3x4fv, EXT);
461             GET_PROC_SUFFIX(ProgramUniformMatrix4x3fv, EXT);
462         }
463         if (glVer >= GR_GL_VER(3,0)) {
464             GET_PROC_SUFFIX(NamedRenderbufferStorage, EXT);
465             GET_PROC_SUFFIX(GetNamedRenderbufferParameteriv, EXT);
466             GET_PROC_SUFFIX(NamedRenderbufferStorageMultisample, EXT);
467             GET_PROC_SUFFIX(CheckNamedFramebufferStatus, EXT);
468             GET_PROC_SUFFIX(NamedFramebufferTexture1D, EXT);
469             GET_PROC_SUFFIX(NamedFramebufferTexture2D, EXT);
470             GET_PROC_SUFFIX(NamedFramebufferTexture3D, EXT);
471             GET_PROC_SUFFIX(NamedFramebufferRenderbuffer, EXT);
472             GET_PROC_SUFFIX(GetNamedFramebufferAttachmentParameteriv, EXT);
473             GET_PROC_SUFFIX(GenerateTextureMipmap, EXT);
474             GET_PROC_SUFFIX(FramebufferDrawBuffer, EXT);
475             GET_PROC_SUFFIX(FramebufferDrawBuffers, EXT);
476             GET_PROC_SUFFIX(FramebufferReadBuffer, EXT);
477             GET_PROC_SUFFIX(GetFramebufferParameteriv, EXT);
478             GET_PROC_SUFFIX(NamedCopyBufferSubData, EXT);
479             GET_PROC_SUFFIX(VertexArrayVertexOffset, EXT);
480             GET_PROC_SUFFIX(VertexArrayColorOffset, EXT);
481             GET_PROC_SUFFIX(VertexArrayEdgeFlagOffset, EXT);
482             GET_PROC_SUFFIX(VertexArrayIndexOffset, EXT);
483             GET_PROC_SUFFIX(VertexArrayNormalOffset, EXT);
484             GET_PROC_SUFFIX(VertexArrayTexCoordOffset, EXT);
485             GET_PROC_SUFFIX(VertexArrayMultiTexCoordOffset, EXT);
486             GET_PROC_SUFFIX(VertexArrayFogCoordOffset, EXT);
487             GET_PROC_SUFFIX(VertexArraySecondaryColorOffset, EXT);
488             GET_PROC_SUFFIX(VertexArrayVertexAttribOffset, EXT);
489             GET_PROC_SUFFIX(VertexArrayVertexAttribIOffset, EXT);
490             GET_PROC_SUFFIX(EnableVertexArray, EXT);
491             GET_PROC_SUFFIX(DisableVertexArray, EXT);
492             GET_PROC_SUFFIX(EnableVertexArrayAttrib, EXT);
493             GET_PROC_SUFFIX(DisableVertexArrayAttrib, EXT);
494             GET_PROC_SUFFIX(GetVertexArrayIntegerv, EXT);
495             GET_PROC_SUFFIX(GetVertexArrayPointerv, EXT);
496             GET_PROC_SUFFIX(GetVertexArrayIntegeri_v, EXT);
497             GET_PROC_SUFFIX(GetVertexArrayPointeri_v, EXT);
498             GET_PROC_SUFFIX(MapNamedBufferRange, EXT);
499             GET_PROC_SUFFIX(FlushMappedNamedBufferRange, EXT);
500         }
501         if (glVer >= GR_GL_VER(3,1)) {
502             GET_PROC_SUFFIX(TextureBuffer, EXT);
503         }
504     }
505 
506     if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_KHR_debug")) {
507         // KHR_debug defines these methods to have no suffix in an OpenGL (not ES) context.
508         GET_PROC(DebugMessageControl);
509         GET_PROC(DebugMessageInsert);
510         GET_PROC(DebugMessageCallback);
511         GET_PROC(GetDebugMessageLog);
512         GET_PROC(PushDebugGroup);
513         GET_PROC(PopDebugGroup);
514         GET_PROC(ObjectLabel);
515     }
516 
517     if (extensions.has("GL_EXT_window_rectangles")) {
518         GET_PROC_SUFFIX(WindowRectangles, EXT);
519     }
520 
521     if (extensions.has("EGL_KHR_image") || extensions.has("EGL_KHR_image_base")) {
522         GET_EGL_PROC_SUFFIX(CreateImage, KHR);
523         GET_EGL_PROC_SUFFIX(DestroyImage, KHR);
524     }
525 
526     if (glVer >= GR_GL_VER(4, 0) || extensions.has("GL_ARB_sample_shading")) {
527         GET_PROC(MinSampleShading);
528     }
529 
530     if (glVer >= GR_GL_VER(3, 2) || extensions.has("GL_ARB_sync")) {
531         GET_PROC(FenceSync);
532         GET_PROC(ClientWaitSync);
533         GET_PROC(WaitSync);
534         GET_PROC(DeleteSync);
535     }
536 
537     if (glVer >= GR_GL_VER(4, 2) || extensions.has("GL_ARB_shader_image_load_store")) {
538         GET_PROC(BindImageTexture);
539         GET_PROC(MemoryBarrier);
540     }
541     if (glVer >= GR_GL_VER(4, 5) || extensions.has("GL_ARB_ES3_1_compatibility")) {
542         GET_PROC(MemoryBarrierByRegion);
543     }
544 
545     interface->fStandard = kGL_GrGLStandard;
546     interface->fExtensions.swap(&extensions);
547 
548     return interface;
549 }
550 
GrGLAssembleGLESInterface(void * ctx,GrGLGetProc get)551 const GrGLInterface* GrGLAssembleGLESInterface(void* ctx, GrGLGetProc get) {
552     GET_PROC_LOCAL(GetString);
553     if (nullptr == GetString) {
554         return nullptr;
555     }
556 
557     const char* verStr = reinterpret_cast<const char*>(GetString(GR_GL_VERSION));
558     GrGLVersion version = GrGLGetVersionFromString(verStr);
559 
560     if (version < GR_GL_VER(2,0)) {
561         return nullptr;
562     }
563 
564     GET_PROC_LOCAL(GetIntegerv);
565     GET_PROC_LOCAL(GetStringi);
566     GrEGLQueryStringProc queryString;
567     GrEGLDisplay display;
568     get_egl_query_and_display(&queryString, &display, ctx, get);
569     GrGLExtensions extensions;
570     if (!extensions.init(kGLES_GrGLStandard, GetString, GetStringi, GetIntegerv, queryString,
571                          display)) {
572         return nullptr;
573     }
574 
575     GrGLInterface* interface = new GrGLInterface;
576     GrGLInterface::Functions* functions = &interface->fFunctions;
577 
578     GET_PROC(ActiveTexture);
579     GET_PROC(AttachShader);
580     GET_PROC(BindAttribLocation);
581     GET_PROC(BindBuffer);
582     GET_PROC(BindTexture);
583     GET_PROC_SUFFIX(BindVertexArray, OES);
584 
585     if (version >= GR_GL_VER(3,0) && extensions.has("GL_EXT_blend_func_extended")) {
586         GET_PROC_SUFFIX(BindFragDataLocation, EXT);
587         GET_PROC_SUFFIX(BindFragDataLocationIndexed, EXT);
588     }
589 
590     if (extensions.has("GL_KHR_blend_equation_advanced")) {
591         GET_PROC_SUFFIX(BlendBarrier, KHR);
592     } else if (extensions.has("GL_NV_blend_equation_advanced")) {
593         GET_PROC_SUFFIX(BlendBarrier, NV);
594     }
595 
596     GET_PROC(BlendColor);
597     GET_PROC(BlendEquation);
598     GET_PROC(BlendFunc);
599     GET_PROC(BufferData);
600     GET_PROC(BufferSubData);
601     GET_PROC(Clear);
602     GET_PROC(ClearColor);
603     GET_PROC(ClearStencil);
604     GET_PROC(ColorMask);
605     GET_PROC(CompileShader);
606     GET_PROC(CompressedTexImage2D);
607     GET_PROC(CompressedTexSubImage2D);
608     GET_PROC(CopyTexSubImage2D);
609     GET_PROC(CreateProgram);
610     GET_PROC(CreateShader);
611     GET_PROC(CullFace);
612     GET_PROC(DeleteBuffers);
613     GET_PROC(DeleteProgram);
614     GET_PROC(DeleteShader);
615     GET_PROC(DeleteTextures);
616     GET_PROC_SUFFIX(DeleteVertexArrays, OES);
617     GET_PROC(DepthMask);
618     GET_PROC(Disable);
619     GET_PROC(DisableVertexAttribArray);
620     GET_PROC(DrawArrays);
621 
622     if (version >= GR_GL_VER(3,0)) {
623         GET_PROC(DrawArraysInstanced);
624         GET_PROC(DrawElementsInstanced);
625     } else if (extensions.has("GL_EXT_draw_instanced")) {
626         GET_PROC_SUFFIX(DrawArraysInstanced, EXT);
627         GET_PROC_SUFFIX(DrawElementsInstanced, EXT);
628     }
629 
630     if (version >= GR_GL_VER(3,1)) {
631         GET_PROC(DrawArraysIndirect);
632         GET_PROC(DrawElementsIndirect);
633     }
634 
635     GET_PROC(DrawElements);
636     if (version >= GR_GL_VER(3,0)) {
637         GET_PROC(DrawRangeElements);
638     }
639     GET_PROC(Enable);
640     GET_PROC(EnableVertexAttribArray);
641     GET_PROC(Finish);
642     GET_PROC(Flush);
643     GET_PROC(FrontFace);
644     GET_PROC(GenBuffers);
645     GET_PROC(GenerateMipmap);
646     GET_PROC(GenTextures);
647     GET_PROC_SUFFIX(GenVertexArrays, OES);
648     GET_PROC(GetBufferParameteriv);
649     GET_PROC(GetError);
650     GET_PROC(GetIntegerv);
651 
652     if (version >= GR_GL_VER(3,1)) {
653         GET_PROC(GetMultisamplefv);
654     }
655 
656     GET_PROC(GetProgramInfoLog);
657     GET_PROC(GetProgramiv);
658     GET_PROC(GetShaderInfoLog);
659     GET_PROC(GetShaderPrecisionFormat);
660     GET_PROC(GetShaderiv);
661     GET_PROC(GetString);
662     GET_PROC(GetStringi);
663     GET_PROC(GetUniformLocation);
664     GET_PROC(IsTexture);
665     GET_PROC(LineWidth);
666     GET_PROC(LinkProgram);
667 
668     if (extensions.has("GL_EXT_multi_draw_indirect")) {
669         GET_PROC_SUFFIX(MultiDrawArraysIndirect, EXT);
670         GET_PROC_SUFFIX(MultiDrawElementsIndirect, EXT);
671     }
672 
673     GET_PROC(PixelStorei);
674 
675     if (extensions.has("GL_EXT_raster_multisample")) {
676         GET_PROC_SUFFIX(RasterSamples, EXT);
677     }
678 
679     GET_PROC(ReadPixels);
680     GET_PROC(Scissor);
681     GET_PROC(ShaderSource);
682     GET_PROC(StencilFunc);
683     GET_PROC(StencilFuncSeparate);
684     GET_PROC(StencilMask);
685     GET_PROC(StencilMaskSeparate);
686     GET_PROC(StencilOp);
687     GET_PROC(StencilOpSeparate);
688 
689     if (version >= GR_GL_VER(3,2)) {
690         GET_PROC(TexBuffer);
691         GET_PROC(TexBufferRange);
692     } else if (extensions.has("GL_OES_texture_buffer")) {
693         GET_PROC_SUFFIX(TexBuffer, OES);
694         GET_PROC_SUFFIX(TexBufferRange, OES);
695     } else if (extensions.has("GL_EXT_texture_buffer")) {
696         GET_PROC_SUFFIX(TexBuffer, EXT);
697         GET_PROC_SUFFIX(TexBufferRange, EXT);
698     }
699 
700     GET_PROC(TexImage2D);
701     GET_PROC(TexParameteri);
702     GET_PROC(TexParameteriv);
703     GET_PROC(TexSubImage2D);
704 
705     if (version >= GR_GL_VER(3,0)) {
706         GET_PROC(TexStorage2D);
707     } else {
708         GET_PROC_SUFFIX(TexStorage2D, EXT);
709     }
710 
711     if (extensions.has("GL_NV_texture_barrier")) {
712         GET_PROC_SUFFIX(TextureBarrier, NV);
713     }
714 
715     GET_PROC_SUFFIX(DiscardFramebuffer, EXT);
716     GET_PROC(Uniform1f);
717     GET_PROC(Uniform1i);
718     GET_PROC(Uniform1fv);
719     GET_PROC(Uniform1iv);
720     GET_PROC(Uniform2f);
721     GET_PROC(Uniform2i);
722     GET_PROC(Uniform2fv);
723     GET_PROC(Uniform2iv);
724     GET_PROC(Uniform3f);
725     GET_PROC(Uniform3i);
726     GET_PROC(Uniform3fv);
727     GET_PROC(Uniform3iv);
728     GET_PROC(Uniform4f);
729     GET_PROC(Uniform4i);
730     GET_PROC(Uniform4fv);
731     GET_PROC(Uniform4iv);
732     GET_PROC(UniformMatrix2fv);
733     GET_PROC(UniformMatrix3fv);
734     GET_PROC(UniformMatrix4fv);
735     GET_PROC(UseProgram);
736     GET_PROC(VertexAttrib1f);
737     GET_PROC(VertexAttrib2fv);
738     GET_PROC(VertexAttrib3fv);
739     GET_PROC(VertexAttrib4fv);
740 
741     if (version >= GR_GL_VER(3,0)) {
742         GET_PROC(VertexAttribDivisor);
743     } else if (extensions.has("GL_EXT_instanced_arrays")) {
744         GET_PROC_SUFFIX(VertexAttribDivisor, EXT);
745     }
746 
747     if (version >= GR_GL_VER(3,0)) {
748         GET_PROC(VertexAttribIPointer);
749     }
750 
751     GET_PROC(VertexAttribPointer);
752     GET_PROC(Viewport);
753     GET_PROC(BindFramebuffer);
754     GET_PROC(BindRenderbuffer);
755     GET_PROC(CheckFramebufferStatus);
756     GET_PROC(DeleteFramebuffers);
757     GET_PROC(DeleteRenderbuffers);
758     GET_PROC(FramebufferRenderbuffer);
759     GET_PROC(FramebufferTexture2D);
760 
761     if (version >= GR_GL_VER(3,0)) {
762         GET_PROC(RenderbufferStorageMultisample);
763         GET_PROC(BlitFramebuffer);
764     } else if (extensions.has("GL_CHROMIUM_framebuffer_multisample")) {
765         GET_PROC_SUFFIX(RenderbufferStorageMultisample, CHROMIUM);
766         GET_PROC_SUFFIX(BlitFramebuffer, CHROMIUM);
767     } else {
768         if (extensions.has("GL_ANGLE_framebuffer_multisample")) {
769             GET_PROC_SUFFIX(RenderbufferStorageMultisample, ANGLE);
770         }
771         if (extensions.has("GL_ANGLE_framebuffer_blit")) {
772             GET_PROC_SUFFIX(BlitFramebuffer, ANGLE);
773         }
774     }
775 
776     if (extensions.has("GL_CHROMIUM_map_sub")) {
777         GET_PROC_SUFFIX(MapBufferSubData, CHROMIUM);
778         GET_PROC_SUFFIX(MapTexSubImage2D, CHROMIUM);
779         GET_PROC_SUFFIX(UnmapBufferSubData, CHROMIUM);
780         GET_PROC_SUFFIX(UnmapTexSubImage2D, CHROMIUM);
781     }
782 
783     if (extensions.has("GL_EXT_multisampled_render_to_texture")) {
784         GET_PROC_SUFFIX(FramebufferTexture2DMultisample, EXT);
785         functions->fRenderbufferStorageMultisampleES2EXT = (GrGLRenderbufferStorageMultisampleProc) get(ctx, "glRenderbufferStorageMultisampleEXT");
786     } else if (extensions.has("GL_IMG_multisampled_render_to_texture")) {
787         GET_PROC_SUFFIX(FramebufferTexture2DMultisample, IMG);
788         functions->fRenderbufferStorageMultisampleES2EXT = (GrGLRenderbufferStorageMultisampleProc) get(ctx, "glRenderbufferStorageMultisampleIMG");
789     } else if (extensions.has("GL_APPLE_framebuffer_multisample")) {
790         functions->fRenderbufferStorageMultisampleES2APPLE = (GrGLRenderbufferStorageMultisampleProc) get(ctx, "glRenderbufferStorageMultisampleAPPLE");
791         GET_PROC_SUFFIX(ResolveMultisampleFramebuffer, APPLE);
792     }
793 
794     GET_PROC(GenFramebuffers);
795     GET_PROC(GenRenderbuffers);
796     GET_PROC(GetFramebufferAttachmentParameteriv);
797     GET_PROC(GetRenderbufferParameteriv);
798     GET_PROC(RenderbufferStorage);
799 
800     GET_PROC_SUFFIX(MapBuffer, OES);
801     GET_PROC_SUFFIX(UnmapBuffer, OES);
802 
803     if (version >= GR_GL_VER(3,0)) {
804         GET_PROC(MapBufferRange);
805         GET_PROC(FlushMappedBufferRange);
806     } else if (extensions.has("GL_EXT_map_buffer_range")) {
807         GET_PROC_SUFFIX(MapBufferRange, EXT);
808         GET_PROC_SUFFIX(FlushMappedBufferRange, EXT);
809     }
810 
811     if (extensions.has("GL_EXT_debug_marker")) {
812         GET_PROC_SUFFIX(InsertEventMarker, EXT);
813         GET_PROC_SUFFIX(PushGroupMarker, EXT);
814         GET_PROC_SUFFIX(PopGroupMarker, EXT);
815     }
816 
817     GET_PROC(InvalidateFramebuffer);
818     GET_PROC(InvalidateSubFramebuffer);
819     GET_PROC(InvalidateBufferData);
820     GET_PROC(InvalidateBufferSubData);
821     GET_PROC(InvalidateTexImage);
822     GET_PROC(InvalidateTexSubImage);
823 
824     if (version >= GR_GL_VER(3,1)) {
825         GET_PROC(GetProgramResourceLocation);
826     }
827 
828     if (extensions.has("GL_NV_path_rendering")) {
829         GET_PROC_SUFFIX(MatrixLoadf, EXT);
830         GET_PROC_SUFFIX(MatrixLoadIdentity, EXT);
831         GET_PROC_SUFFIX(PathCommands, NV);
832         GET_PROC_SUFFIX(PathParameteri, NV);
833         GET_PROC_SUFFIX(PathParameterf, NV);
834         GET_PROC_SUFFIX(GenPaths, NV);
835         GET_PROC_SUFFIX(DeletePaths, NV);
836         GET_PROC_SUFFIX(IsPath, NV);
837         GET_PROC_SUFFIX(PathStencilFunc, NV);
838         GET_PROC_SUFFIX(StencilFillPath, NV);
839         GET_PROC_SUFFIX(StencilStrokePath, NV);
840         GET_PROC_SUFFIX(StencilFillPathInstanced, NV);
841         GET_PROC_SUFFIX(StencilStrokePathInstanced, NV);
842         GET_PROC_SUFFIX(CoverFillPath, NV);
843         GET_PROC_SUFFIX(CoverStrokePath, NV);
844         GET_PROC_SUFFIX(CoverFillPathInstanced, NV);
845         GET_PROC_SUFFIX(CoverStrokePathInstanced, NV);
846         GET_PROC_SUFFIX(StencilThenCoverFillPath, NV);
847         GET_PROC_SUFFIX(StencilThenCoverStrokePath, NV);
848         GET_PROC_SUFFIX(StencilThenCoverFillPathInstanced, NV);
849         GET_PROC_SUFFIX(StencilThenCoverStrokePathInstanced, NV);
850         GET_PROC_SUFFIX(ProgramPathFragmentInputGen, NV);
851     }
852 
853     if (extensions.has("GL_CHROMIUM_path_rendering")) {
854         GET_PROC_SUFFIX(MatrixLoadf, CHROMIUM);
855         GET_PROC_SUFFIX(MatrixLoadIdentity, CHROMIUM);
856         GET_PROC_SUFFIX(PathCommands, CHROMIUM);
857         GET_PROC_SUFFIX(PathParameteri, CHROMIUM);
858         GET_PROC_SUFFIX(PathParameterf, CHROMIUM);
859         GET_PROC_SUFFIX(GenPaths, CHROMIUM);
860         GET_PROC_SUFFIX(DeletePaths, CHROMIUM);
861         GET_PROC_SUFFIX(IsPath, CHROMIUM);
862         GET_PROC_SUFFIX(PathStencilFunc, CHROMIUM);
863         GET_PROC_SUFFIX(StencilFillPath, CHROMIUM);
864         GET_PROC_SUFFIX(StencilStrokePath, CHROMIUM);
865         GET_PROC_SUFFIX(StencilFillPathInstanced, CHROMIUM);
866         GET_PROC_SUFFIX(StencilStrokePathInstanced, CHROMIUM);
867         GET_PROC_SUFFIX(CoverFillPath, CHROMIUM);
868         GET_PROC_SUFFIX(CoverStrokePath, CHROMIUM);
869         GET_PROC_SUFFIX(CoverFillPathInstanced, CHROMIUM);
870         GET_PROC_SUFFIX(CoverStrokePathInstanced, CHROMIUM);
871         GET_PROC_SUFFIX(StencilThenCoverFillPath, CHROMIUM);
872         GET_PROC_SUFFIX(StencilThenCoverStrokePath, CHROMIUM);
873         GET_PROC_SUFFIX(StencilThenCoverFillPathInstanced, CHROMIUM);
874         GET_PROC_SUFFIX(StencilThenCoverStrokePathInstanced, CHROMIUM);
875         GET_PROC_SUFFIX(ProgramPathFragmentInputGen, CHROMIUM);
876         // GL_CHROMIUM_path_rendering additions:
877         GET_PROC_SUFFIX(BindFragmentInputLocation, CHROMIUM);
878     }
879 
880     if (extensions.has("GL_NV_framebuffer_mixed_samples")) {
881         GET_PROC_SUFFIX(CoverageModulation, NV);
882     }
883     if (extensions.has("GL_CHROMIUM_framebuffer_mixed_samples")) {
884         GET_PROC_SUFFIX(CoverageModulation, CHROMIUM);
885     }
886 
887     if (extensions.has("GL_NV_bindless_texture")) {
888         GET_PROC_SUFFIX(GetTextureHandle, NV);
889         GET_PROC_SUFFIX(GetTextureSamplerHandle, NV);
890         GET_PROC_SUFFIX(MakeTextureHandleResident, NV);
891         GET_PROC_SUFFIX(MakeTextureHandleNonResident, NV);
892         GET_PROC_SUFFIX(GetImageHandle, NV);
893         GET_PROC_SUFFIX(MakeImageHandleResident, NV);
894         GET_PROC_SUFFIX(MakeImageHandleNonResident, NV);
895         GET_PROC_SUFFIX(IsTextureHandleResident, NV);
896         GET_PROC_SUFFIX(IsImageHandleResident, NV);
897         GET_PROC_SUFFIX(UniformHandleui64, NV);
898         GET_PROC_SUFFIX(UniformHandleui64v, NV);
899         GET_PROC_SUFFIX(ProgramUniformHandleui64, NV);
900         GET_PROC_SUFFIX(ProgramUniformHandleui64v, NV);
901     }
902 
903     if (extensions.has("GL_KHR_debug")) {
904         GET_PROC_SUFFIX(DebugMessageControl, KHR);
905         GET_PROC_SUFFIX(DebugMessageInsert, KHR);
906         GET_PROC_SUFFIX(DebugMessageCallback, KHR);
907         GET_PROC_SUFFIX(GetDebugMessageLog, KHR);
908         GET_PROC_SUFFIX(PushDebugGroup, KHR);
909         GET_PROC_SUFFIX(PopDebugGroup, KHR);
910         GET_PROC_SUFFIX(ObjectLabel, KHR);
911         // In general we have a policy against removing extension strings when the driver does
912         // not provide function pointers for an advertised extension. However, because there is a
913         // known device that advertises GL_KHR_debug but fails to provide the functions and this is
914         // a debugging- only extension we've made an exception. This also can happen when using
915         // APITRACE.
916         if (!interface->fFunctions.fDebugMessageControl) {
917             extensions.remove("GL_KHR_debug");
918         }
919     }
920 
921     if (extensions.has("GL_CHROMIUM_bind_uniform_location")) {
922         GET_PROC_SUFFIX(BindUniformLocation, CHROMIUM);
923     }
924 
925     if (extensions.has("GL_EXT_window_rectangles")) {
926         GET_PROC_SUFFIX(WindowRectangles, EXT);
927     }
928 
929     if (extensions.has("EGL_KHR_image") || extensions.has("EGL_KHR_image_base")) {
930         GET_EGL_PROC_SUFFIX(CreateImage, KHR);
931         GET_EGL_PROC_SUFFIX(DestroyImage, KHR);
932     }
933 
934     if (extensions.has("GL_OES_sample_shading")) {
935         GET_PROC_SUFFIX(MinSampleShading, OES);
936     }
937 
938     if (version >= GR_GL_VER(3, 0)) {
939         GET_PROC(FenceSync);
940         GET_PROC(ClientWaitSync);
941         GET_PROC(WaitSync);
942         GET_PROC(DeleteSync);
943     }
944 
945     if (version >= GR_GL_VER(3, 1)) {
946         GET_PROC(BindImageTexture);
947         GET_PROC(MemoryBarrier);
948         GET_PROC(MemoryBarrierByRegion);
949     }
950 
951     interface->fStandard = kGLES_GrGLStandard;
952     interface->fExtensions.swap(&extensions);
953 
954     return interface;
955 }
956