Store pointers to GrGlyph directly in BitmapTextBlob

src/gpu/GrBatchFontCache.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 GrBatchFontCache_DEFINED
 #define GrBatchFontCache_DEFINED
 
 #include "GrBatchAtlas.h"
 #include "GrDrawTarget.h"
 #include "GrFontScaler.h"
 #include "GrGlyph.h"
 #include "SkTDynamicHash.h"
 #include "SkVarAlloc.h"
 
 class GrBatchFontCache;
 class GrBatchTarget;
 class GrGpu;
 
 /**
  *  The GrBatchTextStrike manages a pool of CPU backing memory for Glyph Masks.  This backing memory
  *  is abstracted by GrGlyph, and indexed by a PackedID and GrFontScaler.  The GrFontScaler is what
  *  actually creates the mask.
  */
-class GrBatchTextStrike {
+class GrBatchTextStrike : public SkNVRefCnt<GrBatchTextStrike> {
 public:
     GrBatchTextStrike(GrBatchFontCache*, const GrFontDescKey* fontScalerKey);
     ~GrBatchTextStrike();
 
     const GrFontDescKey* getFontScalerKey() const { return fFontScalerKey; }
     GrBatchFontCache* getBatchFontCache() const { return fBatchFontCache; }
 
     inline GrGlyph* getGlyph(GrGlyph::PackedID packed, GrFontScaler* scaler) {
         GrGlyph* glyph = fCache.find(packed);
         if (NULL == glyph) {
             glyph = this->generateGlyph(packed, scaler);
         }
         return glyph;
     }
 
     // returns true if glyph (or glyph+padding for distance field)
     // is too large to ever fit in texture atlas subregions (GrPlots)
     bool glyphTooLargeForAtlas(GrGlyph*);
     // returns true if glyph successfully added to texture atlas, false otherwise
     bool addGlyphToAtlas(GrBatchTarget*, GrGlyph*, GrFontScaler*);
 
     // testing
     int countGlyphs() const { return fCache.count(); }
 
     // remove any references to this plot
     void removeID(GrBatchAtlas::AtlasID);
 
+    // If a TextStrike is abandoned by the cache, then the caller must get a new strike
+    bool isAbandoned() const { return fIsAbandoned; }
+
     static const GrFontDescKey& GetKey(const GrBatchTextStrike& ts) {
         return *(ts.fFontScalerKey);
     }
     static uint32_t Hash(const GrFontDescKey& key) {
         return key.getHash();
     }
 
 private:
     SkTDynamicHash<GrGlyph, GrGlyph::PackedID> fCache;
     SkAutoTUnref<const GrFontDescKey> fFontScalerKey;
     SkVarAlloc fPool;
 
     GrBatchFontCache* fBatchFontCache;
     int fAtlasedGlyphs;
+    bool fIsAbandoned;
 
     GrGlyph* generateGlyph(GrGlyph::PackedID packed, GrFontScaler* scaler);
 
     friend class GrBatchFontCache;
 };
 
 /*
  * GrBatchFontCache manages strikes which are indexed by a GrFontScaler.  These strikes can then be
  * used to individual Glyph Masks.  The GrBatchFontCache also manages GrBatchAtlases, though this is
  * more or less transparent to the client(aside from atlasGeneration, described below).
  * Note - we used to initialize the backing atlas for the GrBatchFontCache at initialization time.
  * However, this caused a regression, even when the GrBatchFontCache was unused.  We now initialize
  * the backing atlases lazily.  Its not immediately clear why this improves the situation.
  */
 class GrBatchFontCache {
 public:
     GrBatchFontCache(GrContext*);
     ~GrBatchFontCache();
-
+    // The user of the cache may hold a long-lived ref to the returned strike. However, actions by
+    // another client of the cache may cause the strike to be purged while it is still reffed.
+    // Therefore, the caller must check GrBatchTextStrike::isAbandoned() if there are other
+    // interactions with the cache since the strike was received.
     inline GrBatchTextStrike* getStrike(GrFontScaler* scaler) {
         GrBatchTextStrike* strike = fCache.find(*(scaler->getKey()));
         if (NULL == strike) {
             strike = this->generateStrike(scaler);
         }
         return strike;
     }
 
     void freeAll();
 
@@ skipping 80 matching lines @@
 
     static void HandleEviction(GrBatchAtlas::AtlasID, void*);
 
     GrContext* fContext;
     SkTDynamicHash<GrBatchTextStrike, GrFontDescKey> fCache;
     GrBatchAtlas* fAtlases[kMaskFormatCount];
     GrBatchTextStrike* fPreserveStrike;
 };
 
 #endif