Start caching masks / stroke fills for 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 "SkMaskFilter.h"
 #include "SkTextBlob.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
@@ skipping 50 matching lines @@
          * Finally, for runs where the entire thing is too large for the GrAtlasTextContext to
          * handle, we have a bit to mark the run as flusahable via rendering as paths.  It is worth
          * pointing. It would be a bit expensive to figure out ahead of time whether or not a run
          * can flush in this manner, so we always allocate vertices for the run, regardless of
          * whether or not it is too large.  The benefit of this strategy is that we can always reuse
          * a blob allocation regardless of viewmatrix changes.  We could store positions for these
          * glyphs.  However, its not clear if this is a win because we'd still have to either go the
          * glyph cache to get the path at flush time, or hold onto the path in the cache, which
          * would greatly increase the memory of these cached items.
          */
-
         struct Run {
             Run() : fColor(GrColor_ILLEGAL), fInitialized(false), fDrawAsPaths(false) {
                 fVertexBounds.setLargestInverted();
                 // We insert the first subrun to gurantee a run always has atleast one subrun.
                 // We do this to simplify things when we 'hand off' data from one subrun to the
                 // next
                 fSubRunInfo.push_back();
             }
             struct SubRunInfo {
                 SubRunInfo()
@@ skipping 27 matching lines @@
         };
 #ifdef SK_DEBUG
         mutable SkScalar fTotalXError;
         mutable SkScalar fTotalYError;
 #endif
         SkTArray<BigGlyph> fBigGlyphs;
         GrColor fColor; // the original color on the paint
         SkMatrix fViewMatrix;
         SkScalar fX;
         SkScalar fY;
-        SkPaint::Style fStyle;
         int fRunCount;
-        uint32_t fUniqueID;
+        SkMaskFilter::BlurRec fBlurRec;
+        struct StrokeInfo {
+            SkScalar fFrameWidth;
+            SkScalar fMiterLimit;
+            SkPaint::Join fJoin;
+        };
+        StrokeInfo fStrokeInfo;
         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;
+        struct Key {
+            Key() {
+                memset(this, 0, sizeof(Key));
+            }
+            uint32_t fUniqueID;
+            SkPaint::Style fStyle;
+            bool fHasBlur;
+
+            bool operator==(const Key& other) const {
+                return 0 == memcmp(this, &other, sizeof(Key));
+            }
+        };
+        Key fKey;
+
+        static const Key& GetKey(const BitmapTextBlob& blob) {
+            return blob.fKey;
         }
 
-        static uint32_t Hash(const uint32_t& key) {
-            return SkChecksum::Mix(key);
+        static uint32_t Hash(const Key& key) {
+            return SkChecksum::Murmur3(&key, sizeof(Key));
         }
 
         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);
         }
@@ skipping 32 matching lines @@
     void internalDrawPosText(BitmapTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
                              const SkMatrix& viewMatrix,
                              const char text[], size_t byteLength,
                              const SkScalar pos[], int scalarsPerPosition,
                              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(SkScalar* outTransX, SkScalar* outTransY,
                                           const BitmapTextBlob&, const SkPaint&,
+                                          const SkMaskFilter::BlurRec&,
                                           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);
 
     GrBatchTextStrike* fCurrStrike;
     GrTextBlobCache* fCache;
 
     friend class GrTextBlobCache;
     friend class BitmapTextBatch;
 
     typedef GrTextContext INHERITED;
 };
 
 #endif