Use sk_sp text blob APIs

tests/TextBlobCacheTest.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 "sk_tool_utils.h"
 
 #include "SkCanvas.h"
 #include "SkPaint.h"
 #include "SkPoint.h"
 #include "SkTextBlob.h"
 #include "SkFontMgr.h"
 #include "SkGraphics.h"
 #include "SkSurface.h"
 #include "SkTypeface.h"
 #include "../src/fonts/SkRandomScalerContext.h"
 
 #ifdef SK_BUILD_FOR_WIN
     #include "SkTypeface_win.h"
 #endif
 
 #include "Test.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrTest.h"
 
-struct TextBlobWrapper {
-    // This class assumes it 'owns' the textblob it wraps, and thus does not need to take a ref
-    explicit TextBlobWrapper(const SkTextBlob* blob) : fBlob(blob) {}
-    TextBlobWrapper(const TextBlobWrapper& blob) : fBlob(SkRef(blob.fBlob.get())) {}
-
-    SkAutoTUnref<const SkTextBlob> fBlob;
-};
-
-static void draw(SkCanvas* canvas, int redraw, const SkTArray<TextBlobWrapper>& blobs) {
+static void draw(SkCanvas* canvas, int redraw, const SkTArray<sk_sp<SkTextBlob>>& blobs) {
     int yOffset = 0;
     for (int r = 0; r < redraw; r++) {
         for (int i = 0; i < blobs.count(); i++) {
-            const SkTextBlob* blob = blobs[i].fBlob.get();
+            const auto& blob = blobs[i];
             const SkRect& bounds = blob->bounds();
             yOffset += SkScalarCeilToInt(bounds.height());
             SkPaint paint;
             canvas->drawTextBlob(blob, 0, SkIntToScalar(yOffset), paint);
         }
     }
 }
 
 static const int kWidth = 1024;
 static const int kHeight = 768;
@@ skipping 25 matching lines @@
 
     int count = SkMin32(fm->countFamilies(), maxFamilies);
 
     // make a ton of text
     SkAutoTArray<uint16_t> text(maxTotalText);
     for (int i = 0; i < maxTotalText; i++) {
         text[i] = i % maxGlyphID;
     }
 
     // generate textblobs
-    SkTArray<TextBlobWrapper> blobs;
+    SkTArray<sk_sp<SkTextBlob>> blobs;
     for (int i = 0; i < count; i++) {
         SkPaint paint;
         paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
         paint.setTextSize(48); // draw big glyphs to really stress the atlas
 
         SkString familyName;
         fm->getFamilyName(i, &familyName);
         SkAutoTUnref<SkFontStyleSet> set(fm->createStyleSet(i));
         for (int j = 0; j < set->count(); ++j) {
             SkFontStyle fs;
@@ skipping 18 matching lines @@
                             paint.setTextSize(160);
                         }
                         const SkTextBlobBuilder::RunBuffer& run = builder.allocRun(paint,
                                                                                    maxTotalText,
                                                                                    0, 0,
                                                                                    nullptr);
                         memcpy(run.glyphs, text.get(), maxTotalText * sizeof(uint16_t));
                     }
                 }
             }
-            blobs.emplace_back(builder.build());
+            blobs.emplace_back(builder.make());
         }
     }
 
     // create surface where LCD is impossible
     info = SkImageInfo::MakeN32Premul(kWidth, kHeight);
     SkSurfaceProps propsNoLCD(0, kUnknown_SkPixelGeometry);
     auto surfaceNoLCD(canvas->makeSurface(info, &propsNoLCD));
     REPORTER_ASSERT(reporter, surface);
     if (!surface) {
         return;
@@ skipping 26 matching lines @@
 }
 
 DEF_GPUTEST_FOR_NULLGL_CONTEXT(TextBlobAbnormal, reporter, ctxInfo) {
     text_blob_cache_inner(reporter, ctxInfo.grContext(), 256, 256, 10, false, false);
 }
 
 DEF_GPUTEST_FOR_NULLGL_CONTEXT(TextBlobStressAbnormal, reporter, ctxInfo) {
     text_blob_cache_inner(reporter, ctxInfo.grContext(), 256, 256, 10, false, true);
 }
 #endif