Add ability to wire up sharelist in glcontext creation

src/gpu/gl/glx/SkCreatePlatformGLContext_glx.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "gl/SkGLContext.h"
 
 #include <X11/Xlib.h>
@@ skipping 28 matching lines @@
 #define NUM_GL_VERSIONS SK_ARRAY_COUNT(gl_versions)
 
 static bool ctxErrorOccurred = false;
 static int ctxErrorHandler(Display *dpy, XErrorEvent *ev) {
     ctxErrorOccurred = true;
     return 0;
 }
 
 class GLXGLContext : public SkGLContext {
 public:
-    GLXGLContext(GrGLStandard forcedGpuAPI);
+    GLXGLContext(GrGLStandard forcedGpuAPI, GLXGLContext* shareList);
     ~GLXGLContext() override;
 
 private:
     void destroyGLContext();
 
     void onPlatformMakeCurrent() const override;
     void onPlatformSwapBuffers() const override;
     GrGLFuncPtr onPlatformGetProcAddress(const char*) const override;
 
     GLXContext fContext;
     Display* fDisplay;
     Pixmap fPixmap;
     GLXPixmap fGlxPixmap;
 };
 
-GLXGLContext::GLXGLContext(GrGLStandard forcedGpuAPI)
+GLXGLContext::GLXGLContext(GrGLStandard forcedGpuAPI, GLXGLContext* shareContext)
     : fContext(nullptr)
     , fDisplay(nullptr)
     , fPixmap(0)
     , fGlxPixmap(0) {
+    fDisplay = XOpenDisplay(0);
 
-    fDisplay = XOpenDisplay(0);
+    GLXContext glxShareContext = shareContext ? shareContext->fContext : nullptr;
 
     if (!fDisplay) {
         SkDebugf("Failed to open X display.\n");
         this->destroyGLContext();
         return;
     }
 
     // Get a matching FB config
     static int visual_attribs[] = {
         GLX_X_RENDERABLE    , True,
@@ skipping 100 matching lines @@
         if (kGLES_GrGLStandard == forcedGpuAPI) {
             if (gluCheckExtension(
                     reinterpret_cast<const GLubyte*>("GLX_EXT_create_context_es2_profile"),
                     reinterpret_cast<const GLubyte*>(glxExts))) {
                 static const int context_attribs_gles[] = {
                     GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
                     GLX_CONTEXT_MINOR_VERSION_ARB, 0,
                     GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_ES2_PROFILE_BIT_EXT,
                     None
                 };
-                fContext = glXCreateContextAttribsARB(fDisplay, bestFbc, 0, True,
+                fContext = glXCreateContextAttribsARB(fDisplay, bestFbc, glxShareContext, True,
                                                       context_attribs_gles);
             }
         } else {
             // Well, unfortunately GLX will not just give us the highest context so instead we have
             // to do this nastiness
             for (i = NUM_GL_VERSIONS - 2; i > 0 ; i--) {
                 /* don't bother below GL 3.0 */
                 if (gl_versions[i].major == 3 && gl_versions[i].minor == 0) {
                     break;
                 }
                 // On Nvidia GPUs, to use Nv Path rendering we need a compatibility profile for the
                 // time being.
                 // TODO when Nvidia implements NVPR on Core profiles, we should start requesting
                 // core here
                 static const int context_attribs_gl[] = {
                       GLX_CONTEXT_MAJOR_VERSION_ARB, gl_versions[i].major,
                       GLX_CONTEXT_MINOR_VERSION_ARB, gl_versions[i].minor,
                       GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
                       None
                 };
                 fContext =
-                        glXCreateContextAttribsARB(fDisplay, bestFbc, 0, True, context_attribs_gl);
+                        glXCreateContextAttribsARB(fDisplay, bestFbc, glxShareContext, True,
+                                                   context_attribs_gl);
 
                 // Sync to ensure any errors generated are processed.
                 XSync(fDisplay, False);
 
                 if (!ctxErrorOccurred && fContext) {
                     break;
                 }
                 // try again
                 ctxErrorOccurred = false;
             }
 
             // Couldn't create GL 3.0 context.
             // Fall back to old-style 2.x context.
             // When a context version below 3.0 is requested,
             // implementations will return the newest context version
             // compatible with OpenGL versions less than version 3.0.
             if (ctxErrorOccurred || !fContext) {
                 static const int context_attribs_gl_fallback[] = {
                     GLX_CONTEXT_MAJOR_VERSION_ARB, 1,
                     GLX_CONTEXT_MINOR_VERSION_ARB, 0,
                     None
                 };
 
                 ctxErrorOccurred = false;
 
-                fContext = glXCreateContextAttribsARB(fDisplay, bestFbc, 0, True,
+                fContext = glXCreateContextAttribsARB(fDisplay, bestFbc, glxShareContext, True,
                                                       context_attribs_gl_fallback);
             }
         }
     }
 
     // Sync to ensure any errors generated are processed.
     XSync(fDisplay, False);
 
     // Restore the original error handler
     XSetErrorHandler(oldHandler);
@@ skipping 73 matching lines @@
 void GLXGLContext::onPlatformSwapBuffers() const {
     glXSwapBuffers(fDisplay, fGlxPixmap);
 }
 
 GrGLFuncPtr GLXGLContext::onPlatformGetProcAddress(const char* procName) const {
     return glXGetProcAddress(reinterpret_cast<const GLubyte*>(procName));
 }
 
 } // anonymous namespace
 
-SkGLContext* SkCreatePlatformGLContext(GrGLStandard forcedGpuAPI) {
-    GLXGLContext *ctx = new GLXGLContext(forcedGpuAPI);
+SkGLContext* SkCreatePlatformGLContext(GrGLStandard forcedGpuAPI, SkGLContext* shareContext) {
+    GLXGLContext* glxShareContext = reinterpret_cast<GLXGLContext*>(shareContext);
+    GLXGLContext *ctx = new GLXGLContext(forcedGpuAPI, glxShareContext);
     if (!ctx->isValid()) {
         delete ctx;
         return nullptr;
     }
     return ctx;
 }