src/core: s/SkAutoTUnref/sk_sp/g

BUG=skia:

GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=4492

Change-Id: I753ad01b03e891221965252e3befe280d09cdb9f
Reviewed-on: https://skia-review.googlesource.com/4492
Reviewed-by: Ben Wagner <bungeman@google.com>
Commit-Queue: Hal Canary <halcanary@google.com>

16 files changed, 59 insertions, 58 deletions

diff --git a/src/core/SkBigPicture.h b/src/core/SkBigPicture.h
index 3dde1479d7..265df397d1 100644
--- a/src/core/SkBigPicture.h
+++ b/src/core/SkBigPicture.h
@@ -54,8 +54,8 @@ public:
                          int stop,
                          const SkMatrix& initialCTM) const;
 // Used by GrRecordReplaceDraw
-    const SkBBoxHierarchy* bbh() const { return fBBH; }
-    const SkRecord*     record() const { return fRecord; }
+    const SkBBoxHierarchy* bbh() const { return fBBH.get(); }
+    const SkRecord*     record() const { return fRecord.get(); }
 
 private:
     struct Analysis {
@@ -72,13 +72,13 @@ private:
     int drawableCount() const;
     SkPicture const* const* drawablePicts() const;
 
-    const SkRect                          fCullRect;
-    const size_t                          fApproxBytesUsedBySubPictures;
-    mutable SkOnce                        fAnalysisOnce;
-    mutable Analysis                      fAnalysis;
-    SkAutoTUnref<const SkRecord>          fRecord;
-    std::unique_ptr<const SnapshotArray>  fDrawablePicts;
-    SkAutoTUnref<const SkBBoxHierarchy>   fBBH;
+    const SkRect                         fCullRect;
+    const size_t                         fApproxBytesUsedBySubPictures;
+    mutable SkOnce                       fAnalysisOnce;
+    mutable Analysis                     fAnalysis;
+    sk_sp<const SkRecord>                fRecord;
+    std::unique_ptr<const SnapshotArray> fDrawablePicts;
+    sk_sp<const SkBBoxHierarchy>         fBBH;
 };
 
 #endif//SkBigPicture_DEFINED
diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp
index beeda4fb42..7ea49a8c6c 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -803,11 +803,11 @@ bool SkBitmap::copyTo(SkBitmap* dst, SkColorType dstColorType, Allocator* alloc)
     }
 
     // allocate colortable if srcConfig == kIndex8_Config
-    SkAutoTUnref<SkColorTable> ctable;
+    sk_sp<SkColorTable> ctable;
     if (dstColorType == kIndex_8_SkColorType) {
         ctable.reset(SkRef(srcPM.ctable()));
     }
-    if (!tmpDst.tryAllocPixels(alloc, ctable)) {
+    if (!tmpDst.tryAllocPixels(alloc, ctable.get())) {
         return false;
     }
 
@@ -1021,7 +1021,7 @@ bool SkBitmap::ReadRawPixels(SkReadBuffer* buffer, SkBitmap* bitmap) {
         SkASSERT(srcRow == dstRow); // first row does not need to be moved
     }
 
-    SkAutoTUnref<SkColorTable> ctable;
+    sk_sp<SkColorTable> ctable;
     if (buffer->readBool()) {
         ctable.reset(SkColorTable::Create(*buffer));
         if (!ctable) {
@@ -1047,13 +1047,13 @@ bool SkBitmap::ReadRawPixels(SkReadBuffer* buffer, SkBitmap* bitmap) {
         }
     }
 
-    SkAutoTUnref<SkPixelRef> pr(SkMallocPixelRef::NewWithData(info, info.minRowBytes(),
-                                                              ctable.get(), data.get()));
+    sk_sp<SkPixelRef> pr(SkMallocPixelRef::NewWithData(info, info.minRowBytes(),
+                                                       ctable.get(), data.get()));
     if (!pr.get()) {
         return false;
     }
     bitmap->setInfo(pr->info());
-    bitmap->setPixelRef(pr, 0, 0);
+    bitmap->setPixelRef(pr.get(), 0, 0);
     return true;
 }
 
diff --git a/src/core/SkBitmapController.cpp b/src/core/SkBitmapController.cpp
index f4ee0fb6c1..ffeb10c8af 100644
--- a/src/core/SkBitmapController.cpp
+++ b/src/core/SkBitmapController.cpp
@@ -48,9 +48,9 @@ public:
                                    SkSourceGammaTreatment);
 
 private:
-    SkBitmap                     fResultBitmap;
-    SkSourceGammaTreatment       fSrcGammaTreatment;
-    SkAutoTUnref<const SkMipMap> fCurrMip;
+    SkBitmap               fResultBitmap;
+    SkSourceGammaTreatment fSrcGammaTreatment;
+    sk_sp<const SkMipMap>  fCurrMip;
 
     bool processHQRequest(const SkBitmapProvider&);
     bool processMediumRequest(const SkBitmapProvider&);
diff --git a/src/core/SkBitmapDevice.cpp b/src/core/SkBitmapDevice.cpp
index 78dff36b0d..e44b76926a 100644
--- a/src/core/SkBitmapDevice.cpp
+++ b/src/core/SkBitmapDevice.cpp
@@ -394,7 +394,7 @@ void SkBitmapDevice::drawSpecial(const SkDraw& draw, SkSpecialImage* srcImg, int
         SkMatrix matrix = *draw.fMatrix;
         matrix.postTranslate(SkIntToScalar(-x), SkIntToScalar(-y));
         const SkIRect clipBounds = draw.fRC->getBounds().makeOffset(-x, -y);
-        SkAutoTUnref<SkImageFilterCache> cache(this->getImageFilterCache());
+        sk_sp<SkImageFilterCache> cache(this->getImageFilterCache());
         SkImageFilter::OutputProperties outputProperties(fBitmap.colorSpace());
         SkImageFilter::Context ctx(matrix, clipBounds, cache.get(), outputProperties);
 
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index c42ee860f3..cd4dcbc2a5 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -762,8 +762,8 @@ SkCanvas::SkCanvas(const SkBitmap& bitmap, const SkSurfaceProps& props)
 {
     inc_canvas();
 
-    SkAutoTUnref<SkBaseDevice> device(new SkBitmapDevice(bitmap, fProps));
-    this->init(device, kDefault_InitFlags);
+    sk_sp<SkBaseDevice> device(new SkBitmapDevice(bitmap, fProps));
+    this->init(device.get(), kDefault_InitFlags);
 }
 
 SkCanvas::SkCanvas(const SkBitmap& bitmap)
@@ -773,8 +773,8 @@ SkCanvas::SkCanvas(const SkBitmap& bitmap)
 {
     inc_canvas();
 
-    SkAutoTUnref<SkBaseDevice> device(new SkBitmapDevice(bitmap, fProps));
-    this->init(device, kDefault_InitFlags);
+    sk_sp<SkBaseDevice> device(new SkBitmapDevice(bitmap, fProps));
+    this->init(device.get(), kDefault_InitFlags);
 }
 
 SkCanvas::~SkCanvas() {
@@ -1248,7 +1248,7 @@ void SkCanvas::internalSaveLayer(const SaveLayerRec& rec, SaveLayerStrategy stra
     SkImageInfo info = make_layer_info(priorDevice->imageInfo(), ir.width(), ir.height(), isOpaque,
                                        paint);
 
-    SkAutoTUnref<SkBaseDevice> newDevice;
+    sk_sp<SkBaseDevice> newDevice;
     {
         const bool preserveLCDText = kOpaque_SkAlphaType == info.alphaType() ||
                                      (saveLayerFlags & kPreserveLCDText_SaveLayerFlag);
@@ -1262,14 +1262,15 @@ void SkCanvas::internalSaveLayer(const SaveLayerRec& rec, SaveLayerStrategy stra
     }
     newDevice->setOrigin(ir.fLeft, ir.fTop);
 
-    DeviceCM* layer = new DeviceCM(newDevice, paint, this, fConservativeRasterClip, stashedMatrix);
+    DeviceCM* layer =
+            new DeviceCM(newDevice.get(), paint, this, fConservativeRasterClip, stashedMatrix);
 
     layer->fNext = fMCRec->fTopLayer;
     fMCRec->fLayer = layer;
     fMCRec->fTopLayer = layer;    // this field is NOT an owner of layer
 
     if (rec.fBackdrop) {
-        DrawDeviceWithFilter(priorDevice, rec.fBackdrop, newDevice,
+        DrawDeviceWithFilter(priorDevice, rec.fBackdrop, newDevice.get(),
                              fMCRec->fMatrix, this->getClipStack());
     }
 }
diff --git a/src/core/SkConfig8888.cpp b/src/core/SkConfig8888.cpp
index 7c3f0214e3..639a444181 100644
--- a/src/core/SkConfig8888.cpp
+++ b/src/core/SkConfig8888.cpp
@@ -354,7 +354,7 @@ bool SkPixelInfo::CopyPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t
         if (!bm.installPixels(srcInfo, const_cast<void*>(srcPixels), srcRB, ctable, nullptr, nullptr)) {
             return false;
         }
-        SkAutoTUnref<SkCanvas> canvas(SkCanvas::NewRasterDirect(dstInfo, dstPixels, dstRB));
+        sk_sp<SkCanvas> canvas(SkCanvas::NewRasterDirect(dstInfo, dstPixels, dstRB));
         if (nullptr == canvas.get()) {
             return false;
         }
diff --git a/src/core/SkImageCacherator.cpp b/src/core/SkImageCacherator.cpp
index 124da389dc..9401b35c9f 100644
--- a/src/core/SkImageCacherator.cpp
+++ b/src/core/SkImageCacherator.cpp
@@ -190,7 +190,7 @@ bool SkImageCacherator::lockAsBitmap(SkBitmap* bitmap, const SkImage* client,
 
 #if SK_SUPPORT_GPU
     // Try to get a texture and read it back to raster (and then cache that with our ID)
-    SkAutoTUnref<GrTexture> tex;
+    sk_sp<GrTexture> tex;
 
     {
         ScopedGenerator generator(fSharedGenerator);
diff --git a/src/core/SkImageFilterCache.cpp b/src/core/SkImageFilterCache.cpp
index c7104def37..889e81f9d2 100644
--- a/src/core/SkImageFilterCache.cpp
+++ b/src/core/SkImageFilterCache.cpp
@@ -41,7 +41,7 @@ public:
             : fKey(key), fImage(SkRef(image)), fOffset(offset) {}
 
         Key fKey;
-        SkAutoTUnref<SkSpecialImage> fImage;
+        sk_sp<SkSpecialImage> fImage;
         SkIPoint fOffset;
         static const Key& GetKey(const Value& v) {
             return v.fKey;
@@ -60,7 +60,7 @@ public:
                 fLRU.remove(v);
                 fLRU.addToHead(v);
             }
-            return v->fImage;
+            return v->fImage.get();
         }
         return nullptr;
     }
diff --git a/src/core/SkImageGenerator.cpp b/src/core/SkImageGenerator.cpp
index 84d9c743eb..ffa845b4db 100644
--- a/src/core/SkImageGenerator.cpp
+++ b/src/core/SkImageGenerator.cpp
@@ -140,14 +140,14 @@ bool SkImageGenerator::tryGenerateBitmap(SkBitmap* bitmap, const SkImageInfo* in
 
     SkPMColor ctStorage[256];
     memset(ctStorage, 0xFF, sizeof(ctStorage)); // init with opaque-white for the moment
-    SkAutoTUnref<SkColorTable> ctable(new SkColorTable(ctStorage, 256));
-    if (!bitmap->tryAllocPixels(allocator, ctable)) {
+    sk_sp<SkColorTable> ctable(new SkColorTable(ctStorage, 256));
+    if (!bitmap->tryAllocPixels(allocator, ctable.get())) {
         // SkResourceCache's custom allcator can'thandle ctables, so it may fail on
         // kIndex_8_SkColorTable.
         // https://bug.skia.org/4355
 #if 1
         // ignroe the allocator, and see if we can succeed without it
-        if (!bitmap->tryAllocPixels(nullptr, ctable)) {
+        if (!bitmap->tryAllocPixels(nullptr, ctable.get())) {
             return reset_and_return_false(bitmap);
         }
 #else
diff --git a/src/core/SkPictureImageGenerator.cpp b/src/core/SkPictureImageGenerator.cpp
index 68742caac2..22baf53be7 100644
--- a/src/core/SkPictureImageGenerator.cpp
+++ b/src/core/SkPictureImageGenerator.cpp
@@ -35,9 +35,9 @@ protected:
 private:
     SkPictureImageGenerator(const SkISize&, const SkPicture*, const SkMatrix*, const SkPaint*);
 
-    SkAutoTUnref<const SkPicture> fPicture;
-    SkMatrix                      fMatrix;
-    SkTLazy<SkPaint>              fPaint;
+    sk_sp<const SkPicture> fPicture;
+    SkMatrix               fMatrix;
+    SkTLazy<SkPaint>       fPaint;
 
     typedef SkImageGenerator INHERITED;
 };
@@ -80,7 +80,7 @@ bool SkPictureImageGenerator::onGetPixels(const SkImageInfo& info, void* pixels,
 
     bitmap.eraseColor(SK_ColorTRANSPARENT);
     SkCanvas canvas(bitmap, SkSurfaceProps(0, kUnknown_SkPixelGeometry));
-    canvas.drawPicture(fPicture, &fMatrix, fPaint.getMaybeNull());
+    canvas.drawPicture(fPicture.get(), &fMatrix, fPaint.getMaybeNull());
 
     return true;
 }
@@ -119,7 +119,7 @@ bool SkPictureImageGenerator::onGenerateScaledPixels(const SkISize& scaledSize,
     bitmap.eraseColor(SK_ColorTRANSPARENT);
     SkCanvas canvas(bitmap, SkSurfaceProps(0, kUnknown_SkPixelGeometry));
     matrix.preConcat(fMatrix);
-    canvas.drawPicture(fPicture, &matrix, fPaint.getMaybeNull());
+    canvas.drawPicture(fPicture.get(), &matrix, fPaint.getMaybeNull());
     return true;
 }
 
@@ -152,7 +152,7 @@ GrTexture* SkPictureImageGenerator::onGenerateTexture(GrContext* ctx, const SkIR
         matrix.postTranslate(-subset->x(), -subset->y());
     }
     surface->getCanvas()->clear(0); // does NewRenderTarget promise to do this for us?
-    surface->getCanvas()->drawPicture(fPicture, &matrix, fPaint.getMaybeNull());
+    surface->getCanvas()->drawPicture(fPicture.get(), &matrix, fPaint.getMaybeNull());
     sk_sp<SkImage> image(surface->makeImageSnapshot());
     if (!image) {
         return nullptr;
diff --git a/src/core/SkPictureShader.cpp b/src/core/SkPictureShader.cpp
index c7ceb76620..ad954d29df 100644
--- a/src/core/SkPictureShader.cpp
+++ b/src/core/SkPictureShader.cpp
@@ -68,9 +68,9 @@ struct BitmapShaderRec : public SkResourceCache::Rec {
         : fKey(key)
         , fShader(SkRef(tileShader)) {}
 
-    BitmapShaderKey        fKey;
-    SkAutoTUnref<SkShader> fShader;
-    size_t                 fBitmapBytes;
+    BitmapShaderKey fKey;
+    sk_sp<SkShader> fShader;
+    size_t          fBitmapBytes;
 
     const Key& getKey() const override { return fKey; }
     size_t bytesUsed() const override {
@@ -82,9 +82,9 @@ struct BitmapShaderRec : public SkResourceCache::Rec {
 
     static bool Visitor(const SkResourceCache::Rec& baseRec, void* contextShader) {
         const BitmapShaderRec& rec = static_cast<const BitmapShaderRec&>(baseRec);
-        SkAutoTUnref<SkShader>* result = reinterpret_cast<SkAutoTUnref<SkShader>*>(contextShader);
+        sk_sp<SkShader>* result = reinterpret_cast<sk_sp<SkShader>*>(contextShader);
 
-        result->reset(SkRef(rec.fShader.get()));
+        *result = rec.fShader;
 
         // The bitmap shader is backed by an image generator, thus it can always re-generate its
         // pixels if discarded.
diff --git a/src/core/SkRWBuffer.cpp b/src/core/SkRWBuffer.cpp
index e69070b5f9..c97b646c15 100644
--- a/src/core/SkRWBuffer.cpp
+++ b/src/core/SkRWBuffer.cpp
@@ -355,6 +355,6 @@ private:
 };
 
 SkStreamAsset* SkRWBuffer::newStreamSnapshot() const {
-    SkAutoTUnref<SkROBuffer> buffer(this->newRBufferSnapshot());
-    return new SkROBufferStreamAsset(buffer);
+    sk_sp<SkROBuffer> buffer(this->newRBufferSnapshot());
+    return new SkROBufferStreamAsset(buffer.get());
 }
diff --git a/src/core/SkSpecialSurface.cpp b/src/core/SkSpecialSurface.cpp
index b719be2969..beba9150c4 100644
--- a/src/core/SkSpecialSurface.cpp
+++ b/src/core/SkSpecialSurface.cpp
@@ -24,12 +24,12 @@ public:
     void reset() { fCanvas.reset(); }
 
     // This can return nullptr if reset has already been called or something when wrong in the ctor
-    SkCanvas* onGetCanvas() { return fCanvas; }
+    SkCanvas* onGetCanvas() { return fCanvas.get(); }
 
     virtual sk_sp<SkSpecialImage> onMakeImageSnapshot() = 0;
 
 protected:
-    SkAutoTUnref<SkCanvas> fCanvas;   // initialized by derived classes in ctors
+    sk_sp<SkCanvas> fCanvas;   // initialized by derived classes in ctors
 
 private:
     typedef SkSpecialSurface INHERITED;
@@ -98,14 +98,14 @@ sk_sp<SkSpecialSurface> SkSpecialSurface::MakeFromBitmap(const SkIRect& subset,
 
 sk_sp<SkSpecialSurface> SkSpecialSurface::MakeRaster(const SkImageInfo& info,
                                                      const SkSurfaceProps* props) {
-    SkAutoTUnref<SkPixelRef> pr(SkMallocPixelRef::NewZeroed(info, 0, nullptr));
+    sk_sp<SkPixelRef> pr(SkMallocPixelRef::NewZeroed(info, 0, nullptr));
     if (nullptr == pr.get()) {
         return nullptr;
     }
 
     const SkIRect subset = SkIRect::MakeWH(pr->info().width(), pr->info().height());
 
-    return sk_make_sp<SkSpecialSurface_Raster>(pr, subset, props);
+    return sk_make_sp<SkSpecialSurface_Raster>(pr.get(), subset, props);
 }
 
 #if SK_SUPPORT_GPU
diff --git a/src/core/SkStream.cpp b/src/core/SkStream.cpp
index 41d1a86ff3..060e0942e2 100644
--- a/src/core/SkStream.cpp
+++ b/src/core/SkStream.cpp
@@ -787,7 +787,7 @@ public:
     }
 
 private:
-    SkAutoTUnref<SkBlockMemoryRefCnt> const fBlockMemory;
+    sk_sp<SkBlockMemoryRefCnt> const fBlockMemory;
     SkDynamicMemoryWStream::Block const * fCurrent;
     size_t const fSize;
     size_t fOffset;
diff --git a/src/core/SkTextBlob.cpp b/src/core/SkTextBlob.cpp
index ca75a2e038..4065771862 100644
--- a/src/core/SkTextBlob.cpp
+++ b/src/core/SkTextBlob.cpp
@@ -71,7 +71,7 @@ private:
     SkScalar                 fSize;
     SkScalar                 fScaleX;
 
-    // Keep this SkAutoTUnref off the first position, to avoid interfering with SkNoncopyable
+    // Keep this sk_sp off the first position, to avoid interfering with SkNoncopyable
     // empty baseclass optimization (http://code.google.com/p/skia/issues/detail?id=3694).
     sk_sp<SkTypeface>        fTypeface;
     SkScalar                 fSkewX;
diff --git a/src/core/SkTypeface.cpp b/src/core/SkTypeface.cpp
index e1cd2b5408..70c0c76d06 100644
--- a/src/core/SkTypeface.cpp
+++ b/src/core/SkTypeface.cpp
@@ -87,7 +87,7 @@ SkTypeface* SkTypeface::GetDefaultTypeface(Style style) {
 
     SkASSERT((int)style < 4);
     once[style]([style] {
-        SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
+        sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
         SkTypeface* t = fm->legacyCreateTypeface(nullptr, SkFontStyle::FromOldStyle(style));
         defaults[style] = t ? t : SkEmptyTypeface::Create();
     });
@@ -129,7 +129,7 @@ sk_sp<SkTypeface> SkTypeface::MakeFromName(const char name[],
             (fontStyle.weight() == SkFontStyle::kBold_Weight ? SkTypeface::kBold :
                                                                SkTypeface::kNormal)));
     }
-    SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
+    sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
     return sk_sp<SkTypeface>(fm->legacyCreateTypeface(name, fontStyle));
 }
 
@@ -142,22 +142,22 @@ sk_sp<SkTypeface> SkTypeface::MakeFromTypeface(SkTypeface* family, Style s) {
         return sk_ref_sp(family);
     }
 
-    SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
+    sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
     return sk_sp<SkTypeface>(fm->matchFaceStyle(family, SkFontStyle::FromOldStyle(s)));
 }
 
 sk_sp<SkTypeface> SkTypeface::MakeFromStream(SkStreamAsset* stream, int index) {
-    SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
+    sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
     return sk_sp<SkTypeface>(fm->createFromStream(stream, index));
 }
 
 sk_sp<SkTypeface> SkTypeface::MakeFromFontData(std::unique_ptr<SkFontData> data) {
-    SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
+    sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
     return sk_sp<SkTypeface>(fm->createFromFontData(std::move(data)));
 }
 
 sk_sp<SkTypeface> SkTypeface::MakeFromFile(const char path[], int index) {
-    SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
+    sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
     return sk_sp<SkTypeface>(fm->createFromFile(path, index));
 }