Start canonicalizing color for all A8 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
 
@@ skipping 109 matching lines @@
         struct BigGlyph {
             BigGlyph(const SkPath& path, int vx, int vy) : fPath(path), fVx(vx), fVy(vy) {}
             SkPath fPath;
             int fVx;
             int fVy;
         };
 #ifdef SK_DEBUG
         mutable SkScalar fTotalXError;
         mutable SkScalar fTotalYError;
 #endif
+        SkColor fPaintColor;
         SkTArray<BigGlyph> fBigGlyphs;
-        GrColor fColor; // the original color on the paint
         SkMatrix fViewMatrix;
         SkScalar fX;
         SkScalar fY;
         int fRunCount;
         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;
 
         struct Key {
             Key() {
                 memset(this, 0, sizeof(Key));
             }
             uint32_t fUniqueID;
             SkPaint::Style fStyle;
             bool fHasBlur;

[reed1, 2015/04/13 17:05:51]

I know there is a memset(0) at the beginning (btw - could use sk_bzero), but
still the fields in this Key are not explicitly packed, allowing for gaps in the
in-memory representation. Could we be more explicit in the order and size of
each?

+            // Color may affect the gamma of the mask we generate, but in a fairly limited way.
+            // There are a certain number of buckets, and within those buckets we can reassign the

[bsalomon, 2015/04/13 15:16:38]

Replace second sentence with

Each color is assigned to on of a fixed number of buckets based o nits
luminance. For each luminance bucket there is a "canonical color" that
represents the bucket.

??

+            // color as desired.  This functionality is currently only supported for A8
+            SkColor fCanonicalColor;
 
             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;
         }
@@ skipping 33 matching lines @@
                                SkScalar transX, SkScalar transY);
 
     // We have to flush SkTextBlobs differently from drawText / drawPosText
     void flush(GrDrawTarget*, const SkTextBlob*, BitmapTextBlob*, GrRenderTarget*, const SkPaint&,
                const GrPaint&, SkDrawFilter*, const GrClip&, const SkMatrix& viewMatrix,
                const SkIRect& clipBounds, SkScalar x, SkScalar y, SkScalar transX, SkScalar transY);
     void flush(GrDrawTarget*, BitmapTextBlob*, GrRenderTarget*, const SkPaint&,
                const GrPaint&, const GrClip&, const SkMatrix& viewMatrix);
 
     void internalDrawText(BitmapTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
-                          const SkMatrix& viewMatrix, const char text[], size_t byteLength,
+                          GrColor color, const SkMatrix& viewMatrix,
+                          const char text[], size_t byteLength,
                           SkScalar x, SkScalar y, const SkIRect& clipRect);
     void internalDrawPosText(BitmapTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
-                             const SkMatrix& viewMatrix,
+                             GrColor color, 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 static GrColor ComputeCanonicalColor(const SkPaint&, bool lcd);
     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,
+    void regenerateTextBlob(BitmapTextBlob* bmp, const SkPaint& skPaint, GrColor,
+                            const SkMatrix& viewMatrix,
                             const SkTextBlob* blob, SkScalar x, SkScalar y,
                             SkDrawFilter* drawFilter, const SkIRect& clipRect);
+    inline static bool HasLCD(const SkTextBlob*);
 
     GrBatchTextStrike* fCurrStrike;
     GrTextBlobCache* fCache;
 
     friend class GrTextBlobCache;
     friend class BitmapTextBatch;
 
     typedef GrTextContext INHERITED;
 };
 
 #endif