Fix for 510931, merge to m44

src/gpu/GrAtlasTextContext.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "GrAtlasTextContext.h"
 
 #include "GrBatch.h"
 #include "GrBatchFontCache.h"
@@ skipping 857 matching lines @@
     Sk48Dot16 fy = SkScalarTo48Dot16(y + halfSampleY);
 
     while (text < stop) {
         const SkGlyph& glyph = glyphCacheProc(cache, &text, fx & fxMask, fy & fyMask);
 
         fx += autokern.adjust(glyph);
 
         if (glyph.fWidth) {
             this->bmpAppendGlyph(blob,
                                  runIndex,
-                                 GrGlyph::Pack(glyph.getGlyphID(),
-                                               glyph.getSubXFixed(),
-                                               glyph.getSubYFixed(),
-                                               GrGlyph::kCoverage_MaskStyle),
+                                 glyph,
                                  Sk48Dot16FloorToInt(fx),
                                  Sk48Dot16FloorToInt(fy),
                                  color,
                                  fontScaler,
                                  clipRect);
         }
 
         fx += glyph.fAdvanceX;
         fy += glyph.fAdvanceY;
     }
@@ skipping 46 matching lines @@
                 tmsProc(pos, &tmsLoc);
                 Sk48Dot16 fx = SkScalarTo48Dot16(tmsLoc.fX + halfSampleX);
                 Sk48Dot16 fy = SkScalarTo48Dot16(tmsLoc.fY + halfSampleY);
 
                 const SkGlyph& glyph = glyphCacheProc(cache, &text,
                                                       fx & fxMask, fy & fyMask);
 
                 if (glyph.fWidth) {
                     this->bmpAppendGlyph(blob,
                                          runIndex,
-                                         GrGlyph::Pack(glyph.getGlyphID(),
-                                                       glyph.getSubXFixed(),
-                                                       glyph.getSubYFixed(),
-                                                       GrGlyph::kCoverage_MaskStyle),
+                                         glyph,
                                          Sk48Dot16FloorToInt(fx),
                                          Sk48Dot16FloorToInt(fy),
                                          color,
                                          fontScaler,
                                          clipRect);
                 }
                 pos += scalarsPerPosition;
             }
         } else {
             while (text < stop) {
@@ skipping 14 matching lines @@
                     // have to call again, now that we've been "aligned"
                     const SkGlyph& glyph = glyphCacheProc(cache, &currentText,
                                                           fx & fxMask, fy & fyMask);
                     // the assumption is that the metrics haven't changed
                     SkASSERT(prevAdvX == glyph.fAdvanceX);
                     SkASSERT(prevAdvY == glyph.fAdvanceY);
                     SkASSERT(glyph.fWidth);
 
                     this->bmpAppendGlyph(blob,
                                          runIndex,
-                                         GrGlyph::Pack(glyph.getGlyphID(),
-                                                       glyph.getSubXFixed(),
-                                                       glyph.getSubYFixed(),
-                                                       GrGlyph::kCoverage_MaskStyle),
+                                         glyph,
                                          Sk48Dot16FloorToInt(fx),
                                          Sk48Dot16FloorToInt(fy),
                                          color,
                                          fontScaler,
                                          clipRect);
                 }
                 pos += scalarsPerPosition;
             }
         }
     } else {    // not subpixel
 
         if (SkPaint::kLeft_Align == skPaint.getTextAlign()) {
             while (text < stop) {
                 // the last 2 parameters are ignored
                 const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
 
                 if (glyph.fWidth) {
                     SkPoint tmsLoc;
                     tmsProc(pos, &tmsLoc);
 
                     Sk48Dot16 fx = SkScalarTo48Dot16(tmsLoc.fX + SK_ScalarHalf); //halfSampleX;
                     Sk48Dot16 fy = SkScalarTo48Dot16(tmsLoc.fY + SK_ScalarHalf); //halfSampleY;
                     this->bmpAppendGlyph(blob,
                                          runIndex,
-                                         GrGlyph::Pack(glyph.getGlyphID(),
-                                                       glyph.getSubXFixed(),
-                                                       glyph.getSubYFixed(),
-                                                       GrGlyph::kCoverage_MaskStyle),
+                                         glyph,
                                          Sk48Dot16FloorToInt(fx),
                                          Sk48Dot16FloorToInt(fy),
                                          color,
                                          fontScaler,
                                          clipRect);
                 }
                 pos += scalarsPerPosition;
             }
         } else {
             while (text < stop) {
                 // the last 2 parameters are ignored
                 const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
 
                 if (glyph.fWidth) {
                     SkPoint tmsLoc;
                     tmsProc(pos, &tmsLoc);
 
                     SkPoint alignLoc;
                     alignProc(tmsLoc, glyph, &alignLoc);
 
                     Sk48Dot16 fx = SkScalarTo48Dot16(alignLoc.fX + SK_ScalarHalf); //halfSampleX;
                     Sk48Dot16 fy = SkScalarTo48Dot16(alignLoc.fY + SK_ScalarHalf); //halfSampleY;
                     this->bmpAppendGlyph(blob,
                                          runIndex,
-                                         GrGlyph::Pack(glyph.getGlyphID(),
-                                                       glyph.getSubXFixed(),
-                                                       glyph.getSubYFixed(),
-                                                       GrGlyph::kCoverage_MaskStyle),
+                                         glyph,
                                          Sk48Dot16FloorToInt(fx),
                                          Sk48Dot16FloorToInt(fy),
                                          color,
                                          fontScaler,
                                          clipRect);
                 }
                 pos += scalarsPerPosition;
             }
         }
     }
@@ skipping 105 matching lines @@
             const char* lastText = text;
             // the last 2 parameters are ignored
             const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
 
             if (glyph.fWidth) {
                 SkScalar x = offset.x() + pos[0];
                 SkScalar y = offset.y() + (2 == scalarsPerPosition ? pos[1] : 0);
 
                 if (!this->dfAppendGlyph(blob,
                                          runIndex,
-                                         GrGlyph::Pack(glyph.getGlyphID(),
-                                                       glyph.getSubXFixed(),
-                                                       glyph.getSubYFixed(),
-                                                       GrGlyph::kDistance_MaskStyle),
+                                         glyph,
                                          x, y, color, fontScaler, clipRect,
                                          textRatio, viewMatrix)) {
                     // couldn't append, send to fallback
                     fallbackTxt->append(SkToInt(text-lastText), lastText);
                     *fallbackPos->append() = pos[0];
                     if (2 == scalarsPerPosition) {
                         *fallbackPos->append() = pos[1];
                     }
                 }
             }
             pos += scalarsPerPosition;
         }
     } else {
         SkScalar alignMul = SkPaint::kCenter_Align == skPaint.getTextAlign() ? SK_ScalarHalf
                                                                              : SK_Scalar1;
         while (text < stop) {
             const char* lastText = text;
             // the last 2 parameters are ignored
             const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
 
             if (glyph.fWidth) {
                 SkScalar x = offset.x() + pos[0];
                 SkScalar y = offset.y() + (2 == scalarsPerPosition ? pos[1] : 0);
 
                 SkScalar advanceX = SkFixedToScalar(glyph.fAdvanceX) * alignMul * textRatio;
                 SkScalar advanceY = SkFixedToScalar(glyph.fAdvanceY) * alignMul * textRatio;
 
                 if (!this->dfAppendGlyph(blob,
                                          runIndex,
-                                         GrGlyph::Pack(glyph.getGlyphID(),
-                                                       glyph.getSubXFixed(),
-                                                       glyph.getSubYFixed(),
-                                                       GrGlyph::kDistance_MaskStyle),
+                                         glyph,
                                          x - advanceX, y - advanceY, color,
                                          fontScaler,
                                          clipRect,
                                          textRatio,
                                          viewMatrix)) {
                     // couldn't append, send to fallback
                     fallbackTxt->append(SkToInt(text-lastText), lastText);
                     *fallbackPos->append() = pos[0];
                     if (2 == scalarsPerPosition) {
                         *fallbackPos->append() = pos[1];
                     }
                 }
             }
             pos += scalarsPerPosition;
         }
     }
 }
 
 void GrAtlasTextContext::bmpAppendGlyph(BitmapTextBlob* blob, int runIndex,
-                                        GrGlyph::PackedID packed,
+                                        const SkGlyph& skGlyph,
                                         int vx, int vy, GrColor color, GrFontScaler* scaler,
                                         const SkIRect& clipRect) {
     Run& run = blob->fRuns[runIndex];
     if (!fCurrStrike) {
         fCurrStrike = fContext->getBatchFontCache()->getStrike(scaler);
-        run.fStrike.reset(SkRef(fCurrStrike));
     }
 
-    GrGlyph* glyph = fCurrStrike->getGlyph(packed, scaler);
+    GrGlyph::PackedID id = GrGlyph::Pack(skGlyph.getGlyphID(),
+                                         skGlyph.getSubXFixed(),
+                                         skGlyph.getSubYFixed(),
+                                         GrGlyph::kCoverage_MaskStyle);
+    GrGlyph* glyph = fCurrStrike->getGlyph(skGlyph, id, scaler);
     if (!glyph) {
         return;
     }
 
     int x = vx + glyph->fBounds.fLeft;
     int y = vy + glyph->fBounds.fTop;
 
     // keep them as ints until we've done the clip-test
     int width = glyph->fBounds.width();
     int height = glyph->fBounds.height();
 
 #if 0
     // Not checking the clip bounds might introduce a performance regression.  However, its not
     // clear if this is still true today with the larger tiles we use in Chrome.  For repositionable
     // blobs, we want to make sure we have all of the glyphs, so clipping them out is not ideal.
     // We could store the cliprect in the key, but then we'd lose the ability to do integer scrolls
     // TODO verify this
     // check if we clipped out
     if (clipRect.quickReject(x, y, x + width, y + height)) {
         return;
     }
 #endif
 
     // If the glyph is too large we fall back to paths
     if (glyph->fTooLargeForAtlas) {
-        this->appendGlyphPath(blob, glyph, scaler, SkIntToScalar(vx), SkIntToScalar(vy));
+        this->appendGlyphPath(blob, glyph, scaler, skGlyph, SkIntToScalar(vx), SkIntToScalar(vy));
         return;
     }
 
     GrMaskFormat format = glyph->fMaskFormat;
 
     PerSubRunInfo* subRun = &run.fSubRunInfo.back();
     if (run.fInitialized && subRun->fMaskFormat != format) {
-        subRun = &run.fSubRunInfo.push_back();
+        subRun = &run.push_back();
+        subRun->fStrike.reset(SkRef(fCurrStrike));
+    } else if (!run.fInitialized) {
+        subRun->fStrike.reset(SkRef(fCurrStrike));
     }
 
     run.fInitialized = true;
 
     size_t vertexStride = get_vertex_stride(format);
 
     SkRect r;
     r.fLeft = SkIntToScalar(x);
     r.fTop = SkIntToScalar(y);
     r.fRight = r.fLeft + SkIntToScalar(width);
     r.fBottom = r.fTop + SkIntToScalar(height);
     subRun->fMaskFormat = format;
     this->appendGlyphCommon(blob, &run, subRun, r, color, vertexStride, kA8_GrMaskFormat == format,
                             glyph);
 }
 
 bool GrAtlasTextContext::dfAppendGlyph(BitmapTextBlob* blob, int runIndex,
-                                       GrGlyph::PackedID packed,
+                                       const SkGlyph& skGlyph,
                                        SkScalar sx, SkScalar sy, GrColor color,
                                        GrFontScaler* scaler,
                                        const SkIRect& clipRect,
                                        SkScalar textRatio, const SkMatrix& viewMatrix) {
     Run& run = blob->fRuns[runIndex];
     if (!fCurrStrike) {
         fCurrStrike = fContext->getBatchFontCache()->getStrike(scaler);
-        run.fStrike.reset(SkRef(fCurrStrike));
     }
 
-    GrGlyph* glyph = fCurrStrike->getGlyph(packed, scaler);
+    GrGlyph::PackedID id = GrGlyph::Pack(skGlyph.getGlyphID(),
+                                         skGlyph.getSubXFixed(),
+                                         skGlyph.getSubYFixed(),
+                                         GrGlyph::kDistance_MaskStyle);
+    GrGlyph* glyph = fCurrStrike->getGlyph(skGlyph, id, scaler);
     if (!glyph) {
         return true;
     }
 
     // fallback to color glyph support
     if (kA8_GrMaskFormat != glyph->fMaskFormat) {
         return false;
     }
 
     SkScalar dx = SkIntToScalar(glyph->fBounds.fLeft + SK_DistanceFieldInset);
@@ skipping 18 matching lines @@
                              SkScalarTruncToInt(dstRect.top()),
                              SkScalarTruncToInt(dstRect.right()),
                              SkScalarTruncToInt(dstRect.bottom()))) {
         return true;
     }
 #endif
 
     // TODO combine with the above
     // If the glyph is too large we fall back to paths
     if (glyph->fTooLargeForAtlas) {
-        this->appendGlyphPath(blob, glyph, scaler, sx - dx, sy - dy);
+        this->appendGlyphPath(blob, glyph, scaler, skGlyph, sx - dx, sy - dy);
         return true;
     }
 
     PerSubRunInfo* subRun = &run.fSubRunInfo.back();
+    if (!run.fInitialized) {
+        subRun->fStrike.reset(SkRef(fCurrStrike));
+    }
+    run.fInitialized = true;
     SkASSERT(glyph->fMaskFormat == kA8_GrMaskFormat);
     subRun->fMaskFormat = kA8_GrMaskFormat;
 
     size_t vertexStride = get_vertex_stride_df(kA8_GrMaskFormat, subRun->fUseLCDText);
 
     bool useColorVerts = !subRun->fUseLCDText;
     this->appendGlyphCommon(blob, &run, subRun, glyphRect, color, vertexStride, useColorVerts,
                             glyph);
     return true;
 }
 
 inline void GrAtlasTextContext::appendGlyphPath(BitmapTextBlob* blob, GrGlyph* glyph,
-                                                GrFontScaler* scaler, SkScalar x, SkScalar y) {
+                                                GrFontScaler* scaler, const SkGlyph& skGlyph,
+                                                SkScalar x, SkScalar y) {
     if (NULL == glyph->fPath) {
-        SkPath* path = SkNEW(SkPath);
-        if (!scaler->getGlyphPath(glyph->glyphID(), path)) {
-            // flag the glyph as being dead?
-            SkDELETE(path);
+        const SkPath* glyphPath = scaler->getGlyphPath(skGlyph);
+        if (!glyphPath) {
             return;
         }
-        glyph->fPath = path;
+
+        glyph->fPath = SkNEW_ARGS(SkPath, (*glyphPath));
     }
-    SkASSERT(glyph->fPath);
     blob->fBigGlyphs.push_back(BitmapTextBlob::BigGlyph(*glyph->fPath, x, y));
 }
 
 inline void GrAtlasTextContext::appendGlyphCommon(BitmapTextBlob* blob, Run* run,
                                                   Run::SubRunInfo* subRun,
                                                   const SkRect& positions, GrColor color,
                                                   size_t vertexStride, bool useVertexColor,
                                                   GrGlyph* glyph) {
     blob->fGlyphs[subRun->fGlyphEndIndex] = glyph;
     run->fVertexBounds.joinNonEmptyArg(positions);
@@ skipping 202 matching lines @@
         SkTypeface* typeface = NULL;
 
         for (int i = 0; i < instanceCount; i++) {
             Geometry& args = fGeoData[i];
             Blob* blob = args.fBlob;
             Run& run = blob->fRuns[args.fRun];
             TextInfo& info = run.fSubRunInfo[args.fSubRun];
 
             uint64_t currentAtlasGen = fFontCache->atlasGeneration(fMaskFormat);
             bool regenerateTextureCoords = info.fAtlasGeneration != currentAtlasGen ||
-                                           run.fStrike->isAbandoned();
+                                           info.fStrike->isAbandoned();
             bool regenerateColors;
             if (fUseDistanceFields) {
                 regenerateColors = !fUseLCDText && run.fColor != args.fColor;
             } else {
                 regenerateColors = kA8_GrMaskFormat == fMaskFormat && run.fColor != args.fColor;
             }
             bool regeneratePositions = args.fTransX != 0.f || args.fTransY != 0.f;
             int glyphCount = info.fGlyphEndIndex - info.fGlyphStartIndex;
 
             // We regenerate both texture coords and colors in the blob itself, and update the
@@ skipping 27 matching lines @@
                                                   run.fOverrideDescriptor->getDesc() :
                                                   run.fDescriptor.getDesc();
                     if (!cache || !SkTypeface::Equal(typeface, run.fTypeface) ||
                                   !(desc->equals(*newDesc))) {
                         if (cache) {
                             SkGlyphCache::AttachCache(cache);
                         }
                         desc = newDesc;
                         cache = SkGlyphCache::DetachCache(run.fTypeface, desc);
                         scaler = GrTextContext::GetGrFontScaler(cache);
-                        strike = run.fStrike;
+                        strike = info.fStrike;
                         typeface = run.fTypeface;
                     }
 
-                    if (run.fStrike->isAbandoned()) {
+                    if (info.fStrike->isAbandoned()) {
                         regenerateGlyphs = true;
                         strike = fFontCache->getStrike(scaler);
                     } else {
-                        strike = run.fStrike;
+                        strike = info.fStrike;
                     }
                 }
 
                 for (int glyphIdx = 0; glyphIdx < glyphCount; glyphIdx++) {
                     if (regenerateTextureCoords) {
                         size_t glyphOffset = glyphIdx + info.fGlyphStartIndex;
-                        GrGlyph* glyph;
+
+                        GrGlyph* glyph = blob->fGlyphs[glyphOffset];
+                        GrGlyph::PackedID id = glyph->fPackedID;
+                        const SkGlyph& skGlyph = scaler->grToSkGlyph(id);
                         if (regenerateGlyphs) {
                             // Get the id from the old glyph, and use the new strike to lookup
                             // the glyph.
-                            glyph = blob->fGlyphs[glyphOffset];
-                            blob->fGlyphs[glyphOffset] = strike->getGlyph(glyph->fPackedID,
+                            blob->fGlyphs[glyphOffset] = strike->getGlyph(skGlyph, id, fMaskFormat,
                                                                           scaler);
                         }
                         glyph = blob->fGlyphs[glyphOffset];
                         SkASSERT(glyph);
 
                         if (!fFontCache->hasGlyph(glyph) &&
-                            !strike->addGlyphToAtlas(batchTarget, glyph, scaler)) {
+                            !strike->addGlyphToAtlas(batchTarget, glyph, scaler, skGlyph,
+                                                     fMaskFormat)) {
                             this->flush(batchTarget, &flushInfo);
                             this->initDraw(batchTarget, gp, pipeline);
                             brokenRun = glyphIdx > 0;
 
                             SkDEBUGCODE(bool success =) strike->addGlyphToAtlas(batchTarget,
                                                                                 glyph,
-                                                                                scaler);
+                                                                                scaler,
+                                                                                skGlyph,
+                                                                                fMaskFormat);
                             SkASSERT(success);
                         }
                         fFontCache->addGlyphToBulkAndSetUseToken(&info.fBulkUseToken, glyph,
                                                                  batchTarget->currentToken());
 
                         // Texture coords are the last vertex attribute so we get a pointer to the
                         // first one and then map with stride in regenerateTextureCoords
                         intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices);
                         vertex += info.fVertexStartIndex;
                         vertex += vertexStride * glyphIdx * kVerticesPerGlyph;
@@ skipping 17 matching lines @@
                         SkScalar transY = args.fTransY;
                         this->regeneratePositions(vertex, vertexStride, transX, transY);
                     }
                     flushInfo.fGlyphsToFlush++;
                 }
 
                 // We my have changed the color so update it here
                 run.fColor = args.fColor;
                 if (regenerateTextureCoords) {
                     if (regenerateGlyphs) {
-                        run.fStrike.reset(SkRef(strike));
+                        info.fStrike.reset(SkRef(strike));
                     }
                     info.fAtlasGeneration = brokenRun ? GrBatchAtlas::kInvalidAtlasGeneration :
                                                         fFontCache->atlasGeneration(fMaskFormat);
                 }
             } else {
                 flushInfo.fGlyphsToFlush += glyphCount;
 
                 // set use tokens for all of the glyphs in our subrun.  This is only valid if we
                 // have a valid atlas generation
                 fFontCache->setUseTokenBulk(info.fBulkUseToken,
@@ skipping 558 matching lines @@
             gTextContext->createDrawTextBlob(rt, clip, grPaint, skPaint, viewMatrix, text,
                                              static_cast<size_t>(textLen), 0, 0, noClip));
 
     SkScalar transX = static_cast<SkScalar>(random->nextU());
     SkScalar transY = static_cast<SkScalar>(random->nextU());
     const GrAtlasTextContext::BitmapTextBlob::Run::SubRunInfo& info = blob->fRuns[0].fSubRunInfo[0];
     return gTextContext->createBatch(blob, info, textLen, 0, 0, color, transX, transY, skPaint);
 }
 
 #endif