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 95 matching lines @@
             SkPath fPath;
             int fVx;
             int fVy;
         };
 
         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;
         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;
+            SkMaskFilter::BlurRec fBlurRec;

[bsalomon, 2015/04/08 15:38:19]

As we discussed, perhaps this should be a bit here to disallow multiple blurred
versions of a blob to the cache (animation) and the blur params are compared on
a cache hit.

+            struct StrokeInfo {

[bsalomon, 2015/04/08 15:38:19]

similar here I think, style says its stroked, probably only want one stroked
cache entry per blob.

+                SkScalar fFrameWidth;
+                SkScalar fMiterLimit;
+                uint8_t fStrokeJoin;
+            };
+            StrokeInfo fStrokeInfo;
+
+            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 47 matching lines @@
     GrBatchTextStrike* fCurrStrike;
     GrTextBlobCache* fCache;
 
     friend class GrTextBlobCache;
     friend class BitmapTextBatch;
 
     typedef GrTextContext INHERITED;
 };
 
 #endif