SkPDF: PDFDevice use SkTArray<T> rather than SkTDArray<T*>

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 "SkAnnotation.h"
 #include "SkColor.h"
 #include "SkColorFilter.h"
 #include "SkClipStack.h"
-#include "SkData.h"
 #include "SkDraw.h"
 #include "SkGlyphCache.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkPathOps.h"
 #include "SkPDFBitmap.h"
 #include "SkPDFCanon.h"
 #include "SkPDFFont.h"
 #include "SkPDFFormXObject.h"
 #include "SkPDFGraphicState.h"
@@ skipping 716 matching lines @@
     if (fFontGlyphUsage.get() == nullptr) {
         fFontGlyphUsage.reset(new SkPDFGlyphSetMap);
     }
 }
 
 void SkPDFDevice::cleanUp(bool clearFontUsage) {
     fGraphicStateResources.unrefAll();
     fXObjectResources.unrefAll();
     fFontResources.unrefAll();
     fShaderResources.unrefAll();
-    fLinkToURLs.deleteAll();
-    fLinkToDestinations.deleteAll();
-    fNamedDestinations.deleteAll();
 
     if (clearFontUsage) {
         fFontGlyphUsage->reset();
     }
 }
 
 void SkPDFDevice::drawPaint(const SkDraw& d, const SkPaint& paint) {
     SkPaint newPaint = paint;
     replace_srcmode_on_opaque_paint(&newPaint);
 
@@ skipping 649 matching lines @@
                                int vertexCount, const SkPoint verts[],
                                const SkPoint texs[], const SkColor colors[],
                                SkXfermode* xmode, const uint16_t indices[],
                                int indexCount, const SkPaint& paint) {
     if (d.fClip->isEmpty()) {
         return;
     }
     // TODO: implement drawVertices
 }
 
-struct RectWithData {
-    SkRect rect;
-    SkAutoTUnref<const SkData> data;
-
-    RectWithData(const SkRect& rect, const SkData* data)
-        : rect(rect), data(SkRef(data)) {}
-};
-
-struct NamedDestination {
-    SkAutoTUnref<const SkData> nameData;
-    SkPoint point;
-
-    NamedDestination(const SkData* nameData, const SkPoint& point)
-        : nameData(SkRef(nameData)), point(point) {}
-};
-
 void SkPDFDevice::drawDevice(const SkDraw& d, SkBaseDevice* device,
                              int x, int y, const SkPaint& paint) {
     // our onCreateCompatibleDevice() always creates SkPDFDevice subclasses.
     SkPDFDevice* pdfDevice = static_cast<SkPDFDevice*>(device);
 
     SkScalar scalarX = SkIntToScalar(x);
     SkScalar scalarY = SkIntToScalar(y);
-    for (RectWithData* link : pdfDevice->fLinkToURLs) {
-        fLinkToURLs.push(new RectWithData(
-                link->rect.makeOffset(scalarX, scalarY), link->data));
+    for (const RectWithData& l : pdfDevice->fLinkToURLs) {
+        SkRect r = l.rect.makeOffset(scalarX, scalarY);
+        fLinkToURLs.emplace_back(r, l.data);
     }
-    for (RectWithData* link : pdfDevice->fLinkToDestinations) {
-        fLinkToDestinations.push(new RectWithData(
-                link->rect.makeOffset(scalarX, scalarY), link->data));
+    for (const RectWithData& l : pdfDevice->fLinkToDestinations) {
+        SkRect r = l.rect.makeOffset(scalarX, scalarY);
+        fLinkToDestinations.emplace_back(r, l.data);
     }
-    for (NamedDestination* d : pdfDevice->fNamedDestinations) {
-        fNamedDestinations.push(new NamedDestination(
-                d->nameData, d->point + SkPoint::Make(scalarX, scalarY)));
+    for (const NamedDestination& d : pdfDevice->fNamedDestinations) {
+        SkPoint p = d.point + SkPoint::Make(scalarX, scalarY);
+        fNamedDestinations.emplace_back(d.nameData, p);
     }
 
     if (pdfDevice->isContentEmpty()) {
         return;
     }
 
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(x), SkIntToScalar(y));
     ScopedContentEntry content(this, d.fClipStack, *d.fClip, matrix, paint);
     if (!content.entry()) {
@@ skipping 219 matching lines @@
 
 bool SkPDFDevice::handlePointAnnotation(const SkPoint* points, size_t count,
                                         const SkMatrix& matrix,
                                         SkAnnotation* annotationInfo) {
     SkData* nameData = annotationInfo->find(
             SkAnnotationKeys::Define_Named_Dest_Key());
     if (nameData) {
         for (size_t i = 0; i < count; i++) {
             SkPoint transformedPoint;
             matrix.mapXY(points[i].x(), points[i].y(), &transformedPoint);
-            fNamedDestinations.push(new NamedDestination(nameData, transformedPoint));
+            fNamedDestinations.emplace_back(nameData, transformedPoint);
         }
         return true;
     }
     return false;
 }
 
 bool SkPDFDevice::handlePathAnnotation(const SkPath& path,
                                        const SkDraw& d,
                                        SkAnnotation* annotation) {
     SkASSERT(annotation);
 
     SkPath transformedPath = path;
     transformedPath.transform(*d.fMatrix);
     SkRasterClip clip = *d.fRC;
     clip.op(transformedPath, SkIRect::MakeWH(width(), height()), SkRegion::kIntersect_Op,
             false);
     SkRect transformedRect = SkRect::Make(clip.getBounds());
 
     SkData* urlData = annotation->find(SkAnnotationKeys::URL_Key());
     if (urlData) {
         if (!transformedRect.isEmpty()) {
-            fLinkToURLs.push(new RectWithData(transformedRect, urlData));
+            fLinkToURLs.emplace_back(transformedRect, urlData);
         }
         return true;
     }
 
     SkData* linkToDestination =
             annotation->find(SkAnnotationKeys::Link_Named_Dest_Key());
     if (linkToDestination) {
         if (!transformedRect.isEmpty()) {
-            fLinkToDestinations.push(new RectWithData(transformedRect, linkToDestination));
+            fLinkToDestinations.emplace_back(transformedRect, linkToDestination);
         }
         return true;
     }
 
     return false;
 }
 
 void SkPDFDevice::appendAnnotations(SkPDFArray* array) const {
     array->reserve(fLinkToURLs.count() + fLinkToDestinations.count());
-    for (RectWithData* rectWithURL : fLinkToURLs) {
+    for (const RectWithData& rectWithURL : fLinkToURLs) {
         SkRect r;
-        fInitialTransform.mapRect(&r, rectWithURL->rect);
-        array->appendObject(create_link_to_url(rectWithURL->data, r));
+        fInitialTransform.mapRect(&r, rectWithURL.rect);
+        array->appendObject(create_link_to_url(rectWithURL.data, r));
     }
-    for (RectWithData* linkToDestination : fLinkToDestinations) {
+    for (const RectWithData& linkToDestination : fLinkToDestinations) {
         SkRect r;
-        fInitialTransform.mapRect(&r, linkToDestination->rect);
-        array->appendObject(create_link_named_dest(linkToDestination->data, r));
+        fInitialTransform.mapRect(&r, linkToDestination.rect);
+        array->appendObject(create_link_named_dest(linkToDestination.data, r));
     }
 }
 
 void SkPDFDevice::appendDestinations(SkPDFDict* dict, SkPDFObject* page) const {
-    for (NamedDestination* dest : fNamedDestinations) {
+    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());
+        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()));
+        SkString name(static_cast<const char*>(dest.nameData->data()));
         dict->insertObject(name, pdfDest.detach());
     }
 }
 
 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.
@@ skipping 595 matching lines @@
         pdfimage.reset(SkPDFCreateBitmapObject(
                                image, fCanon->fPixelSerializer));
         if (!pdfimage) {
             return;
         }
         fCanon->addPDFBitmap(image->uniqueID(), pdfimage);
     }
     SkPDFUtils::DrawFormXObject(this->addXObjectResource(pdfimage.get()),
                                 &content.entry()->fContent);
 }