Refactor SkGLContext to be actually extendable

src/gpu/gl/egl/SkCreatePlatformGLContext_egl.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 <GLES2/gl2.h>
 #include <EGL/egl.h>
 
 namespace {
 
 class EGLGLContext : public SkGLContext  {
 public:
-    EGLGLContext();
-
-    virtual ~EGLGLContext();
-
+    EGLGLContext(GrGLStandard forcedGpuAPI);
+    virtual ~EGLGLContext() 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();
+
     EGLContext fContext;
     EGLDisplay fDisplay;
     EGLSurface fSurface;
 };
 
-EGLGLContext::EGLGLContext()
+EGLGLContext::EGLGLContext(GrGLStandard forcedGpuAPI)
     : fContext(EGL_NO_CONTEXT)
     , fDisplay(EGL_NO_DISPLAY)
     , fSurface(EGL_NO_SURFACE) {
-}
-
-EGLGLContext::~EGLGLContext() {
-    this->destroyGLContext();
-}
-
-void EGLGLContext::destroyGLContext() {
-    if (fDisplay) {
-        eglMakeCurrent(fDisplay, 0, 0, 0);
-
-        if (fContext) {
-            eglDestroyContext(fDisplay, fContext);
-            fContext = EGL_NO_CONTEXT;
-        }
-
-        if (fSurface) {
-            eglDestroySurface(fDisplay, fSurface);
-            fSurface = EGL_NO_SURFACE;
-        }
-
-        //TODO should we close the display?
-        fDisplay = EGL_NO_DISPLAY;
-    }
-}
-
-const GrGLInterface* EGLGLContext::createGLContext(GrGLStandard forcedGpuAPI) {
     static const EGLint kEGLContextAttribsForOpenGL[] = {
         EGL_NONE
     };
 
     static const EGLint kEGLContextAttribsForOpenGLES[] = {
         EGL_CONTEXT_CLIENT_VERSION, 2,
         EGL_NONE
     };
 
     static const struct {
@@ skipping 18 matching lines @@
 
     size_t apiLimit = SK_ARRAY_COUNT(kAPIs);
     size_t api = 0;
     if (forcedGpuAPI == kGL_GrGLStandard) {
         apiLimit = 1;
     } else if (forcedGpuAPI == kGLES_GrGLStandard) {
         api = 1;
     }
     SkASSERT(forcedGpuAPI == kNone_GrGLStandard || kAPIs[api].fStandard == forcedGpuAPI);
 
-    const GrGLInterface* interface = NULL;
-
-    for (; NULL == interface && api < apiLimit; ++api) {
+    for (; NULL == fGL.get() && api < apiLimit; ++api) {
         fDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
 
         EGLint majorVersion;
         EGLint minorVersion;
         eglInitialize(fDisplay, &majorVersion, &minorVersion);
 
 #if 0
         SkDebugf("VENDOR: %s\n", eglQueryString(fDisplay, EGL_VENDOR));
         SkDebugf("APIS: %s\n", eglQueryString(fDisplay, EGL_CLIENT_APIS));
         SkDebugf("VERSION: %s\n", eglQueryString(fDisplay, EGL_VERSION));
@@ skipping 39 matching lines @@
             this->destroyGLContext();
             continue;
         }
 
         if (!eglMakeCurrent(fDisplay, fSurface, fSurface, fContext)) {
             SkDebugf("eglMakeCurrent failed.  EGL Error: 0x%08x\n", eglGetError());
             this->destroyGLContext();
             continue;
         }
 
-        interface = GrGLCreateNativeInterface();
-        if (NULL == interface) {
+        fGL.reset(GrGLCreateNativeInterface());
+        if (NULL == fGL.get()) {
             SkDebugf("Failed to create gl interface.\n");
             this->destroyGLContext();
             continue;
         }
 
-        if (!interface->validate()) {
-            interface->unref();
-            interface = NULL;
+        if (!fGL->validate()) {
+            SkDebugf("Failed to validate gl interface.\n");
             this->destroyGLContext();
+            continue;
         }
     }
+}
 
-    return interface;
+EGLGLContext::~EGLGLContext() {
+    this->destroyGLContext();
 }
 
+void EGLGLContext::destroyGLContext() {
+    fGL.reset(NULL);
+    if (fDisplay) {
+        eglMakeCurrent(fDisplay, 0, 0, 0);
+
+        if (fContext) {
+            eglDestroyContext(fDisplay, fContext);
+            fContext = EGL_NO_CONTEXT;
+        }
+
+        if (fSurface) {
+            eglDestroySurface(fDisplay, fSurface);
+            fSurface = EGL_NO_SURFACE;
+        }
+
+        //TODO should we close the display?
+        fDisplay = EGL_NO_DISPLAY;
+    }
+}
+
+
 void EGLGLContext::makeCurrent() const {
     if (!eglMakeCurrent(fDisplay, fSurface, fSurface, fContext)) {
         SkDebugf("Could not set the context.\n");
     }
 }
 
 void EGLGLContext::swapBuffers() const {
     if (!eglSwapBuffers(fDisplay, fSurface)) {
         SkDebugf("Could not complete eglSwapBuffers.\n");
     }
 }
 
 } // anonymous namespace
 
-SkGLContext* SkCreatePlatformGLContext() {
-    return SkNEW(EGLGLContext);
+SkGLContext* SkCreatePlatformGLContext(GrGLStandard forcedGpuAPI) {
+    EGLGLContext* ctx = SkNEW_ARGS(EGLGLContext, (forcedGpuAPI));
+    if (!ctx->isValid()) {
+        SkDELETE(ctx);
+        return NULL;
+    }
+    return ctx;
 }