Use glGetStringi to get extensions when available.

src/gpu/gl/GrGLNoOpInterface.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLNoOpInterface.h"
+#include "SkString.h"
+#include "SkThread.h"
 
 // the OpenGLES 2.0 spec says this must be >= 128
 static const GrGLint kDefaultMaxVertexUniformVectors = 128;
 
 // the OpenGLES 2.0 spec says this must be >=16
 static const GrGLint kDefaultMaxFragmentUniformVectors = 16;
 
 // the OpenGLES 2.0 spec says this must be >= 8
 static const GrGLint kDefaultMaxVertexAttribs = 8;
 
 // the OpenGLES 2.0 spec says this must be >= 8
 static const GrGLint kDefaultMaxVaryingVectors = 8;
 
+static const char* kExtensions[] = {
+    "GL_ARB_framebuffer_object",
+    "GL_ARB_blend_func_extended",
+    "GL_ARB_timer_query",
+    "GL_ARB_draw_buffers",
+    "GL_ARB_occlusion_query",
+    "GL_EXT_blend_color",
+    "GL_EXT_stencil_wrap"
+};
+
+namespace {
+const GrGLubyte* combined_extensions_string() {
+    static SkString gExtString;
+    static SkMutex gMutex;
+    gMutex.acquire();
+    if (0 == gExtString.size()) {
+        for (size_t i = 0; i < GR_ARRAY_COUNT(kExtensions) - 1; ++i) {
+            gExtString.append(kExtensions[i]);
+            gExtString.append(" ");
+        }
+        gExtString.append(kExtensions[GR_ARRAY_COUNT(kExtensions) - 1]);
+    }
+    gMutex.release();
+    return (const GrGLubyte*) gExtString.c_str();
+}
+}
+
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlendColor(GrGLclampf red,
                                               GrGLclampf green,
                                               GrGLclampf blue,
                                               GrGLclampf alpha) {
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBindFragDataLocation(GrGLuint program,
                                                         GrGLuint colorNumber,
                                                         const GrGLchar* name) {
 }
@@ skipping 14 matching lines @@
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClearColor(GrGLclampf red,
                                               GrGLclampf green,
                                               GrGLclampf blue,
                                               GrGLclampf alpha) {
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClearStencil(GrGLint s) {
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLColorMask(GrGLboolean red,
-                                              GrGLboolean green,
-                                              GrGLboolean blue,
-                                              GrGLboolean alpha) {
+                                             GrGLboolean green,
+                                             GrGLboolean blue,
+                                             GrGLboolean alpha) {
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompileShader(GrGLuint shader) {
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompressedTexImage2D(GrGLenum target,
                                                         GrGLint level,
                                                         GrGLenum internalformat,
                                                         GrGLsizei width,
                                                         GrGLsizei height,
@@ skipping 56 matching lines @@
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLinkProgram(GrGLuint program) {
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLQueryCounter(GrGLuint id, GrGLenum target) {
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLReadBuffer(GrGLenum src) {
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLScissor(GrGLint x,
-                                            GrGLint y,
-                                            GrGLsizei width,
-                                            GrGLsizei height) {
+                                           GrGLint y,
+                                           GrGLsizei width,
+                                           GrGLsizei height) {
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLShaderSource(GrGLuint shader,
                                                 GrGLsizei count,
 #if GR_USE_NEW_GL_SHADER_SOURCE_SIGNATURE
                                                 const char* const * str,
 #else
                                                 const char** str,
 #endif
                                                 const GrGLint* length) {
@@ skipping 163 matching lines @@
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttribPointer(GrGLuint indx,
                                                        GrGLint size,
                                                        GrGLenum type,
                                                        GrGLboolean normalized,
                                                        GrGLsizei stride,
                                                        const GrGLvoid* ptr) {
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLViewport(GrGLint x,
-                                             GrGLint y,
-                                             GrGLsizei width,
-                                             GrGLsizei height) {
+                                            GrGLint y,
+                                            GrGLsizei width,
+                                            GrGLsizei height) {
 }
 
   GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetFramebufferAttachmentParameteriv(GrGLenum target,
-                                                                        GrGLenum attachment,
-                                                                        GrGLenum pname,
-                                                                        GrGLint* params) {
+                                                                         GrGLenum attachment,
+                                                                         GrGLenum pname,
+                                                                         GrGLint* params) {
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetRenderbufferParameteriv(GrGLenum target,
                                                               GrGLenum pname,
                                                               GrGLint* params) {
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLRenderbufferStorage(GrGLenum target,
                                                        GrGLenum internalformat,
                                                        GrGLsizei width,
@@ skipping 46 matching lines @@
 }
 
 GrGLenum GR_GL_FUNCTION_TYPE noOpGLGetError() {
     return GR_GL_NO_ERROR;
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetIntegerv(GrGLenum pname, GrGLint* params) {
     // TODO: remove from Ganesh the #defines for gets we don't use.
     // We would like to minimize gets overall due to performance issues
     switch (pname) {
+        case GR_GL_CONTEXT_PROFILE_MASK:
+            *params = GR_GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
+            break;
         case GR_GL_STENCIL_BITS:
             *params = 8;
             break;
         case GR_GL_SAMPLES:
             *params = 1;
             break;
         case GR_GL_FRAMEBUFFER_BINDING:
             *params = 0;
             break;
         case GR_GL_VIEWPORT:
@@ skipping 27 matching lines @@
             break;
         case GR_GL_MAX_SAMPLES:
             *params = 32;
             break;
         case GR_GL_MAX_VERTEX_ATTRIBS:
             *params = kDefaultMaxVertexAttribs;
             break;
         case GR_GL_MAX_VARYING_VECTORS:
             *params = kDefaultMaxVaryingVectors;
             break;
+        case GR_GL_NUM_EXTENSIONS:
+            *params = GR_ARRAY_COUNT(kExtensions);
+            break;
         default:
             GrCrash("Unexpected pname to GetIntegerv");
    }
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetInfoLog(GrGLuint program,
                                               GrGLsizei bufsize,
                                               GrGLsizei* length,
-                                               char* infolog) {
+                                              char* infolog) {
     if (length) {
         *length = 0;
    }
     if (bufsize > 0) {
         *infolog = 0;
    }
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetShaderOrProgramiv(GrGLuint program,
                                                         GrGLenum pname,
@@ skipping 65 matching lines @@
 
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectuiv(GrGLuint id,
                                                      GrGLenum pname,
                                                      GrGLuint *params) {
     query_result(id, pname, params);
 }
 
 const GrGLubyte* GR_GL_FUNCTION_TYPE noOpGLGetString(GrGLenum name) {
     switch (name) {
         case GR_GL_EXTENSIONS:
-            return (const GrGLubyte*)"GL_ARB_framebuffer_object GL_ARB_blend_func_extended GL_ARB_timer_query GL_ARB_draw_buffers GL_ARB_occlusion_query GL_EXT_blend_color GL_EXT_stencil_wrap";
+            return combined_extensions_string();
         case GR_GL_VERSION:
             return (const GrGLubyte*)"4.0 Debug GL";
         case GR_GL_SHADING_LANGUAGE_VERSION:
             return (const GrGLubyte*)"4.20.8 Debug GLSL";
         case GR_GL_VENDOR:
             return (const GrGLubyte*)"Debug Vendor";
         case GR_GL_RENDERER:
             return (const GrGLubyte*)"The Debug (Non-)Renderer";
         default:
-            GrCrash("Unexpected name to GetString");
+            GrCrash("Unexpected name passed to GetString");
             return NULL;
    }
 }
 
+const GrGLubyte* GR_GL_FUNCTION_TYPE noOpGLGetStringi(GrGLenum name, GrGLuint i) {
+    switch (name) {
+        case GR_GL_EXTENSIONS:
+            if (static_cast<size_t>(i) <= GR_ARRAY_COUNT(kExtensions)) {
+                return (const GrGLubyte*) kExtensions[i];
+            } else {
+                return NULL;
+            }
+        default:
+            GrCrash("Unexpected name passed to GetStringi");
+            return NULL;
+    }
+}
+
 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetTexLevelParameteriv(GrGLenum target,
                                                           GrGLint level,
                                                           GrGLenum pname,
                                                           GrGLint* params) {
     // we used to use this to query stuff about externally created textures,
     // now we just require clients to tell us everything about the texture.
     GrCrash("Should never query texture parameters.");
 }
 
-GrGLint GR_GL_FUNCTION_TYPE noOpGLGetUniformLocation(GrGLuint program,
-                                                     const char* name) {
+GrGLint GR_GL_FUNCTION_TYPE noOpGLGetUniformLocation(GrGLuint program, const char* name) {
     static int gUniLocation = 0;
     return ++gUniLocation;
 }