Make null GL context use callback to make current

src/gpu/gl/SkNullGLContext.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/SkNullGLContext.h"
 #include "gl/GrGLInterface.h"
 #include "GrGLDefines.h"
 #include "GrGLNoOpInterface.h"
 #include "SkTDArray.h"
 #include "SkTLS.h"
 
-static const SkNullGLContext* current_context();
+static SkNullGLContext::ContextState* current_context();
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
 class BufferObj {
 public:
     SK_DECLARE_INST_COUNT(BufferObj);
 
     BufferObj(GrGLuint id) : fID(id), fDataPtr(NULL), fSize(0), fMapped(false) {}
     ~BufferObj() { SkDELETE_ARRAY(fDataPtr); }
 
@@ skipping 81 matching lines @@
     static const intptr_t kFreeListEnd = -1;
     // Index of the first entry of fBuffers in the free list. Free slots in fBuffers are indices to
     // the next free slot. The last free slot has a value of kFreeListEnd.
     intptr_t                fFreeListHead;
     SkTDArray<BufferObj*>   fBuffers;
 };
 
 /**
  * The state object for the null interface.
  */
-struct SkNullGLContext::ContextState {
+class SkNullGLContext::ContextState : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(ContextState);
 
     BufferManager   fBufferManager;
     GrGLuint        fCurrArrayBuffer;
     GrGLuint        fCurrElementArrayBuffer;
     GrGLuint        fCurrProgramID;
     GrGLuint        fCurrShaderID;
 
 
     ContextState()
         : fCurrArrayBuffer(0)
         , fCurrElementArrayBuffer(0)
         , fCurrProgramID(0)
         , fCurrShaderID(0) {}
 
-    static ContextState* Get() {
-        const SkNullGLContext* context = current_context();
-        SkASSERT(context);
-        return context->fState;
-    }
+    static ContextState* Get() { return current_context(); }
 };
 
 typedef SkNullGLContext::ContextState State;
 
 // Functions not declared in GrGLBogusInterface.h (not common with the Debug GL interface).
 
 namespace { // added to suppress 'no previous prototype' warning
 
 GrGLvoid GR_GL_FUNCTION_TYPE nullGLActiveTexture(GrGLenum texture) {}
 GrGLvoid GR_GL_FUNCTION_TYPE nullGLAttachShader(GrGLuint program, GrGLuint shader) {}
@@ skipping 181 matching lines @@
                     *params = GR_GL_TRUE;
                 }
             }
             break; }
         default:
             SkFAIL("Unexpected pname to GetBufferParamateriv");
             break;
     }
 };
 
+class NullInterface : public GrGLInterface {
+public:
+    NullInterface(State* state) : fState(SkRef(state)) {}
+    ~NullInterface() SK_OVERRIDE {
+        fState->unref();
+    }
+    State* fState;
+};
+
 } // end anonymous namespace
 
-static const GrGLInterface* create_null_interface() {
-    GrGLInterface* interface = SkNEW(GrGLInterface);
+static GrGLInterface* create_null_interface(State* state) {
+    GrGLInterface* interface = SkNEW_ARGS(NullInterface, (state));
 
     interface->fStandard = kGL_GrGLStandard;
 
     GrGLInterface::Functions* functions = &interface->fFunctions;
     functions->fActiveTexture = nullGLActiveTexture;
     functions->fAttachShader = nullGLAttachShader;
     functions->fBeginQuery = nullGLBeginQuery;
     functions->fBindAttribLocation = nullGLBindAttribLocation;
     functions->fBindBuffer = nullGLBindBuffer;
     functions->fBindFragDataLocation = noOpGLBindFragDataLocation;
@@ skipping 127 matching lines @@
     functions->fBindFragDataLocationIndexed = noOpGLBindFragDataLocationIndexed;
 
     interface->fExtensions.init(kGL_GrGLStandard, functions->fGetString, functions->fGetStringi,
                                 functions->fGetIntegerv);
     return interface;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 static void* create_tls() {
-    const SkNullGLContext** current = SkNEW(const SkNullGLContext*);
+    State** current = SkNEW(State*);
     *current = NULL;
     return current;
 }
 
 static void delete_tls(void* ctx) {
-    const SkNullGLContext** current = static_cast<const SkNullGLContext**>(ctx);
+    State** current = static_cast<State**>(ctx);
     if (*current) {
         (*current)->unref();
     }
     SkDELETE(current);
 }
 
-static const SkNullGLContext* current_context() {
-    return *static_cast<const SkNullGLContext**>(SkTLS::Get(create_tls, delete_tls));
+static State* current_context() {
+    return *static_cast<State**>(SkTLS::Get(create_tls, delete_tls));
 }
 
-static void set_current_context(const SkNullGLContext* context) {
-    const SkNullGLContext** current =
-        static_cast<const SkNullGLContext**>(SkTLS::Get(create_tls, delete_tls));
+static void set_current_context(State* state) {
+    State** current = static_cast<State**>(SkTLS::Get(create_tls, delete_tls));
     if (*current) {
         (*current)->unref();
     }
-    *current = context;
-    if (context) {
-        context->ref();
+    *current = state;
+    if (state) {
+        state->ref();
     }
 }
 
+#if GR_GL_PER_GL_FUNC_CALLBACK
+static void set_current_context_from_interface(const GrGLInterface* interface) {
+    set_current_context(reinterpret_cast<State*>(interface->fCallbackData));
+}
+#endif
+
 SkNullGLContext* SkNullGLContext::Create(GrGLStandard forcedGpuAPI) {
     if (kGLES_GrGLStandard == forcedGpuAPI) {
         return NULL;
     }
     SkNullGLContext* ctx = SkNEW(SkNullGLContext);
     if (!ctx->isValid()) {
         SkDELETE(ctx);
         return NULL;
     }
     return ctx;
 }
 
 SkNullGLContext::SkNullGLContext() {
-    fGL.reset(create_null_interface());
     fState = SkNEW(ContextState);
+    GrGLInterface* interface = create_null_interface(fState);
+    fGL.reset(interface);
+#if GR_GL_PER_GL_FUNC_CALLBACK
+    interface->fCallback = set_current_context_from_interface;
+    interface->fCallbackData = reinterpret_cast<GrGLInterfaceCallbackData>(fState);
+#endif
 }
 
 SkNullGLContext::~SkNullGLContext() {
     fGL.reset(NULL);
-    SkDELETE(fState);
+    fState->unref();
 }
 
-void SkNullGLContext::makeCurrent() const { set_current_context(this); }
+void SkNullGLContext::makeCurrent() const { set_current_context(fState); }