Add standalone drawText for 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"
 
 #include "SkPostConfig.h"
 
-class GrContext;
+class SkGpuDevice;
 class GrDrawTarget;
 class GrFontScaler;
 
 /*
  * 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;
+    virtual void drawText(const char text[], size_t byteLength, SkScalar x, SkScalar y) = 0;
+    virtual void drawPosText(const char text[], size_t byteLength,
+                             const SkScalar pos[], SkScalar constY,
+                             int scalarsPerPosition) = 0;
 
 protected:
-    GrTextContext(GrContext*, const GrPaint&, const SkPaint&);
+    GrTextContext(SkGpuDevice*, const GrPaint&, const SkPaint&);
 
+    static GrFontScaler* GetGrFontScaler(SkGlyphCache* cache);
+    static void MeasureText(SkGlyphCache* cache, SkDrawCacheProc glyphCacheProc,
+                            const char text[], size_t byteLength, SkVector* stopVector);
+    
     GrPaint                fPaint;
     SkPaint                fSkPaint;
-    GrContext*             fContext;
+    SkGpuDevice*           fDevice;
     GrDrawTarget*          fDrawTarget;
 
     SkIRect                fClipRect;
 };
 
 /*
  * 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 GrTextContextManager {
 public:
     virtual ~GrTextContextManager() {}
-    virtual GrTextContext* create(GrContext* context, const GrPaint& grPaint,
+    virtual GrTextContext* create(SkGpuDevice* device, const GrPaint& grPaint,
                                   const SkPaint& skPaint) = 0;
 };
 
 template <class TextContextClass>
 class GrTTextContextManager : public GrTextContextManager {
 private:
     class ManagedTextContext : public TextContextClass {
     public:
         ~ManagedTextContext() {}
 
-        ManagedTextContext(GrContext* context,
+        ManagedTextContext(SkGpuDevice* device,

[bsalomon, 2014/01/27 21:51:25]

Is this just to get at the device properties? I'd like to somehow encapsulate
just what is necessary. device has a lot of functions that I don't think we'd
want a text context subclass to call.

[jvanverth1, 2014/01/28 18:05:33]

Done.

                            const GrPaint& grPaint,
                            const SkPaint& skPaint,
                            GrTTextContextManager<TextContextClass>* manager) :
-        TextContextClass(context, grPaint, skPaint) {
+                          TextContextClass(device, grPaint, skPaint) {
             fManager = manager;
         }
 
         static void operator delete(void* ptr) {
             if (ptr == NULL) {
                 return;
             }
             ManagedTextContext* context = reinterpret_cast<ManagedTextContext*>(ptr);
             context->fManager->recycle(context);
         }
 
         static void operator delete(void*, void*) {
         }
 
         GrTTextContextManager<TextContextClass>* fManager;
     };
 
 public:
     GrTTextContextManager() {
         fAllocation = sk_malloc_throw(sizeof(ManagedTextContext));
         fUsed = false;
     }
 
     ~GrTTextContextManager() {
         SkASSERT(!fUsed);
         sk_free(fAllocation);
     }
 
-    GrTextContext* create(GrContext* context, const GrPaint& grPaint,
+    GrTextContext* create(SkGpuDevice* device, const GrPaint& grPaint,
                           const SkPaint& skPaint) {
         // add check for usePath here?
         SkASSERT(!fUsed);
         ManagedTextContext* obj = SkNEW_PLACEMENT_ARGS(fAllocation, ManagedTextContext,
-                                                       (context, grPaint, skPaint, this));
+                                                       (device, grPaint, skPaint, this));
         fUsed = true;
         return obj;
     }
 
 private:
     void recycle(GrTextContext* textContext) {
         SkASSERT((void*)textContext == fAllocation);
         SkASSERT(fUsed);
         fUsed = false;
     }
 
     void* fAllocation;
     bool  fUsed;
 };
 
 #endif