Use glGetStringi to get extensions when available.

src/gpu/gl/GrGLExtensions.cpp

Index: src/gpu/gl/GrGLExtensions.cpp
===================================================================
--- src/gpu/gl/GrGLExtensions.cpp	(revision 0)
+++ src/gpu/gl/GrGLExtensions.cpp	(revision 0)
@@ -0,0 +1,77 @@
+/*
+ * 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 "gl/GrGLExtensions.h"
+#include "gl/GrGLDefines.h"
+#include "gl/GrGLUtil.h"
+
+bool GrGLExtensions::init(GrGLBinding binding,
+                          GrGLGetStringProc getString,
+                          GrGLGetStringiProc getStringi,

[robertphillips, 2013/02/26 21:06:07]

getIntegerv?

[bsalomon, 2013/02/26 21:32:51]

Done.

+                          GrGLGetIntegervProc getIntegeriv) {
+    fStrings.reset();
+    if (NULL == getString) {
+        return false;
+    }
+    bool indexed = false;
+    if (kDesktop_GrGLBinding == binding) {
+        const GrGLubyte* verString = getString(GR_GL_VERSION);
+        if (NULL == verString) {
+            return false;
+        }
+        GrGLVersion version = GrGLGetVersionFromString((const char*) verString);
+        indexed = version >= GR_GL_VER(3, 0);
+    }
+    if (indexed) {
+        if (NULL == getStringi || NULL == getIntegeriv) {
+            return false;
+        }
+        GrGLint extensionCnt = 0;
+        getIntegeriv(GR_GL_NUM_EXTENSIONS, &extensionCnt);
+        fStrings.push_back_n(extensionCnt);
+        for (int i = 0; i < extensionCnt; ++i) {
+            const char* ext = (const char*) getStringi(GR_GL_EXTENSIONS, i);
+            fStrings[i] = ext;
+        }
+    } else {
+        const char* extensions = (const char*) getString(GR_GL_EXTENSIONS);

[Jvsquare, 2013/02/26 21:33:39]

Not a huge deal since it's in an init function, but it'd be nice if this scanned
the extension string only once.

[bsalomon, 2013/02/26 21:38:46]

True... I was thinking that the initial scan to get the size would be cheaper
than having multiple malloc calls while building the stretchy array. I suppose I
should at least comment on that. 

+        if (NULL == extensions) {
+            return false;
+        }
+        int extensionCnt = 1;
+        const char* e = (const char*) extensions;
+        while (NULL != (e = strchr(e+1, ' '))) {
+            e += 1;
+            ++extensionCnt;
+        }
+        fStrings.push_back_n(extensionCnt);
+        int i = 0;
+        while (true) {
+            size_t length = strcspn(extensions, " ");
+            GrAssert(i < extensionCnt);
+            fStrings[i].set(extensions, length);
+            ++i;
+            if ('\0' == extensions[length]) {
+                break;
+            }
+            extensions += length + 1;
+        }
+        GrAssert(i == extensionCnt);
+    }
+    return true;
+}
+
+bool GrGLExtensions::has(const char* ext) const {
+    // TODO: Sort the extensions and binary search.
+    int count = fStrings.count();
+    for (int i = 0; i < count; ++i) {
+        if (fStrings[i].equals(ext)) {
+            return true;
+        }
+    }
+    return false;
+}