SkPDF: use sk_make_sp<T> when it makes sense.

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) {
-    sk_sp<SkPDFDict> annotation(new SkPDFDict("Annot"));
+    auto annotation = sk_make_sp<SkPDFDict>("Annot");
     annotation->insertName("Subtype", "Link");
 
-    sk_sp<SkPDFArray> border(new SkPDFArray);
+    auto border = sk_make_sp<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());
 
-    sk_sp<SkPDFArray> rect(new SkPDFArray);
+    auto rect = sk_make_sp<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) {
     sk_sp<SkPDFDict> annotation(create_link_annotation(r));
 
     SkString url(static_cast<const char *>(urlData->data()),
                  urlData->size() - 1);
-    sk_sp<SkPDFDict> action(new SkPDFDict("Action"));
+    auto action = sk_make_sp<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) {
     sk_sp<SkPDFDict> annotation(create_link_annotation(r));
     SkString name(static_cast<const char *>(nameData->data()),
@@ skipping 521 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;
     }
 
-    sk_sp<SkPDFFormXObject> xObject(new SkPDFFormXObject(pdfDevice));
+    auto xObject = sk_make_sp<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?
 
-    sk_sp<SkPDFArray> mediaBox(new SkPDFArray);
+    auto mediaBox = sk_make_sp<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) {
-        sk_sp<SkPDFArray> pdfDest(new SkPDFArray);
+        auto pdfDest = sk_make_sp<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 603 matching lines @@
         pdfimage.reset(SkPDFCreateBitmapObject(
                                image, fCanon->getPixelSerializer()));
         if (!pdfimage) {
             return;
         }
         fCanon->addPDFBitmap(image->uniqueID(), pdfimage.get());
     }
     SkPDFUtils::DrawFormXObject(this->addXObjectResource(pdfimage.get()),
                                 &content.entry()->fContent);
 }