Fix bug with GrAtlasTextContext color regen

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
 
@@ skipping 45 matching lines @@
      * 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)
+            : fInitialized(false)
             , fDrawAsPaths(false) {
             fVertexBounds.setLargestInverted();
             // To ensure we always have one subrun, we push back a fresh run here
             fSubRunInfo.push_back();
         }
         struct SubRunInfo {
             SubRunInfo()
                 : fAtlasGeneration(GrBatchAtlas::kInvalidAtlasGeneration)
                 , fVertexStartIndex(0)
                 , fVertexEndIndex(0)
                 , fGlyphStartIndex(0)
                 , fGlyphEndIndex(0)
+                , fColor(GrColor_ILLEGAL)
                 , fMaskFormat(kA8_GrMaskFormat)
                 , fDrawAsDistanceFields(false)
                 , fUseLCDText(false) {}
             SubRunInfo(const SubRunInfo& that)
                 : fBulkUseToken(that.fBulkUseToken)
                 , fStrike(SkSafeRef(that.fStrike.get()))
                 , fAtlasGeneration(that.fAtlasGeneration)
                 , fVertexStartIndex(that.fVertexStartIndex)
                 , fVertexEndIndex(that.fVertexEndIndex)
                 , fGlyphStartIndex(that.fGlyphStartIndex)
                 , fGlyphEndIndex(that.fGlyphEndIndex)
+                , fColor(that.fColor)
                 , fMaskFormat(that.fMaskFormat)
                 , fDrawAsDistanceFields(that.fDrawAsDistanceFields)
                 , fUseLCDText(that.fUseLCDText) {
             }
 
             // TODO when this object is more internal, drop the privacy
             void resetBulkUseToken() { fBulkUseToken.reset(); }
             GrBatchAtlas::BulkUseTokenUpdater* bulkUseToken() { return &fBulkUseToken; }
             void setStrike(GrBatchTextStrike* strike) { fStrike.reset(SkRef(strike)); }
             GrBatchTextStrike* strike() const { return fStrike.get(); }
 
             void setAtlasGeneration(uint64_t atlasGeneration) { fAtlasGeneration = atlasGeneration;}
             uint64_t atlasGeneration() const { return fAtlasGeneration; }
 
             size_t byteCount() const { return fVertexEndIndex - fVertexStartIndex; }
             size_t vertexStartIndex() const { return fVertexStartIndex; }
             size_t vertexEndIndex() const { return fVertexEndIndex; }
             void appendVertices(size_t vertexStride) {
                 fVertexEndIndex += vertexStride * kVerticesPerGlyph;
             }
 
             uint32_t glyphCount() const { return fGlyphEndIndex - fGlyphStartIndex; }
             uint32_t glyphStartIndex() const { return fGlyphStartIndex; }
             uint32_t glyphEndIndex() const { return fGlyphEndIndex; }
             void glyphAppended() { fGlyphEndIndex++; }
+            void setColor(GrColor color) { fColor = color; }
+            GrColor color() const { return fColor; }
             void setMaskFormat(GrMaskFormat format) { fMaskFormat = format; }
             GrMaskFormat maskFormat() const { return fMaskFormat; }
 
             void setAsSuccessor(const SubRunInfo& prev) {
                 fGlyphStartIndex = prev.glyphEndIndex();
                 fGlyphEndIndex = prev.glyphEndIndex();
 
                 fVertexStartIndex = prev.vertexEndIndex();
                 fVertexEndIndex = prev.vertexEndIndex();
             }
 
             // df properties
             void setUseLCDText(bool useLCDText) { fUseLCDText = useLCDText; }
             bool hasUseLCDText() const { return fUseLCDText; }
             void setDrawAsDistanceFields() { fDrawAsDistanceFields = true; }
             bool drawAsDistanceFields() const { return fDrawAsDistanceFields; }
 
         private:
             GrBatchAtlas::BulkUseTokenUpdater fBulkUseToken;
             SkAutoTUnref<GrBatchTextStrike> fStrike;
             uint64_t fAtlasGeneration;
             size_t fVertexStartIndex;
             size_t fVertexEndIndex;
             uint32_t fGlyphStartIndex;
             uint32_t fGlyphEndIndex;
+            GrColor fColor;
             GrMaskFormat fMaskFormat;
             bool fDrawAsDistanceFields; // df property
             bool fUseLCDText; // df property
         };
 
         SubRunInfo& push_back() {
             // Forward glyph / vertex information to seed the new sub run
             SubRunInfo& newSubRun = fSubRunInfo.push_back();
             const SubRunInfo& prevSubRun = fSubRunInfo.fromBack(1);
 
             newSubRun.setAsSuccessor(prevSubRun);
             return newSubRun;
         }
         static const int kMinSubRuns = 1;
         SkAutoTUnref<SkTypeface> fTypeface;
         SkRect fVertexBounds;
         SkSTArray<kMinSubRuns, SubRunInfo> fSubRunInfo;
         SkAutoDescriptor fDescriptor;
 
         // 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
-        GrColor fColor;
         bool fInitialized;
         bool fDrawAsPaths;
     };
 
     struct BigGlyph {
         BigGlyph(const SkPath& path, SkScalar vx, SkScalar vy, SkScalar scale, bool applyVM)
             : fPath(path)
             , fVx(vx)
             , fVy(vy)
             , fScale(scale)
@@ skipping 127 matching lines @@
     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
 };
 
 #endif