Refactor SkGLContext to be actually extendable

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();
-
-    virtual ~GLXGLContext();
-
+    GLXGLContext(GrGLStandard forcedGpuAPI);
+    virtual ~GLXGLContext() SK_OVERRIDE;
     virtual void makeCurrent() const SK_OVERRIDE;
     virtual void swapBuffers() const SK_OVERRIDE;
-protected:
-    virtual const GrGLInterface* createGLContext(GrGLStandard forcedGpuAPI) SK_OVERRIDE;
-    virtual void destroyGLContext() SK_OVERRIDE;
 
 private:
+    void destroyGLContext();
+
     GLXContext fContext;
     Display* fDisplay;
     Pixmap fPixmap;
     GLXPixmap fGlxPixmap;
 };
 
-GLXGLContext::GLXGLContext()
+GLXGLContext::GLXGLContext(GrGLStandard forcedGpuAPI)
     : fContext(NULL)
     , fDisplay(NULL)
     , fPixmap(0)
     , fGlxPixmap(0) {
-}
 
-GLXGLContext::~GLXGLContext() {
-    this->destroyGLContext();
-}
-
-void GLXGLContext::destroyGLContext() {
-    if (fDisplay) {
-        glXMakeCurrent(fDisplay, 0, 0);
-
-        if (fContext) {
-            glXDestroyContext(fDisplay, fContext);
-            fContext = NULL;
-        }
-
-        if (fGlxPixmap) {
-            glXDestroyGLXPixmap(fDisplay, fGlxPixmap);
-            fGlxPixmap = 0;
-        }
-
-        if (fPixmap) {
-            XFreePixmap(fDisplay, fPixmap);
-            fPixmap = 0;
-        }
-
-        XCloseDisplay(fDisplay);
-        fDisplay = NULL;
-    }
-}
-
-const GrGLInterface* GLXGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
     fDisplay = XOpenDisplay(0);
 
     if (!fDisplay) {
         SkDebugf("Failed to open X display.\n");
         this->destroyGLContext();
-        return NULL;
+        return;
     }
 
     // Get a matching FB config
     static int visual_attribs[] = {
         GLX_X_RENDERABLE    , True,
         GLX_DRAWABLE_TYPE   , GLX_PIXMAP_BIT,
         None
     };
 
     int glx_major, glx_minor;
 
     // FBConfigs were added in GLX version 1.3.
     if (!glXQueryVersion(fDisplay, &glx_major, &glx_minor) ||
             ((glx_major == 1) && (glx_minor < 3)) || (glx_major < 1)) {
         SkDebugf("GLX version 1.3 or higher required.\n");
         this->destroyGLContext();
-        return NULL;
+        return;
     }
 
     //SkDebugf("Getting matching framebuffer configs.\n");
     int fbcount;
     GLXFBConfig *fbc = glXChooseFBConfig(fDisplay, DefaultScreen(fDisplay),
                                           visual_attribs, &fbcount);
     if (!fbc) {
         SkDebugf("Failed to retrieve a framebuffer config.\n");
         this->destroyGLContext();
-        return NULL;
+        return;
     }
     //SkDebugf("Found %d matching FB configs.\n", fbcount);
 
     // Pick the FB config/visual with the most samples per pixel
     //SkDebugf("Getting XVisualInfos.\n");
     int best_fbc = -1, best_num_samp = -1;
 
     int i;
     for (i = 0; i < fbcount; ++i) {
         XVisualInfo *vi = glXGetVisualFromFBConfig(fDisplay, fbc[i]);
@@ skipping 19 matching lines @@
 
     // Get a visual
     XVisualInfo *vi = glXGetVisualFromFBConfig(fDisplay, bestFbc);
     //SkDebugf("Chosen visual ID = 0x%x\n", (unsigned int)vi->visualid);
 
     fPixmap = XCreatePixmap(fDisplay, RootWindow(fDisplay, vi->screen), 10, 10, vi->depth);
 
     if (!fPixmap) {
         SkDebugf("Failed to create pixmap.\n");
         this->destroyGLContext();
-        return NULL;
+        return;
     }
 
     fGlxPixmap = glXCreateGLXPixmap(fDisplay, vi, fPixmap);
 
     // Done with the visual info data
     XFree(vi);
 
     // Create the context
 
     // Install an X error handler so the application won't exit if GL 3.0
@@ skipping 91 matching lines @@
 
     // Sync to ensure any errors generated are processed.
     XSync(fDisplay, False);
 
     // Restore the original error handler
     XSetErrorHandler(oldHandler);
 
     if (ctxErrorOccurred || !fContext) {
         SkDebugf("Failed to create an OpenGL context.\n");
         this->destroyGLContext();
-        return NULL;
+        return;
     }
 
     // Verify that context is a direct context
     if (!glXIsDirect(fDisplay, fContext)) {
         //SkDebugf("Indirect GLX rendering context obtained.\n");
     } else {
         //SkDebugf("Direct GLX rendering context obtained.\n");
     }
 
     //SkDebugf("Making context current.\n");
     if (!glXMakeCurrent(fDisplay, fGlxPixmap, fContext)) {
       SkDebugf("Could not set the context.\n");
         this->destroyGLContext();
-        return NULL;
+        return;
     }
 
-    const GrGLInterface* interface = GrGLCreateNativeInterface();
-    if (!interface) {
+    fGL.reset(GrGLCreateNativeInterface());
+    if (NULL == fGL.get()) {
         SkDebugf("Failed to create gl interface");
         this->destroyGLContext();
-        return NULL;
+        return;
     }
-    return interface;
+
+    if (!fGL->validate()) {
+        SkDebugf("Failed to validate gl interface");
+        this->destroyGLContext();
+        return;
+    }
+}
+
+
+GLXGLContext::~GLXGLContext() {
+    this->destroyGLContext();
+}
+
+void GLXGLContext::destroyGLContext() {
+    fGL.reset(NULL);
+    if (fDisplay) {
+        glXMakeCurrent(fDisplay, 0, 0);
+
+        if (fContext) {
+            glXDestroyContext(fDisplay, fContext);
+            fContext = NULL;
+        }
+
+        if (fGlxPixmap) {
+            glXDestroyGLXPixmap(fDisplay, fGlxPixmap);
+            fGlxPixmap = 0;
+        }
+
+        if (fPixmap) {
+            XFreePixmap(fDisplay, fPixmap);
+            fPixmap = 0;
+        }
+
+        XCloseDisplay(fDisplay);
+        fDisplay = NULL;
+    }
 }
 
 void GLXGLContext::makeCurrent() const {
     if (!glXMakeCurrent(fDisplay, fGlxPixmap, fContext)) {
         SkDebugf("Could not set the context.\n");
     }
 }
 
 void GLXGLContext::swapBuffers() const {
     glXSwapBuffers(fDisplay, fGlxPixmap);
 }
 
 } // anonymous namespace
 
-SkGLContext* SkCreatePlatformGLContext() {
-    return SkNEW(GLXGLContext);
+SkGLContext* SkCreatePlatformGLContext(GrGLStandard forcedGpuAPI) {
+    GLXGLContext* ctx = SkNEW_ARGS(GLXGLContext, (forcedGpuAPI));
+    if (!ctx->isValid()) {
+        SkDELETE(ctx);
+        return NULL;
+    }
+    return ctx;
 }