Remove last bit of privacy violation for GrAtlasTextBlob

src/gpu/text/GrAtlasTextBlob.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 GrAtlasTextBlob_DEFINED
 #define GrAtlasTextBlob_DEFINED
 
 #include "GrBatchAtlas.h"
 #include "GrBatchFontCache.h"
 #include "GrColor.h"
 #include "GrMemoryPool.h"
 #include "SkDescriptor.h"
 #include "SkMaskFilter.h"
 #include "SkSurfaceProps.h"
 #include "SkTInternalLList.h"
 
+class GrBlobRegenHelper;
 struct GrDistanceFieldAdjustTable;
 class GrMemoryPool;
 class GrTextContext;
 class SkDrawFilter;
 class SkTextBlob;
 class SkTextBlobRunIterator;
 
 // With this flag enabled, the GrAtlasTextContext will, as a sanity check, regenerate every blob
 // that comes in to verify the integrity of its cache
 #define CACHE_SANITY_CHECK 0
@@ skipping 71 matching lines @@
     void* operator new(size_t, void* p) { return p; }
     void operator delete(void* target, void* placement) {
         ::operator delete(target, placement);
     }
 
     bool hasDistanceField() const { return SkToBool(fTextType & kHasDistanceField_TextType); }
     bool hasBitmap() const { return SkToBool(fTextType & kHasBitmap_TextType); }
     void setHasDistanceField() { fTextType |= kHasDistanceField_TextType; }
     void setHasBitmap() { fTextType |= kHasBitmap_TextType; }
 
+    int runCount() const { return fRunCount; }
+
     void push_back_run(int currRun) {
         SkASSERT(currRun < fRunCount);
         if (currRun > 0) {
             Run::SubRunInfo& newRun = fRuns[currRun].fSubRunInfo.back();
             Run::SubRunInfo& lastRun = fRuns[currRun - 1].fSubRunInfo.back();
             newRun.setAsSuccessor(lastRun);
         }
     }
 
     // sets the last subrun of runIndex to use distance field text
@@ skipping 127 matching lines @@
     // We use this color vs the SkPaint color because it has the colorfilter applied.
     void initReusableBlob(GrColor color, const SkMatrix& viewMatrix, SkScalar x, SkScalar y) {
         fPaintColor = color;
         this->setupViewMatrix(viewMatrix, x, y);
     }
 
     void initThrowawayBlob(const SkMatrix& viewMatrix, SkScalar x, SkScalar y) {
         this->setupViewMatrix(viewMatrix, x, y);
     }
 
+    void regenInBatch(GrDrawBatch::Target* target, GrBatchFontCache* fontCache,
+                      GrBlobRegenHelper *helper, int run, int subRun, SkGlyphCache** cache,
+                      SkTypeface** typeface, GrFontScaler** scaler,
+                      const SkDescriptor** desc, size_t vertexStride,
+                      GrColor color, SkScalar transX, SkScalar transY,
+                      void** vertices, size_t* byteCount, int* glyphCount);
+
     const Key& key() const { return fKey; }
 
     ~GrAtlasTextBlob() {
         for (int i = 0; i < fRunCount; i++) {
             fRuns[i].~Run();
         }
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
     // Internal test methods
@@ skipping 178 matching lines @@
 
         // Distance field text cannot draw coloremoji, and so has to fall back.  However,
         // though the distance field text and the coloremoji may share the same run, they
         // will have different descriptors.  If fOverrideDescriptor is non-nullptr, then it
         // will be used in place of the run's descriptor to regen texture coords
         SkAutoTDelete<SkAutoDescriptor> fOverrideDescriptor; // df properties
         bool fInitialized;
         bool fDrawAsPaths;
     };
 
+    template <bool regenPos, bool regenCol, bool regenTexCoords, bool regenGlyphs>
+    void regenInBatch(GrDrawBatch::Target* target,
+                      GrBatchFontCache* fontCache,
+                      GrBlobRegenHelper* helper,
+                      Run* run, Run::SubRunInfo* info, SkGlyphCache** cache,
+                      SkTypeface** typeface, GrFontScaler** scaler,
+                      const SkDescriptor** desc,
+                      int glyphCount, size_t vertexStride,
+                      GrColor color, SkScalar transX,
+                      SkScalar transY) const;
+
     inline GrDrawBatch* createBatch(const Run::SubRunInfo& info,
                                     int glyphCount, int run, int subRun,
                                     GrColor color, SkScalar transX, SkScalar transY,
                                     const SkPaint& skPaint, const SkSurfaceProps& props,
                                     const GrDistanceFieldAdjustTable* distanceAdjustTable,
                                     GrBatchFontCache* cache);
 
     struct BigGlyph {
         BigGlyph(const SkPath& path, SkScalar vx, SkScalar vy, SkScalar scale, bool applyVM)
             : fPath(path)
@@ skipping 37 matching lines @@
     SkScalar fX;
     SkScalar fY;
 
     // We can reuse distance field text, but only if the new viewmatrix would not result in
     // a mip change.  Because there can be multiple runs in a blob, we track the overall
     // maximum minimum scale, and minimum maximum scale, we can support before we need to regen
     SkScalar fMaxMinScale;
     SkScalar fMinMaxScale;
     int fRunCount;
     uint8_t fTextType;
-
-    friend class GrAtlasTextBatch; // We might be able to get rid of this friending
 };
 
 #endif