Use sk_sp text blob APIs

src/gpu/text/GrStencilAndCoverTextContext.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrStencilAndCoverTextContext.h"
 #include "GrAtlasTextContext.h"
 #include "GrContext.h"
@@ skipping 326 matching lines @@
 class GrStencilAndCoverTextContext::FallbackBlobBuilder {
 public:
     FallbackBlobBuilder() : fBuffIdx(0), fCount(0) {}
 
     bool isInitialized() const { return fBuilder != nullptr; }
 
     void init(const SkPaint& font, SkScalar textRatio);
 
     void appendGlyph(uint16_t glyphId, const SkPoint& pos);
 
-    const SkTextBlob* buildIfNeeded(int* count);
+    sk_sp<SkTextBlob> makeIfNeeded(int* count);
 
 private:
     enum { kWriteBufferSize = 1024 };
 
     void flush();
 
     SkAutoTDelete<SkTextBlobBuilder>   fBuilder;
     SkPaint                            fFont;
     int                                fBuffIdx;
     int                                fCount;
@@ skipping 156 matching lines @@
         const SkGlyph& glyph = glyphCacheProc(glyphCache, &text);
         x += autokern.adjust(glyph) * fTextRatio;
         if (glyph.fWidth) {
             this->appendGlyph(glyph, SkPoint::Make(x, y), &fallback);
         }
 
         x += SkFloatToScalar(glyph.fAdvanceX) * fTextRatio;
         y += SkFloatToScalar(glyph.fAdvanceY) * fTextRatio;
     }
 
-    fFallbackTextBlob.reset(fallback.buildIfNeeded(&fFallbackGlyphCount));
+    fFallbackTextBlob = fallback.makeIfNeeded(&fFallbackGlyphCount);
 }
 
 void GrStencilAndCoverTextContext::TextRun::setPosText(const char text[], size_t byteLength,
                                                        const SkScalar pos[], int scalarsPerPosition,
                                                        const SkPoint& offset) {
     SkASSERT(byteLength == 0 || text != nullptr);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
     SkGlyphCache* glyphCache = this->getGlyphCache();
     SkPaint::GlyphCacheProc glyphCacheProc = SkPaint::GetGlyphCacheProc(fFont.getTextEncoding(),
@@ skipping 15 matching lines @@
             SkPoint tmsLoc;
             tmsProc(pos, &tmsLoc);
             SkPoint loc;
             alignProc(tmsLoc, glyph, &loc);
 
             this->appendGlyph(glyph, loc, &fallback);
         }
         pos += scalarsPerPosition;
     }
 
-    fFallbackTextBlob.reset(fallback.buildIfNeeded(&fFallbackGlyphCount));
+    fFallbackTextBlob = fallback.makeIfNeeded(&fFallbackGlyphCount);
 }
 
 GrPathRange* GrStencilAndCoverTextContext::TextRun::createGlyphs(GrContext* ctx) const {
     GrPathRange* glyphs = static_cast<GrPathRange*>(
             ctx->resourceProvider()->findAndRefResourceByUniqueKey(fGlyphPathsKey));
     if (nullptr == glyphs) {
         if (fUsingRawGlyphPaths) {
             SkScalerContextEffects noeffects;
             glyphs = ctx->resourceProvider()->createGlyphs(fFont.getTypeface(), noeffects,
                                                            nullptr, fStyle);
@@ skipping 76 matching lines @@
     }
 
     if (fFallbackTextBlob) {
         SkPaint fallbackSkPaint(originalSkPaint);
         fStyle.strokeRec().applyToPaint(&fallbackSkPaint);
         if (!fStyle.isSimpleFill()) {
             fallbackSkPaint.setStrokeWidth(fStyle.strokeRec().getWidth() * fTextRatio);
         }
 
         fallbackTextContext->drawTextBlob(ctx, drawContext, clip, fallbackSkPaint, viewMatrix,
-                                          props, fFallbackTextBlob, x, y, nullptr, clipBounds);
+                                          props, fFallbackTextBlob.get(), x, y, nullptr,
+                                          clipBounds);
     }
 }
 
 SkGlyphCache* GrStencilAndCoverTextContext::TextRun::getGlyphCache() const {
     if (!fDetachedGlyphCache) {
         fDetachedGlyphCache = fFont.detachCache(nullptr, SkPaint::kNone_ScalerContextFlags,
                                                 nullptr);
     }
     return fDetachedGlyphCache;
 }
@@ skipping 53 matching lines @@
     if (!fBuffIdx) {
         return;
     }
     // This will automatically merge with previous runs since we use the same font.
     const SkTextBlobBuilder::RunBuffer& buff = fBuilder->allocRunPos(fFont, fBuffIdx);
     memcpy(buff.glyphs, fGlyphIds, fBuffIdx * sizeof(uint16_t));
     memcpy(buff.pos, fPositions[0].asScalars(), fBuffIdx * 2 * sizeof(SkScalar));
     fBuffIdx = 0;
 }
 
-const SkTextBlob* GrStencilAndCoverTextContext::FallbackBlobBuilder::buildIfNeeded(int *count) {
+sk_sp<SkTextBlob> GrStencilAndCoverTextContext::FallbackBlobBuilder::makeIfNeeded(int *count) {
     *count = fCount;
     if (fCount) {
         this->flush();
-        return fBuilder->build();
+        return fBuilder->make();
     }
     return nullptr;
 }