SkPDF: AutoTUnref<T> changes in use

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 870 matching lines @@
 
 static SkPDFDict* create_link_annotation(const SkRect& translatedRect) {
     SkAutoTUnref<SkPDFDict> annotation(new SkPDFDict("Annot"));
     annotation->insertName("Subtype", "Link");
 
     SkAutoTUnref<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.detach());
+    annotation->insertObject("Border", border.release());
 
     SkAutoTUnref<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.detach());
+    annotation->insertObject("Rect", rect.release());
 
-    return annotation.detach();
+    return annotation.release();
 }
 
 static SkPDFDict* create_link_to_url(const SkData* urlData, const SkRect& r) {
     SkAutoTUnref<SkPDFDict> annotation(create_link_annotation(r));
 
     SkString url(static_cast<const char *>(urlData->data()),
                  urlData->size() - 1);
     SkAutoTUnref<SkPDFDict> action(new SkPDFDict("Action"));
     action->insertName("S", "URI");
     action->insertString("URI", url);
-    annotation->insertObject("A", action.detach());
-    return annotation.detach();
+    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));
     SkString name(static_cast<const char *>(nameData->data()),
                   nameData->size() - 1);
     annotation->insertName("Dest", name);
-    return annotation.detach();
+    return annotation.release();
 }
 
 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 225 matching lines @@
 
         // since we may need to clamp to the borders of the src rect within
         // the bitmap, we extract a subset.
         SkIRect srcIR;
         tmpSrc.roundOut(&srcIR);
 
         autoImageUnref.reset(image->newSubset(srcIR));
         if (!autoImageUnref) {
             return;
         }
-        image = autoImageUnref;
+        image = autoImageUnref.get();
         // Since we did an extract, we need to adjust the matrix accordingly
         SkScalar dx = 0, dy = 0;
         if (srcIR.fLeft > 0) {
             dx = SkIntToScalar(srcIR.fLeft);
         }
         if (srcIR.fTop > 0) {
             dy = SkIntToScalar(srcIR.fTop);
         }
         if (dx || dy) {
             matrix.preTranslate(dx, dy);
@@ skipping 347 matching lines @@
 
 SkPDFArray* SkPDFDevice::copyMediaBox() const {
     // should this be a singleton?
 
     SkAutoTUnref<SkPDFArray> mediaBox(new SkPDFArray);
     mediaBox->reserve(4);
     mediaBox->appendInt(0);
     mediaBox->appendInt(0);
     mediaBox->appendInt(fPageSize.fWidth);
     mediaBox->appendInt(fPageSize.fHeight);
-    return mediaBox.detach();
+    return mediaBox.release();
 }
 
 SkStreamAsset* SkPDFDevice::content() const {
     SkDynamicMemoryWStream buffer;
     this->writeContent(&buffer);
     return buffer.bytesWritten() > 0
         ? buffer.detachAsStream()
         : new SkMemoryStream;
 }
 
@@ skipping 165 matching lines @@
     for (const NamedDestination& dest : fNamedDestinations) {
         SkAutoTUnref<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.detach());
+        dict->insertObject(name, pdfDest.release());
     }
 }
 
 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 115 matching lines @@
     if (!lastContentEntry) {
         contentEntries->reset(entry);
         setLastContentEntry(entry);
     } else if (xfermode == SkXfermode::kDstOver_Mode) {
         entry->fNext.reset(contentEntries->detach());
         contentEntries->reset(entry);
     } else {
         lastContentEntry->fNext.reset(entry);
         setLastContentEntry(entry);
     }
-    newEntry.detach();
+    newEntry.release();
     return entry;
 }
 
 void SkPDFDevice::finishContentEntry(SkXfermode::Mode xfermode,
                                      SkPDFFormXObject* dst,
                                      SkPath* shape) {
     if (xfermode != SkXfermode::kClear_Mode       &&
             xfermode != SkXfermode::kSrc_Mode     &&
             xfermode != SkXfermode::kDstOver_Mode &&
             xfermode != SkXfermode::kSrcIn_Mode   &&
@@ skipping 333 matching lines @@
     SkMatrix matrix = origMatrix;
     SkRegion perspectiveBounds;
     const SkRegion* clipRegion = &origClipRegion;
     SkAutoTUnref<const SkImage> autoImageUnref;
 
     if (srcRect) {
         autoImageUnref.reset(image->newSubset(*srcRect));
         if (!autoImageUnref) {
             return;
         }
-        image = autoImageUnref;
+        image = autoImageUnref.get();
     }
     // Rasterize the bitmap using perspective in a new bitmap.
     if (origMatrix.hasPerspective()) {
         if (fRasterDpi == 0) {
             return;
         }
         // Transform the bitmap in the new space, without taking into
         // account the initial transform.
         SkPath perspectiveOutline;
         SkRect imageBounds = SkRect::Make(image->bounds());
@@ skipping 55 matching lines @@
         // In the new space, we use the identity matrix translated
         // and scaled to reflect DPI.
         matrix.setScale(1 / scaleX, 1 / scaleY);
         matrix.postTranslate(deltaX, deltaY);
 
         perspectiveBounds.setRect(bounds.roundOut());
         clipRegion = &perspectiveBounds;
         srcRect = nullptr;
 
         autoImageUnref.reset(surface->newImageSnapshot());
-        image = autoImageUnref;
+        image = autoImageUnref.get();
     }
 
     SkMatrix scaled;
     // Adjust for origin flip.
     scaled.setScale(SK_Scalar1, -SK_Scalar1);
     scaled.postTranslate(0, SK_Scalar1);
     // Scale the image up from 1x1 to WxH.
     SkIRect subset = image->bounds();
     scaled.postScale(SkIntToScalar(image->width()),
                      SkIntToScalar(image->height()));
@@ skipping 12 matching lines @@
         return;
     }
 
     if (SkColorFilter* colorFilter = paint.getColorFilter()) {
         // 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;
+        image = autoImageUnref.get();
         // TODO(halcanary): de-dupe this by caching filtered images.
         // (maybe in the resource cache?)
     }
     SkAutoTUnref<SkPDFObject> pdfimage(SkSafeRef(fCanon->findPDFBitmap(image)));
     if (!pdfimage) {
         pdfimage.reset(SkPDFCreateBitmapObject(
-                               image, fCanon->fPixelSerializer));
+                               image, fCanon->getPixelSerializer()));
         if (!pdfimage) {
             return;
         }
-        fCanon->addPDFBitmap(image->uniqueID(), pdfimage);
+        fCanon->addPDFBitmap(image->uniqueID(), pdfimage.get());
     }
     SkPDFUtils::DrawFormXObject(this->addXObjectResource(pdfimage.get()),
                                 &content.entry()->fContent);
 }