Fix for 510931, merge to m44

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 91 matching lines @@
                 fSubRunInfo.push_back();
             }
             struct SubRunInfo {
                 SubRunInfo()
                     : fAtlasGeneration(GrBatchAtlas::kInvalidAtlasGeneration)
                     , fVertexStartIndex(0)
                     , fVertexEndIndex(0)
                     , fGlyphStartIndex(0)
                     , fGlyphEndIndex(0)
                     , fDrawAsDistanceFields(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)
+                    , fTextRatio(that.fTextRatio)
+                    , fMaskFormat(that.fMaskFormat)
+                    , fDrawAsDistanceFields(that.fDrawAsDistanceFields)
+                    , fUseLCDText(that.fUseLCDText) {
+                }
                 // 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-NULL, then it
                 // will be used in place of the run's descriptor to regen texture coords
                 // TODO we could have a descriptor cache, it would reduce the size of these blobs
                 // significantly, and then the subrun could just have a refed pointer to the
                 // correct descriptor.
                 GrBatchAtlas::BulkUseTokenUpdater fBulkUseToken;
+                SkAutoTUnref<GrBatchTextStrike> fStrike;
                 uint64_t fAtlasGeneration;
                 size_t fVertexStartIndex;
                 size_t fVertexEndIndex;
                 uint32_t fGlyphStartIndex;
                 uint32_t fGlyphEndIndex;
                 SkScalar fTextRatio; // df property
                 GrMaskFormat fMaskFormat;
                 bool fDrawAsDistanceFields; // df property
                 bool fUseLCDText; // df property
             };
 
             SubRunInfo& push_back() {
                 // Forward glyph / vertex information to seed the new sub run
-                SubRunInfo& prevSubRun = fSubRunInfo.back();
                 SubRunInfo& newSubRun = fSubRunInfo.push_back();
+                SubRunInfo& prevSubRun = fSubRunInfo.fromBack(1);
+
                 newSubRun.fGlyphStartIndex = prevSubRun.fGlyphEndIndex;
                 newSubRun.fGlyphEndIndex = prevSubRun.fGlyphEndIndex;
 
                 newSubRun.fVertexStartIndex = prevSubRun.fVertexEndIndex;
                 newSubRun.fVertexEndIndex = prevSubRun.fVertexEndIndex;
                 return newSubRun;
             }
             static const int kMinSubRuns = 1;
-            SkAutoTUnref<GrBatchTextStrike> fStrike;
             SkAutoTUnref<SkTypeface> fTypeface;
             SkRect fVertexBounds;
             SkSTArray<kMinSubRuns, SubRunInfo> fSubRunInfo;
             SkAutoDescriptor fDescriptor;
             SkAutoTDelete<SkAutoDescriptor> fOverrideDescriptor; // df properties
             GrColor fColor;
             bool fInitialized;
             bool fDrawAsPaths;
         };
 
@@ skipping 98 matching lines @@
         void setHasBitmap() { fTextType |= kHasBitmap_TextType; }
     };
 
     typedef BitmapTextBlob::Run Run;
     typedef Run::SubRunInfo PerSubRunInfo;
 
     inline bool canDrawAsDistanceFields(const SkPaint&, const SkMatrix& viewMatrix);
     BitmapTextBlob* setupDFBlob(int glyphCount, const SkPaint& origPaint,
                                 const SkMatrix& viewMatrix, SkGlyphCache** cache,
                                 SkPaint* dfPaint, SkScalar* textRatio);
-    void bmpAppendGlyph(BitmapTextBlob*, int runIndex, GrGlyph::PackedID, int left, int top,
+    void bmpAppendGlyph(BitmapTextBlob*, int runIndex, const SkGlyph&, int left, int top,
                         GrColor color, GrFontScaler*, const SkIRect& clipRect);
-    bool dfAppendGlyph(BitmapTextBlob*, int runIndex, GrGlyph::PackedID, SkScalar sx, SkScalar sy,
+    bool dfAppendGlyph(BitmapTextBlob*, int runIndex, const SkGlyph&, SkScalar sx, SkScalar sy,
                        GrColor color, GrFontScaler*, const SkIRect& clipRect, SkScalar textRatio,
                        const SkMatrix& viewMatrix);
-    inline void appendGlyphPath(BitmapTextBlob* blob, GrGlyph* glyph,
-                                GrFontScaler* scaler, SkScalar x, SkScalar y);
+    inline void appendGlyphPath(BitmapTextBlob*, GrGlyph*, GrFontScaler*, const SkGlyph&,
+                                SkScalar x, SkScalar y);
     inline void appendGlyphCommon(BitmapTextBlob*, Run*, Run::SubRunInfo*,
                                   const SkRect& positions, GrColor color,
                                   size_t vertexStride, bool useVertexColor,
                                   GrGlyph*);
 
     inline void flushRunAsPaths(const SkTextBlob::RunIterator&, const SkPaint&, SkDrawFilter*,
                                 const SkMatrix& viewMatrix, const SkIRect& clipBounds, SkScalar x,
                                 SkScalar y);
     inline BitmapTextBatch* createBatch(BitmapTextBlob*, const PerSubRunInfo&,
                                         int glyphCount, int run, int subRun,
@@ skipping 109 matching lines @@
     friend class BitmapTextBatch;
 
 #ifdef GR_TEST_UTILS
     BATCH_TEST_FRIEND(TextBlobBatch);
 #endif
 
     typedef GrTextContext INHERITED;
 };
 
 #endif