SkPDF: Add sk_sp setters; .release() becomes std::move()

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 861 matching lines @@
                                    &content.entry()->fContent);
                 SkPDFUtils::ClosePath(&content.entry()->fContent);
                 SkPDFUtils::StrokePath(&content.entry()->fContent);
             }
             break;
         default:
             SkASSERT(false);
     }
 }
 
-static SkPDFDict* create_link_annotation(const SkRect& translatedRect) {
+static sk_sp<SkPDFDict> create_link_annotation(const SkRect& translatedRect) {
     auto annotation = sk_make_sp<SkPDFDict>("Annot");
     annotation->insertName("Subtype", "Link");
 
     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());
+    annotation->insertObject("Border", std::move(border));
 
     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());
+    annotation->insertObject("Rect", std::move(rect));
 
-    return annotation.release();
+    return annotation;
 }
 
-static SkPDFDict* create_link_to_url(const SkData* urlData, const SkRect& r) {
-    sk_sp<SkPDFDict> annotation(create_link_annotation(r));
-
+static sk_sp<SkPDFDict> create_link_to_url(const SkData* urlData, const SkRect& r) {
+    auto annotation = create_link_annotation(r);
     SkString url(static_cast<const char *>(urlData->data()),
                  urlData->size() - 1);
     auto action = sk_make_sp<SkPDFDict>("Action");
     action->insertName("S", "URI");
     action->insertString("URI", url);
-    annotation->insertObject("A", action.release());
-    return annotation.release();
+    annotation->insertObject("A", std::move(action));
+    return annotation;
 }
 
-static SkPDFDict* create_link_named_dest(const SkData* nameData,
-                                         const SkRect& r) {
-    sk_sp<SkPDFDict> annotation(create_link_annotation(r));
+static sk_sp<SkPDFDict> create_link_named_dest(const SkData* nameData,
+                                               const SkRect& r) {
+    auto  annotation = create_link_annotation(r);
     SkString name(static_cast<const char *>(nameData->data()),
                   nameData->size() - 1);
     annotation->insertName("Dest", name);
-    return annotation.release();
+    return annotation;
 }
 
 void SkPDFDevice::drawRect(const SkDraw& d,
                            const SkRect& rect,
                            const SkPaint& srcPaint) {
     SkPaint paint = srcPaint;
     replace_srcmode_on_opaque_paint(&paint);
     SkRect r = rect;
     r.sort();
 
@@ skipping 567 matching lines @@
         fLastMarginContentEntry = contentEntry;
     }
 }
 
 void SkPDFDevice::setDrawingArea(DrawingArea drawingArea) {
     // A ScopedContentEntry only exists during the course of a draw call, so
     // this can't be called while a ScopedContentEntry exists.
     fDrawingArea = drawingArea;
 }
 
-SkPDFDict* SkPDFDevice::createResourceDict() const {
+sk_sp<SkPDFDict> SkPDFDevice::makeResourceDict() const {
     SkTDArray<SkPDFObject*> fonts;
     fonts.setReserve(fFontResources.count());
     for (SkPDFFont* font : fFontResources) {
         fonts.push(font);
     }
-    return SkPDFResourceDict::Create(
+    return SkPDFResourceDict::Make(
             &fGraphicStateResources,
             &fShaderResources,
             &fXObjectResources,
             &fonts);
 }
 
 const SkTDArray<SkPDFFont*>& SkPDFDevice::getFontResources() const {
     return fFontResources;
 }
 
-SkPDFArray* SkPDFDevice::copyMediaBox() const {
-    // should this be a singleton?
-
+sk_sp<SkPDFArray> SkPDFDevice::copyMediaBox() const {
     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();
+    mediaBox->appendInt(fPageSize.width());
+    mediaBox->appendInt(fPageSize.height());
+    return mediaBox;
 }
 
-SkStreamAsset* SkPDFDevice::content() const {
+skstd::unique_ptr<SkStreamAsset> SkPDFDevice::content() const {
     SkDynamicMemoryWStream buffer;
     this->writeContent(&buffer);
-    return buffer.bytesWritten() > 0
-        ? buffer.detachAsStream()
-        : new SkMemoryStream;
+    return skstd::unique_ptr<SkStreamAsset>(
+            buffer.bytesWritten() > 0
+            ? buffer.detachAsStream()
+            : new SkMemoryStream);
 }
 
 void SkPDFDevice::copyContentEntriesToData(ContentEntry* entry,
         SkWStream* data) const {
     // TODO(ctguil): For margins, I'm not sure fExistingClipStack/Region is the
     // right thing to pass here.
     GraphicStackState gsState(fExistingClipStack, fExistingClipRegion, data);
     while (entry != nullptr) {
         SkPoint translation;
         translation.iset(this->getOrigin());
@@ skipping 151 matching lines @@
         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) {
         auto pdfDest = sk_make_sp<SkPDFArray>();
         pdfDest->reserve(5);
-        pdfDest->appendObjRef(SkRef(page));
+        pdfDest->appendObjRef(sk_sp<SkPDFObject>(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());
+        dict->insertObject(name, std::move(pdfDest));
     }
 }
 
 SkPDFFormXObject* SkPDFDevice::createFormXObjectFromDevice() {
     SkPDFFormXObject* xobject = new SkPDFFormXObject(this);
     // We always draw the form xobjects that we create back into the device, so
     // we simply preserve the font usage instead of pulling it out and merging
     // it back in later.
     cleanUp(false);  // Reset this device to have no content.
     init();
@@ skipping 594 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);
 }