Adding a cache + memory pool for GPU TextBlobs

src/gpu/GrAtlasTextContext.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrAtlasTextContext_DEFINED
 #define GrAtlasTextContext_DEFINED
 
 #include "GrTextContext.h"
 
 #include "GrBatchAtlas.h"
 #include "GrGeometryProcessor.h"
 #include "SkDescriptor.h"
+#include "GrMemoryPool.h"
 #include "SkTextBlob.h"
-#include "SkTHash.h"
+#include "SkTInternalLList.h"
 
 class GrBatchTextStrike;
 class GrPipelineBuilder;
+class GrTextBlobCache;
 
 /*
  * This class implements GrTextContext using standard bitmap fonts, and can also process textblobs.
  * TODO replace GrBitmapTextContext
  */
 class GrAtlasTextContext : public GrTextContext {
 public:
     static GrAtlasTextContext* Create(GrContext*, SkGpuDevice*, const SkDeviceProperties&);
 
-    virtual ~GrAtlasTextContext();
-
 private:
     GrAtlasTextContext(GrContext*, SkGpuDevice*, const SkDeviceProperties&);
 
     bool canDraw(const GrRenderTarget*, const GrClip&, const GrPaint&,
                  const SkPaint&, const SkMatrix& viewMatrix) override;
 
     void onDrawText(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&,
                     const SkMatrix& viewMatrix, const char text[], size_t byteLength,
                     SkScalar x, SkScalar y, const SkIRect& regionClipBounds) override;
     void onDrawPosText(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&,
@@ skipping 10 matching lines @@
      * on the GPU.  These are initially created with valid positions and colors, but invalid
      * texture coordinates.  The BitmapTextBlob itself has a few Blob-wide properties, and also
      * consists of a number of runs.  Runs inside a blob are flushed individually so they can be
      * reordered.
      *
      * The only thing(aside from a memcopy) required to flush a BitmapTextBlob is to ensure that
      * the GrAtlas will not evict anything the Blob needs.
      * TODO this is currently a bug
      */
     struct BitmapTextBlob : public SkRefCnt {
+        SK_DECLARE_INTERNAL_LLIST_INTERFACE(BitmapTextBlob);
+
         /*
          * Each Run inside of the blob can have its texture coordinates regenerated if required.
          * To determine if regeneration is necessary, fAtlasGeneration is used.  If there have been
          * any evictions inside of the atlas, then we will simply regenerate Runs.  We could track
          * this at a more fine grained level, but its not clear if this is worth it, as evictions
          * should be fairly rare.
          *
          * One additional point, each run can contain glyphs with any of the three mask formats.
          * We call these SubRuns.  Because a subrun must be a contiguous range, we have to create
          * a new subrun each time the mask format changes in a run.  In theory, a run can have as
@@ skipping 49 matching lines @@
             int fVx;
             int fVy;
         };
 
         SkTArray<BigGlyph> fBigGlyphs;
         SkMatrix fViewMatrix;
         SkScalar fX;
         SkScalar fY;
         SkPaint::Style fStyle;
         int fRunCount;
+        uint32_t fUniqueID;
+        GrMemoryPool* fPool;
 
         // all glyph / vertex offsets are into these pools.
         unsigned char* fVertices;
         GrGlyph::PackedID* fGlyphIDs;
         Run* fRuns;
 
+        static const uint32_t& GetKey(const BitmapTextBlob& blob) {
+            return blob.fUniqueID;
+        }
+
         static uint32_t Hash(const uint32_t& key) {
             return SkChecksum::Mix(key);
         }
 
-        void operator delete(void* p) { sk_free(p); }
+        void operator delete(void* p) {
+            BitmapTextBlob* blob = reinterpret_cast<BitmapTextBlob*>(p);
+            blob->fPool->release(p);
+        }
         void* operator new(size_t) {
             SkFAIL("All blobs are created by placement new.");
             return sk_malloc_throw(0);
         }
 
         void* operator new(size_t, void* p) { return p; }
         void operator delete(void* target, void* placement) {
             ::operator delete(target, placement);
         }
     };
 
     typedef BitmapTextBlob::Run Run;
     typedef Run::SubRunInfo PerSubRunInfo;
 
-    BitmapTextBlob* CreateBlob(int glyphCount, int runCount);
-
     void appendGlyph(BitmapTextBlob*, int runIndex, GrGlyph::PackedID, int left, int top,
                      GrColor color, GrFontScaler*, const SkIRect& clipRect);
 
     inline void flushRunAsPaths(const SkTextBlob::RunIterator&, const SkPaint&, SkDrawFilter*,
                                 const SkMatrix& viewMatrix, const SkIRect& clipBounds, SkScalar x,
                                 SkScalar y);
     inline void flushRun(GrDrawTarget*, GrPipelineBuilder*, BitmapTextBlob*, int run, GrColor,
                          uint8_t paintAlpha);
     inline void flushBigGlyphs(BitmapTextBlob* cacheBlob, GrRenderTarget* rt,
                                const GrPaint& grPaint, const GrClip& clip);
@@ skipping 15 matching lines @@
                              const SkPoint& offset, const SkIRect& clipRect);
 
     // sets up the descriptor on the blob and returns a detached cache.  Client must attach
     inline SkGlyphCache* setupCache(Run*, const SkPaint&, const SkMatrix& viewMatrix);
     static inline bool MustRegenerateBlob(const BitmapTextBlob&, const SkPaint&,
                                           const SkMatrix& viewMatrix, SkScalar x, SkScalar y);
     void regenerateTextBlob(BitmapTextBlob* bmp, const SkPaint& skPaint, const SkMatrix& viewMatrix,
                             const SkTextBlob* blob, SkScalar x, SkScalar y,
                             SkDrawFilter* drawFilter, const SkIRect& clipRect);
 
-    // TODO this currently only uses the public interface of SkTextBlob, however, I may need to add
-    // functionality to it while looping over the runs so I'm putting this here for the time being.
-    // If this lands in Chrome without changes, move it to SkTextBlob.
-    static inline void BlobGlyphCount(int* glyphCount, int* runCount, const SkTextBlob*);
+    GrBatchTextStrike* fCurrStrike;
+    GrTextBlobCache* fCache;
 
-    GrBatchTextStrike* fCurrStrike;
-
-    // TODO use real cache
-    static void ClearCacheEntry(uint32_t key, BitmapTextBlob**);
-    SkTHashMap<uint32_t, BitmapTextBlob*, BitmapTextBlob::Hash> fCache;
-
+    friend class GrTextBlobCache;
     friend class BitmapTextBatch;
 
     typedef GrTextContext INHERITED;
 };
 
 #endif