Move flush logic into GrAtlasTextBlob

src/gpu/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 "GrMemoryPool.h"
 #include "SkSurfaceProps.h"
 #include "SkTInternalLList.h"
 
+struct GrDistanceFieldAdjustTable;
+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 // VERY SLOW
 
 /*
  * A GrAtlasTextBlob contains a fully processed SkTextBlob, suitable for nearly immediate drawing
  * on the GPU.  These are initially created with valid positions and colors, but invalid
  * texture coordinates.  The GrAtlasTextBlob 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 GrAtlasTextBlob is to ensure that
  * the GrAtlas will not evict anything the Blob needs.
  *
  * Note: This struct should really be named GrCachedAtasTextBlob, but that is too verbose.
  *
  * *WARNING* If you add new fields to this struct, then you may need to to update AssertEqual
  */
-struct GrAtlasTextBlob : public SkNVRefCnt<GrAtlasTextBlob> {
+class GrAtlasTextBlob : public SkNVRefCnt<GrAtlasTextBlob> {
+public:
     SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrAtlasTextBlob);
 
     /*
      * 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.
@@ skipping 252 matching lines @@
                 return kColorTextVASize;
             default:
                 return kLCDTextVASize;
         }
     }
 
     bool mustRegenerate(SkScalar* outTransX, SkScalar* outTransY, const SkPaint& paint,
                         GrColor color, const SkMaskFilter::BlurRec& blurRec,
                         const SkMatrix& viewMatrix, SkScalar x, SkScalar y);
 
+    // flush a GrAtlasTextBlob associated with a SkTextBlob
+    void flushCached(const SkTextBlob* blob,
+                     GrContext* context,
+                     GrDrawContext* dc,
+                     GrTextContext* textContext,
+                     const SkSurfaceProps& props,
+                     const GrDistanceFieldAdjustTable* distanceAdjustTable,
+                     const SkPaint& skPaint,
+                     const GrPaint& grPaint,
+                     SkDrawFilter* drawFilter,
+                     const GrClip& clip,
+                     const SkMatrix& viewMatrix,
+                     const SkIRect& clipBounds,
+                     SkScalar x, SkScalar y,
+                     SkScalar transX, SkScalar transY);
+
+    // flush a throwaway GrAtlasTextBlob *not* associated with an SkTextBlob
+    void flushThrowaway(GrContext* context,
+                        GrDrawContext* dc,
+                        const SkSurfaceProps& props,
+                        const GrDistanceFieldAdjustTable* distanceAdjustTable,
+                        const SkPaint& skPaint,
+                        const GrPaint& grPaint,
+                        const GrClip& clip,
+                        const SkIRect& clipBounds);
+
     // position + local coord
     static const size_t kColorTextVASize = sizeof(SkPoint) + sizeof(SkIPoint16);
     static const size_t kGrayTextVASize = sizeof(SkPoint) + sizeof(GrColor) + sizeof(SkIPoint16);
     static const size_t kLCDTextVASize = kGrayTextVASize;
     static const int kVerticesPerGlyph = 4;
 
 #ifdef CACHE_SANITY_CHECK
     static void AssertEqual(const GrAtlasTextBlob&, const GrAtlasTextBlob&);
     size_t fSize;
 #endif
+
+    // We'd like to inline this and make it private, but there is some test code which calls it.
+    // TODO refactor this
+    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);
+
 private:
     void appendLargeGlyph(GrGlyph* glyph, GrFontScaler* scaler, const SkGlyph& skGlyph,
                           SkScalar x, SkScalar y, SkScalar scale, bool applyVM);
+
+    inline void flushRun(GrDrawContext* dc, GrPipelineBuilder* pipelineBuilder,
+                         int run, GrColor color,
+                         SkScalar transX, SkScalar transY,
+                         const SkPaint& skPaint, const SkSurfaceProps& props,
+                         const GrDistanceFieldAdjustTable* distanceAdjustTable,
+                         GrBatchFontCache* cache);
+
+    void flushBigGlyphs(GrContext* context, GrDrawContext* dc,
+                        const GrClip& clip, const SkPaint& skPaint,
+                        SkScalar transX, SkScalar transY,
+                        const SkIRect& clipBounds);
+
+    void flushRunAsPaths(GrDrawContext* dc,
+                         GrTextContext* textContext,
+                         const SkSurfaceProps& props,
+                         const SkTextBlobRunIterator& it,
+                         const GrClip& clip, const SkPaint& skPaint,
+                         SkDrawFilter* drawFilter, const SkMatrix& viewMatrix,
+                         const SkIRect& clipBounds, SkScalar x, SkScalar y);
 };
 
 #endif