Style Change: SkNEW->new; SkDELETE->delete

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"
@@ skipping 679 matching lines @@
             paint.getXfermode()->asMode(&fXfermode);
         }
         fContentEntry = fDevice->setUpContentEntry(clipStack, clipRegion,
                                                    matrix, paint, hasText,
                                                    &fDstFormXObject);
     }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
-SkPDFDevice::SkPDFDevice(SkISize pageSize,
-                         SkScalar rasterDpi,
-                         SkPDFCanon* canon,
-                         bool flip)
+SkPDFDevice::SkPDFDevice(SkISize pageSize, SkScalar rasterDpi, SkPDFCanon* canon, bool flip)
     : INHERITED(SkSurfaceProps(0, kUnknown_SkPixelGeometry))
     , fPageSize(pageSize)
     , fContentSize(pageSize)
     , fExistingClipRegion(SkIRect::MakeSize(pageSize))
     , fAnnotations(NULL)
     , fLastContentEntry(NULL)
     , fLastMarginContentEntry(NULL)
     , fDrawingArea(kContent_DrawingArea)
     , fClipStack(NULL)
-    , fFontGlyphUsage(SkNEW(SkPDFGlyphSetMap))
+    , fFontGlyphUsage(new SkPDFGlyphSetMap)
     , fRasterDpi(rasterDpi)
     , fCanon(canon) {
     SkASSERT(pageSize.width() > 0);
     SkASSERT(pageSize.height() > 0);
     fLegacyBitmap.setInfo(
             SkImageInfo::MakeUnknown(pageSize.width(), pageSize.height()));
     if (flip) {
         // Skia generally uses the top left as the origin but PDF
         // natively has the origin at the bottom left. This matrix
         // corrects for that.  But that only needs to be done once, we
@@ skipping 10 matching lines @@
 }
 
 void SkPDFDevice::init() {
     fAnnotations = NULL;
     fContentEntries.free();
     fLastContentEntry = NULL;
     fMarginContentEntries.free();
     fLastMarginContentEntry = NULL;
     fDrawingArea = kContent_DrawingArea;
     if (fFontGlyphUsage.get() == NULL) {
-        fFontGlyphUsage.reset(SkNEW(SkPDFGlyphSetMap));
+        fFontGlyphUsage.reset(new SkPDFGlyphSetMap);
     }
 }
 
 void SkPDFDevice::cleanUp(bool clearFontUsage) {
     fGraphicStateResources.unrefAll();
     fXObjectResources.unrefAll();
     fFontResources.unrefAll();
     fShaderResources.unrefAll();
     SkSafeUnref(fAnnotations);
     fNamedDestinations.deleteAll();
@@ skipping 134 matching lines @@
     if (const SkClipStack* clipStack = d.fClipStack) {
         SkPath clip;
         (void)clipStack->asPath(&clip);
         clip.transform(initialTransform);
         Op(clip, path, SkPathOp::kIntersect_SkPathOp, &path);
     }
     return path;
 }
 
 static SkPDFDict* create_link_annotation(const SkRect& translatedRect) {
-    SkAutoTUnref<SkPDFDict> annotation(SkNEW_ARGS(SkPDFDict, ("Annot")));
+    SkAutoTUnref<SkPDFDict> annotation(new SkPDFDict("Annot"));
     annotation->insertName("Subtype", "Link");
 
-    SkAutoTUnref<SkPDFArray> border(SkNEW(SkPDFArray));
+    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());
 
-    SkAutoTUnref<SkPDFArray> rect(SkNEW(SkPDFArray));
+    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());
 
     return annotation.detach();
 }
 
 static SkPDFDict* create_link_to_url(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(SkNEW_ARGS(SkPDFDict, ("Action")));
+    SkAutoTUnref<SkPDFDict> action(new SkPDFDict("Action"));
     action->insertName("S", "URI");
     action->insertString("URI", url);
     annotation->insertObject("A", action.detach());
     return annotation.detach();
 }
 
 static SkPDFDict* create_link_named_dest(SkData* nameData, const SkRect& r) {
     SkAutoTUnref<SkPDFDict> annotation(create_link_annotation(r));
     SkString name(static_cast<const char *>(nameData->data()),
                   nameData->size() - 1);
@@ skipping 491 matching lines @@
             &fonts);
 }
 
 const SkTDArray<SkPDFFont*>& SkPDFDevice::getFontResources() const {
     return fFontResources;
 }
 
 SkPDFArray* SkPDFDevice::copyMediaBox() const {
     // should this be a singleton?
 
-    SkAutoTUnref<SkPDFArray> mediaBox(SkNEW(SkPDFArray));
+    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();
 }
 
 SkStreamAsset* SkPDFDevice::content() const {
     SkDynamicMemoryWStream buffer;
@@ skipping 124 matching lines @@
                                         const SkMatrix& matrix,
                                         SkAnnotation* annotationInfo) {
     SkData* nameData = annotationInfo->find(
             SkAnnotationKeys::Define_Named_Dest_Key());
     if (nameData) {
         SkMatrix transform = matrix;
         transform.postConcat(fInitialTransform);
         for (size_t i = 0; i < count; i++) {
             SkPoint translatedPoint;
             transform.mapXY(points[i].x(), points[i].y(), &translatedPoint);
-            fNamedDestinations.push(
-                    SkNEW_ARGS(NamedDestination, (nameData, translatedPoint)));
-
+            fNamedDestinations.push(new NamedDestination(nameData, translatedPoint));
         }
         return true;
     }
     return false;
 }
 
 void SkPDFDevice::addAnnotation(SkPDFDict* annotation) {
     if (NULL == fAnnotations) {
-        fAnnotations = SkNEW(SkPDFArray);
+        fAnnotations = new SkPDFArray;
     }
     fAnnotations->appendObject(annotation);
 }
 
 
 void SkPDFDevice::appendDestinations(SkPDFDict* dict, SkPDFObject* page) const {
     int nDest = fNamedDestinations.count();
     for (int i = 0; i < nDest; i++) {
         NamedDestination* dest = fNamedDestinations[i];
-        SkAutoTUnref<SkPDFArray> pdfDest(SkNEW(SkPDFArray));
+        SkAutoTUnref<SkPDFArray> pdfDest(new SkPDFArray);
         pdfDest->reserve(5);
         pdfDest->appendObjRef(SkRef(page));
         pdfDest->appendName("XYZ");
         pdfDest->appendScalar(dest->point.x());
         pdfDest->appendScalar(dest->point.y());
         pdfDest->appendInt(0);  // Leave zoom unchanged
         SkString name(static_cast<const char*>(dest->nameData->data()));
         dict->insertObject(name, pdfDest.detach());
     }
 }
 
 SkPDFFormXObject* SkPDFDevice::createFormXObjectFromDevice() {
-    SkPDFFormXObject* xobject = SkNEW_ARGS(SkPDFFormXObject, (this));
+    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();
     return xobject;
 }
 
 void SkPDFDevice::drawFormXObjectWithMask(int xObjectIndex,
                                           SkPDFFormXObject* mask,
@@ skipping 568 matching lines @@
         return;
     }
     SkAutoTUnref<SkPDFObject> image(SkPDFBitmap::Create(fCanon, subsetBitmap));
     if (!image) {
         return;
     }
 
     SkPDFUtils::DrawFormXObject(this->addXObjectResource(image.get()),
                                 &content.entry()->fContent);
 }