Add support for EGLImage to GrGLInterface

src/gpu/gl/GrGLExtensions.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 "gl/GrGLExtensions.h"
 #include "gl/GrGLDefines.h"
 #include "gl/GrGLUtil.h"
@@ skipping 23 matching lines @@
 GrGLExtensions::GrGLExtensions(const GrGLExtensions& that) : fStrings(new SkTArray<SkString>) {
     *this = that;
 }
 
 GrGLExtensions& GrGLExtensions::operator=(const GrGLExtensions& that) {
     *fStrings = *that.fStrings;
     fInitialized = that.fInitialized;
     return *this;
 }
 
+static void eat_space_sep_strings(SkTArray<SkString>* out, const char in[]) {
+    if (!in) {
+        return;
+    }
+    while (true) {
+        // skip over multiple spaces between extensions
+        while (' ' == *in) {
+            ++in;
+        }
+        // quit once we reach the end of the string.
+        if ('\0' == *in) {
+            break;
+        }
+        // we found an extension
+        size_t length = strcspn(in, " ");
+        out->push_back().set(in, length);
+        in += length;
+    }
+}
+
 bool GrGLExtensions::init(GrGLStandard standard,
                           GrGLGetStringProc getString,
                           GrGLGetStringiProc getStringi,
-                          GrGLGetIntegervProc getIntegerv) {
+                          GrGLGetIntegervProc getIntegerv,
+                          GrEGLQueryStringProc queryString,
+                          GrEGLDisplay eglDisplay) {
     fInitialized = false;
     fStrings->reset();
 
-    if (nullptr == getString) {
+    if (!getString) {
         return false;
     }
 
     // glGetStringi and indexed extensions were added in version 3.0 of desktop GL and ES.
     const GrGLubyte* verString = getString(GR_GL_VERSION);
     GrGLVersion version = GrGLGetVersionFromString((const char*) verString);
     if (GR_GL_INVALID_VER == version) {
         return false;
     }
 
     bool indexed = version >= GR_GL_VER(3, 0);
 
     if (indexed) {
-        if (nullptr == getStringi || nullptr == getIntegerv) {
+        if (!getStringi || !getIntegerv) {
             return false;
         }
         GrGLint extensionCnt = 0;
         getIntegerv(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);
-        if (nullptr == extensions) {
+        if (!extensions) {
             return false;
         }
-        while (true) {
-            // skip over multiple spaces between extensions
-            while (' ' == *extensions) {
-                ++extensions;
-            }
-            // quit once we reach the end of the string.
-            if ('\0' == *extensions) {
-                break;
-            }
-            // we found an extension
-            size_t length = strcspn(extensions, " ");
-            fStrings->push_back().set(extensions, length);
-            extensions += length;
-        }
+        eat_space_sep_strings(fStrings, extensions);
+    }
+    if (queryString) {
+        const char* extensions = queryString(eglDisplay, GR_EGL_EXTENSIONS);
+
+        eat_space_sep_strings(fStrings, extensions);
     }
     if (!fStrings->empty()) {
         SkTLessFunctionToFunctorAdaptor<SkString, extension_compare> cmp;
         SkTQSort(&fStrings->front(), &fStrings->back(), cmp);
     }
     fInitialized = true;
     return true;
 }
 
 bool GrGLExtensions::has(const char ext[]) const {
@@ skipping 30 matching lines @@
 
 void GrGLExtensions::print(const char* sep) const {
     if (nullptr == sep) {
         sep = " ";
     }
     int cnt = fStrings->count();
     for (int i = 0; i < cnt; ++i) {
         SkDebugf("%s%s", (*fStrings)[i].c_str(), (i < cnt - 1) ? sep : "");
     }
 }