SkPDF: s/SkAutoTUnref/sk_sp/g

src/pdf/SkPDFDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPDFDevice.h"
 
 #include "SkAnnotationKeys.h"
@@ skipping 862 matching lines @@
                 SkPDFUtils::ClosePath(&content.entry()->fContent);
                 SkPDFUtils::StrokePath(&content.entry()->fContent);
             }
             break;
         default:
             SkASSERT(false);
     }
 }
 
 static SkPDFDict* create_link_annotation(const SkRect& translatedRect) {
-    SkAutoTUnref<SkPDFDict> annotation(new SkPDFDict("Annot"));
+    sk_sp<SkPDFDict> annotation(new SkPDFDict("Annot"));
     annotation->insertName("Subtype", "Link");
 
-    SkAutoTUnref<SkPDFArray> border(new SkPDFArray);
+    sk_sp<SkPDFArray> border(new SkPDFArray);
     border->reserve(3);
     border->appendInt(0);  // Horizontal corner radius.
     border->appendInt(0);  // Vertical corner radius.
     border->appendInt(0);  // Width, 0 = no border.
     annotation->insertObject("Border", border.release());
 
-    SkAutoTUnref<SkPDFArray> rect(new SkPDFArray);
+    sk_sp<SkPDFArray> rect(new SkPDFArray);
     rect->reserve(4);
     rect->appendScalar(translatedRect.fLeft);
     rect->appendScalar(translatedRect.fTop);
     rect->appendScalar(translatedRect.fRight);
     rect->appendScalar(translatedRect.fBottom);
     annotation->insertObject("Rect", rect.release());
 
     return annotation.release();
 }
 
 static SkPDFDict* create_link_to_url(const SkData* urlData, const SkRect& r) {
-    SkAutoTUnref<SkPDFDict> annotation(create_link_annotation(r));
+    sk_sp<SkPDFDict> annotation(create_link_annotation(r));
 
     SkString url(static_cast<const char *>(urlData->data()),
                  urlData->size() - 1);
-    SkAutoTUnref<SkPDFDict> action(new SkPDFDict("Action"));
+    sk_sp<SkPDFDict> action(new SkPDFDict("Action"));
     action->insertName("S", "URI");
     action->insertString("URI", url);
     annotation->insertObject("A", action.release());
     return annotation.release();
 }
 
 static SkPDFDict* create_link_named_dest(const SkData* nameData,
                                          const SkRect& r) {
-    SkAutoTUnref<SkPDFDict> annotation(create_link_annotation(r));
+    sk_sp<SkPDFDict> annotation(create_link_annotation(r));
     SkString name(static_cast<const char *>(nameData->data()),
                   nameData->size() - 1);
     annotation->insertName("Dest", name);
     return annotation.release();
 }
 
 void SkPDFDevice::drawRect(const SkDraw& d,
                            const SkRect& rect,
                            const SkPaint& srcPaint) {
     SkPaint paint = srcPaint;
@@ skipping 210 matching lines @@
     // Compute matrix from the two rectangles
     if (src) {
         tmpSrc = *src;
     } else {
         tmpSrc = imageBounds;
     }
     matrix.setRectToRect(tmpSrc, dst, SkMatrix::kFill_ScaleToFit);
 
     // clip the tmpSrc to the bounds of the bitmap, and recompute dstRect if
     // needed (if the src was clipped). No check needed if src==null.
-    SkAutoTUnref<const SkImage> autoImageUnref;
+    sk_sp<const SkImage> autoImageUnref;
     if (src) {
         if (!imageBounds.contains(*src)) {
             if (!tmpSrc.intersect(imageBounds)) {
                 return; // nothing to draw
             }
             // recompute dst, based on the smaller tmpSrc
             matrix.mapRect(&tmpDst, tmpSrc);
         }
 
         // since we may need to clamp to the borders of the src rect within
@@ skipping 281 matching lines @@
         SkPath shape;
         shape.addRect(SkRect::MakeXYWH(SkIntToScalar(x), SkIntToScalar(y),
                                        SkIntToScalar(device->width()),
                                        SkIntToScalar(device->height())));
         content.setShape(shape);
     }
     if (!content.needSource()) {
         return;
     }
 
-    SkAutoTUnref<SkPDFFormXObject> xObject(new SkPDFFormXObject(pdfDevice));
+    sk_sp<SkPDFFormXObject> xObject(new SkPDFFormXObject(pdfDevice));
     SkPDFUtils::DrawFormXObject(this->addXObjectResource(xObject.get()),
                                 &content.entry()->fContent);
 
     // Merge glyph sets from the drawn device.
     fFontGlyphUsage->merge(pdfDevice->getFontGlyphUsage());
 }
 
 SkImageInfo SkPDFDevice::imageInfo() const {
     return fLegacyBitmap.info();
 }
@@ skipping 58 matching lines @@
             &fonts);
 }
 
 const SkTDArray<SkPDFFont*>& SkPDFDevice::getFontResources() const {
     return fFontResources;
 }
 
 SkPDFArray* SkPDFDevice::copyMediaBox() const {
     // should this be a singleton?
 
-    SkAutoTUnref<SkPDFArray> mediaBox(new SkPDFArray);
+    sk_sp<SkPDFArray> mediaBox(new SkPDFArray);
     mediaBox->reserve(4);
     mediaBox->appendInt(0);
     mediaBox->appendInt(0);
     mediaBox->appendInt(fPageSize.fWidth);
     mediaBox->appendInt(fPageSize.fHeight);
     return mediaBox.release();
 }
 
 SkStreamAsset* SkPDFDevice::content() const {
     SkDynamicMemoryWStream buffer;
@@ skipping 163 matching lines @@
     for (const RectWithData& linkToDestination : fLinkToDestinations) {
         SkRect r;
         fInitialTransform.mapRect(&r, linkToDestination.rect);
         array->appendObject(
                 create_link_named_dest(linkToDestination.data.get(), r));
     }
 }
 
 void SkPDFDevice::appendDestinations(SkPDFDict* dict, SkPDFObject* page) const {
     for (const NamedDestination& dest : fNamedDestinations) {
-        SkAutoTUnref<SkPDFArray> pdfDest(new SkPDFArray);
+        sk_sp<SkPDFArray> pdfDest(new SkPDFArray);
         pdfDest->reserve(5);
         pdfDest->appendObjRef(SkRef(page));
         pdfDest->appendName("XYZ");
         SkPoint p = fInitialTransform.mapXY(dest.point.x(), dest.point.y());
         pdfDest->appendScalar(p.x());
         pdfDest->appendScalar(p.y());
         pdfDest->appendInt(0);  // Leave zoom unchanged
         SkString name(static_cast<const char*>(dest.nameData->data()));
         dict->insertObject(name, pdfDest.release());
     }
@@ skipping 12 matching lines @@
 void SkPDFDevice::drawFormXObjectWithMask(int xObjectIndex,
                                           SkPDFFormXObject* mask,
                                           const SkClipStack* clipStack,
                                           const SkRegion& clipRegion,
                                           SkXfermode::Mode mode,
                                           bool invertClip) {
     if (clipRegion.isEmpty() && !invertClip) {
         return;
     }
 
-    SkAutoTUnref<SkPDFObject> sMaskGS(SkPDFGraphicState::GetSMaskGraphicState(
+    sk_sp<SkPDFObject> sMaskGS(SkPDFGraphicState::GetSMaskGraphicState(
             mask, invertClip, SkPDFGraphicState::kAlpha_SMaskMode));
 
     SkMatrix identity;
     identity.reset();
     SkPaint paint;
     paint.setXfermodeMode(mode);
     ScopedContentEntry content(this, clipStack, clipRegion, identity, paint);
     if (!content.entry()) {
         return;
     }
@@ skipping 143 matching lines @@
     // objects which is fine since the xobject will already be clipped. However
     // if source has shape, we need to clip it too, so a copy of the clip is
     // saved.
     SkClipStack clipStack = contentEntries->fState.fClipStack;
     SkRegion clipRegion = contentEntries->fState.fClipRegion;
 
     SkMatrix identity;
     identity.reset();
     SkPaint stockPaint;
 
-    SkAutoTUnref<SkPDFFormXObject> srcFormXObject;
+    sk_sp<SkPDFFormXObject> srcFormXObject;
     if (isContentEmpty()) {
         // If nothing was drawn and there's no shape, then the draw was a
         // no-op, but dst needs to be restored for that to be true.
         // If there is shape, then an empty source with Src, SrcIn, SrcOut,
         // DstIn, DstAtop or Modulate reduces to Clear and DstOut or SrcAtop
         // reduces to Dst.
         if (shape == nullptr || xfermode == SkXfermode::kDstOut_Mode ||
                 xfermode == SkXfermode::kSrcATop_Mode) {
             ScopedContentEntry content(this, &fExistingClipStack,
                                        fExistingClipRegion, identity,
@@ skipping 13 matching lines @@
     // without alpha.
     if (xfermode == SkXfermode::kSrcATop_Mode) {
         // TODO(vandebo): In order to properly support SrcATop we have to track
         // the shape of what's been drawn at all times. It's the intersection of
         // the non-transparent parts of the device and the outlines (shape) of
         // all images and devices drawn.
         drawFormXObjectWithMask(addXObjectResource(srcFormXObject.get()), dst,
                                 &fExistingClipStack, fExistingClipRegion,
                                 SkXfermode::kSrcOver_Mode, true);
     } else {
-        SkAutoTUnref<SkPDFFormXObject> dstMaskStorage;
+        sk_sp<SkPDFFormXObject> dstMaskStorage;
         SkPDFFormXObject* dstMask = srcFormXObject.get();
         if (shape != nullptr) {
             // Draw shape into a form-xobject.
             SkDraw d;
             d.fMatrix = &identity;
             d.fClip = &clipRegion;
             d.fClipStack = &clipStack;
             SkPaint filledPaint;
             filledPaint.setColor(SK_ColorBLACK);
             filledPaint.setStyle(SkPaint::kFill_Style);
@@ skipping 80 matching lines @@
     NOT_IMPLEMENTED(paint.getMaskFilter() != nullptr, false);
     NOT_IMPLEMENTED(paint.getColorFilter() != nullptr, false);
 
     entry->fMatrix = matrix;
     entry->fClipStack = clipStack;
     entry->fClipRegion = clipRegion;
     entry->fColor = SkColorSetA(paint.getColor(), 0xFF);
     entry->fShaderIndex = -1;
 
     // PDF treats a shader as a color, so we only set one or the other.
-    SkAutoTUnref<SkPDFObject> pdfShader;
+    sk_sp<SkPDFObject> pdfShader;
     const SkShader* shader = paint.getShader();
     SkColor color = paint.getColor();
     if (shader) {
         // PDF positions patterns relative to the initial transform, so
         // we need to apply the current transform to the shader parameters.
         SkMatrix transform = matrix;
         transform.postConcat(fInitialTransform);
 
         // PDF doesn't support kClamp_TileMode, so we simulate it by making
         // a pattern the size of the current clip.
@@ skipping 30 matching lines @@
             gradientInfo.fColorOffsets = nullptr;
             gradientInfo.fColorCount = 1;
             if (shader->asAGradient(&gradientInfo) ==
                     SkShader::kColor_GradientType) {
                 entry->fColor = SkColorSetA(gradientColor, 0xFF);
                 color = gradientColor;
             }
         }
     }
 
-    SkAutoTUnref<SkPDFGraphicState> newGraphicState;
+    sk_sp<SkPDFGraphicState> newGraphicState;
     if (color == paint.getColor()) {
         newGraphicState.reset(
                 SkPDFGraphicState::GetGraphicStateForPaint(fCanon, paint));
     } else {
         SkPaint newPaint = paint;
         newPaint.setColor(color);
         newGraphicState.reset(
                 SkPDFGraphicState::GetGraphicStateForPaint(fCanon, newPaint));
     }
     int resourceIndex = addGraphicStateResource(newGraphicState.get());
@@ skipping 43 matching lines @@
                 SkPDFResourceDict::kFont_ResourceType,
                 fontIndex).c_str());
         contentEntry->fContent.writeText(" ");
         SkPDFUtils::AppendScalar(paint.getTextSize(), &contentEntry->fContent);
         contentEntry->fContent.writeText(" Tf\n");
         contentEntry->fState.fFont = fFontResources[fontIndex];
     }
 }
 
 int SkPDFDevice::getFontResourceIndex(SkTypeface* typeface, uint16_t glyphID) {
-    SkAutoTUnref<SkPDFFont> newFont(
+    sk_sp<SkPDFFont> newFont(
             SkPDFFont::GetFontResource(fCanon, typeface, glyphID));
     int resourceIndex = fFontResources.find(newFont.get());
     if (resourceIndex < 0) {
         resourceIndex = fFontResources.count();
         fFontResources.push(newFont.get());
         newFont.get()->ref();
     }
     return resourceIndex;
 }
 
 static SkSize rect_to_size(const SkRect& r) {
     return SkSize::Make(r.width(), r.height());
 }
 
 static const SkImage* color_filter(const SkImage* image,
                                    SkColorFilter* colorFilter) {
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(
+    sk_sp<SkSurface> surface(SkSurface::NewRaster(
             SkImageInfo::MakeN32Premul(image->dimensions())));
     if (!surface) {
         return image;
     }
     SkCanvas* canvas = surface->getCanvas();
     canvas->clear(SK_ColorTRANSPARENT);
     SkPaint paint;
     paint.setColorFilter(colorFilter);
     canvas->drawImage(image, 0, 0, &paint);
     canvas->flush();
     return surface->newImageSnapshot();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 void SkPDFDevice::internalDrawImage(const SkMatrix& origMatrix,
                                     const SkClipStack* clipStack,
                                     const SkRegion& origClipRegion,
                                     const SkImage* image,
                                     const SkIRect* srcRect,
                                     const SkPaint& paint) {
     SkASSERT(image);
     #ifdef SK_PDF_IMAGE_STATS
     gDrawImageCalls.fetch_add(1);
     #endif
     SkMatrix matrix = origMatrix;
     SkRegion perspectiveBounds;
     const SkRegion* clipRegion = &origClipRegion;
-    SkAutoTUnref<const SkImage> autoImageUnref;
+    sk_sp<const SkImage> autoImageUnref;
 
     if (srcRect) {
         autoImageUnref.reset(image->newSubset(*srcRect));
         if (!autoImageUnref) {
             return;
         }
         image = autoImageUnref.get();
     }
     // Rasterize the bitmap using perspective in a new bitmap.
     if (origMatrix.hasPerspective()) {
@@ skipping 30 matching lines @@
 
         // TODO(edisonn): A better approach would be to use a bitmap shader
         // (in clamp mode) and draw a rect over the entire bounding box. Then
         // intersect perspectiveOutline to the clip. That will avoid introducing
         // alpha to the image while still giving good behavior at the edge of
         // the image.  Avoiding alpha will reduce the pdf size and generation
         // CPU time some.
 
         SkISize wh = rect_to_size(physicalPerspectiveBounds).toCeil();
 
-        SkAutoTUnref<SkSurface> surface(
+        sk_sp<SkSurface> surface(
                 SkSurface::NewRaster(SkImageInfo::MakeN32Premul(wh)));
         if (!surface) {
             return;
         }
         SkCanvas* canvas = surface->getCanvas();
         canvas->clear(SK_ColorTRANSPARENT);
 
         SkScalar deltaX = bounds.left();
         SkScalar deltaY = bounds.top();
 
@@ skipping 48 matching lines @@
         // TODO(https://bug.skia.org/4378): implement colorfilter on other
         // draw calls.  This code here works for all
         // drawBitmap*()/drawImage*() calls amd ImageFilters (which
         // rasterize a layer on this backend).  Fortuanely, this seems
         // to be how Chromium impements most color-filters.
         autoImageUnref.reset(color_filter(image, colorFilter));
         image = autoImageUnref.get();
         // TODO(halcanary): de-dupe this by caching filtered images.
         // (maybe in the resource cache?)
     }
-    SkAutoTUnref<SkPDFObject> pdfimage(SkSafeRef(fCanon->findPDFBitmap(image)));
+    sk_sp<SkPDFObject> pdfimage(SkSafeRef(fCanon->findPDFBitmap(image)));
     if (!pdfimage) {
         pdfimage.reset(SkPDFCreateBitmapObject(
                                image, fCanon->getPixelSerializer()));
         if (!pdfimage) {
             return;
         }
         fCanon->addPDFBitmap(image->uniqueID(), pdfimage.get());
     }
     SkPDFUtils::DrawFormXObject(this->addXObjectResource(pdfimage.get()),
                                 &content.entry()->fContent);
 }