Make GrVertexBatch objects hold their own draws during GrDrawTarget flush

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 "GrFontScaler.h"
 #include "GrGlyph.h"
 #include "SkGlyph.h"
 #include "SkTDynamicHash.h"
 #include "SkVarAlloc.h"
 
 class GrBatchFontCache;
-class GrBatchTarget;
 class GrGpu;
 
 /**
  *  The GrBatchTextStrike manages a pool of CPU backing memory for GrGlyphs.  This backing memory
  *  is indexed by a PackedID and GrFontScaler.  The GrFontScaler is what actually creates the mask.
  */
 class GrBatchTextStrike : public SkNVRefCnt<GrBatchTextStrike> {
 public:
     GrBatchTextStrike(GrBatchFontCache*, const GrFontDescKey* fontScalerKey);
     ~GrBatchTextStrike();
@@ skipping 22 matching lines @@
             glyph->fMaskFormat = expectedMaskFormat;
         }
         return glyph;
     }
 
     // returns true if glyph successfully added to texture atlas, false otherwise.  If the glyph's
     // mask format has changed, then addGlyphToAtlas will draw a clear box.  This will almost never
     // happen.
     // TODO we can handle some of these cases if we really want to, but the long term solution is to
     // get the actual glyph image itself when we get the glyph metrics.
-    bool addGlyphToAtlas(GrBatchTarget*, GrGlyph*, GrFontScaler*, const SkGlyph&,
+    bool addGlyphToAtlas(GrDrawBatch::Target*, GrGlyph*, GrFontScaler*, const SkGlyph&,
                          GrMaskFormat expectedMaskFormat);
 
     // 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; }
@@ skipping 54 matching lines @@
         }
         return NULL;
     }
 
     bool hasGlyph(GrGlyph* glyph) {
         SkASSERT(glyph);
         return this->getAtlas(glyph->fMaskFormat)->hasID(glyph->fID);
     }
 
     // To ensure the GrBatchAtlas does not evict the Glyph Mask from its texture backing store,
-    // the client must pass in the currentToken from the GrBatchTarget along with the GrGlyph.
+    // the client must pass in the current batch token along with the GrGlyph.
     // A BulkUseTokenUpdater is used to manage bulk last use token updating in the Atlas.
     // For convenience, this function will also set the use token for the current glyph if required
     // NOTE: the bulk uploader is only valid if the subrun has a valid atlasGeneration
     void addGlyphToBulkAndSetUseToken(GrBatchAtlas::BulkUseTokenUpdater* updater,
-                                      GrGlyph* glyph, GrBatchAtlas::BatchToken token) {
+                                      GrGlyph* glyph, GrBatchToken token) {
         SkASSERT(glyph);
         updater->add(glyph->fID);
         this->getAtlas(glyph->fMaskFormat)->setLastUseToken(glyph->fID, token);
     }
 
     void setUseTokenBulk(const GrBatchAtlas::BulkUseTokenUpdater& updater,
-                         GrBatchAtlas::BatchToken token,
+                         GrBatchToken token,
                          GrMaskFormat format) {
         this->getAtlas(format)->setLastUseTokenBulk(updater, token);
     }
 
     // add to texture atlas that matches this format
     bool addToAtlas(GrBatchTextStrike* strike, GrBatchAtlas::AtlasID* id,
-                    GrBatchTarget* batchTarget,
+                    GrDrawBatch::Target* target,
                     GrMaskFormat format, int width, int height, const void* image,
                     SkIPoint16* loc) {
         fPreserveStrike = strike;
-        return this->getAtlas(format)->addToAtlas(id, batchTarget, width, height, image, loc);
+        return this->getAtlas(format)->addToAtlas(id, target, width, height, image, loc);
     }
 
     // Some clients may wish to verify the integrity of the texture backing store of the
     // GrBatchAtlas.  The atlasGeneration returned below is a monitonically increasing number which
     // changes everytime something is removed from the texture backing store.
     uint64_t atlasGeneration(GrMaskFormat format) const {
         return this->getAtlas(format)->atlasGeneration();
     }
 
     void dump() const;
@@ skipping 39 matching lines @@
 
     static void HandleEviction(GrBatchAtlas::AtlasID, void*);
 
     GrContext* fContext;
     SkTDynamicHash<GrBatchTextStrike, GrFontDescKey> fCache;
     GrBatchAtlas* fAtlases[kMaskFormatCount];
     GrBatchTextStrike* fPreserveStrike;
 };
 
 #endif