Add factory class for generating various flavors of GrTextContext.

include/gpu/GrTextContext.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrTextContext_DEFINED
 #define GrTextContext_DEFINED
 
 #include "GrContext.h"
 #include "GrGlyph.h"
 #include "GrPaint.h"
 
 class GrContext;
 class GrDrawTarget;
 class GrFontScaler;
+class GrTextContext;
+
+/*
+ * These classes wrap the creation of a single text context for a given GPU device. The
+ * assumption is that we'll only be using one text context at a time for that device.
+ */
+class GrTextContextFactory {
+public:
+    virtual ~GrTextContextFactory() {}
+    virtual GrTextContext* Create(GrContext* context, const GrPaint& grPaint, 
+                          const SkPaint& skPaint) = 0;
+    virtual void Recycle(GrTextContext* textContext) = 0;
+};
+
+template <class TextContextClass>
+class GrTTextContextFactory : public GrTextContextFactory {
+public:
+    GrTTextContextFactory() {
+        fAllocation = sk_malloc_throw(sizeof(TextContextClass));
+        fUsed = false;
+    }
+    
+    ~GrTTextContextFactory() {
+        SkASSERT(!fUsed);
+        sk_free(fAllocation);
+    }
+
+    GrTextContext* Create(GrContext* context, const GrPaint& grPaint, 

[bsalomon, 2014/01/22 19:13:36]

nit: since Create and Destroy are not static they should have initial lower
case.

[jvanverth1, 2014/01/22 20:28:40]

Done.

+                          const SkPaint& skPaint) {
+        // add check for usePath here?
+        SkASSERT(!fUsed);
+        TextContextClass* obj = new(fAllocation) TextContextClass(context, grPaint, skPaint);
+        obj->fFactory = this;
+        fUsed = true;
+        return obj;
+    }
+
+    void Recycle(GrTextContext* textContext) {
+        SkASSERT((void*)textContext == fAllocation);
+        SkASSERT(fUsed);
+        fUsed = false;
+    }
+
+private:
+    void* fAllocation;
+    bool  fUsed;
+};
 
 /*
  * This class wraps the state for a single text render
  */
 class GrTextContext {
 public:
+    virtual ~GrTextContext() {}
+    
     virtual void drawPackedGlyph(GrGlyph::PackedID, GrFixed left, GrFixed top,
                                  GrFontScaler*) = 0;
-
+    
+    static void operator delete(void* ptr) throw() {

[bsalomon, 2014/01/22 19:13:36]

Do we need the throw here? We build without exceptions.

What do you think of encapsulating the delete overload within the factory?
Something like:

template <class TextContextClass>
class GrTTextContextFactory : public GrTextContextFactory {

    class ManagedTextContext : public TextContextClass {
    public:
        static void operator delete(void* ptr) throw() {
           // ...        
        }
    private:
        GrTTextContextFactory* fFactory; 
    }
    // ...
};

Aside from encapsulating the memory management in the factory, I think this
would mean that the destroy function need not be virtual since the sub-subclass
has a ptr to GrTTextContextFactory<Foo>.

[jvanverth1, 2014/01/22 20:28:40]

Done.

+        if (ptr == NULL) {
+            return;
+        }
+        GrTextContext* context = reinterpret_cast<GrTextContext*>(ptr);
+        context->fFactory->Recycle(context);
+    }
+    
 protected:
-    GrTextContext(GrContext*, const GrPaint&);
-    virtual ~GrTextContext() {}
-
+    GrTextContext(GrContext*, const GrPaint&, const SkPaint&);
+    
     GrPaint                fPaint;
+    SkPaint                fSkPaint;
     GrContext*             fContext;
     GrDrawTarget*          fDrawTarget;
-
+    
     SkIRect                fClipRect;
-
-private:
+    
+    GrTextContextFactory*  fFactory;
 };
 
 #endif