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

tools/PictureRenderer.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "PictureRenderer.h"
 #include "picture_utils.h"
 #include "SamplePipeControllers.h"
@@ skipping 113 matching lines @@
     return this->setupCanvas(width, height);
 }
 
 SkCanvas* PictureRenderer::setupCanvas(int width, int height) {
     SkAutoTUnref<SkCanvas> canvas;
 
     switch(fDeviceType) {
         case kBitmap_DeviceType: {
             SkBitmap bitmap;
             sk_tools::setup_bitmap(&bitmap, width, height);
-            canvas.reset(SkNEW_ARGS(SkCanvas, (bitmap)));
+            canvas.reset(new SkCanvas(bitmap));
         }
         break;
 #if SK_SUPPORT_GPU
 #if SK_ANGLE
         case kAngle_DeviceType:
             // fall through
 #endif
 #if SK_MESA
         case kMesa_DeviceType:
             // fall through
@@ skipping 13 matching lines @@
             }
 
             uint32_t flags = fUseDFText ? SkSurfaceProps::kUseDistanceFieldFonts_Flag : 0;
             SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
             SkAutoTUnref<SkGpuDevice> device(
                 SkGpuDevice::Create(target->asRenderTarget(), &props,
                                     SkGpuDevice::kUninit_InitContents));
             if (!device) {
                 return NULL;
             }
-            canvas.reset(SkNEW_ARGS(SkCanvas, (device)));
+            canvas.reset(new SkCanvas(device));
             break;
         }
 #endif
         default:
             SkASSERT(0);
             return NULL;
     }
 
     if (fHasDrawFilters) {
         if (fDrawFilters[0] & PictureRenderer::kAAClip_DrawFilterFlag) {
             canvas->setAllowSoftClip(false);
         }
 
-        canvas.reset(SkNEW_ARGS(FlagsFilterCanvas, (canvas.get(), fDrawFilters)));
+        canvas.reset(new FlagsFilterCanvas(canvas.get(), fDrawFilters));
     }
 
     this->scaleToScaleFactor(canvas);
 
     // Pictures often lie about their extent (i.e., claim to be 100x100 but
     // only ever draw to 90x100). Clear here so the undrawn portion will have
     // a consistent color
     canvas->clear(SK_ColorTRANSPARENT);
     return canvas.detach();
 }
@@ skipping 208 matching lines @@
         return false;
     }
 
     PipeController pipeController(fCanvas.get());
     SkGPipeWriter writer;
     SkCanvas* pipeCanvas = writer.startRecording(&pipeController);
     pipeCanvas->drawPicture(fPicture);
     writer.endRecording();
     fCanvas->flush();
     if (out) {
-        *out = SkNEW(SkBitmap);
+        *out = new SkBitmap;
         setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()),
                            SkScalarCeilToInt(fPicture->cullRect().height()));
         fCanvas->readPixels(*out, 0, 0);
     }
     if (fEnableWrites) {
         return write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSummaryPtr,
                      fUseChecksumBasedFilenames);
     } else {
         return true;
     }
@@ skipping 24 matching lines @@
         SkMultiPictureDraw mpd;
 
         mpd.add(fCanvas, fPicture);
 
         mpd.draw();
     } else {
         fCanvas->drawPicture(fPicture);
     }
     fCanvas->flush();
     if (out) {
-        *out = SkNEW(SkBitmap);
+        *out = new SkBitmap;
         setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()),
                            SkScalarCeilToInt(fPicture->cullRect().height()));
         fCanvas->readPixels(*out, 0, 0);
     }
     if (fEnableWrites) {
         return write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSummaryPtr,
                      fUseChecksumBasedFilenames);
     } else {
         return true;
     }
@@ skipping 220 matching lines @@
 }
 
 bool TiledPictureRenderer::render(SkBitmap** out) {
     SkASSERT(fPicture != NULL);
     if (NULL == fPicture) {
         return false;
     }
 
     SkBitmap bitmap;
     if (out) {
-        *out = SkNEW(SkBitmap);
+        *out = new SkBitmap;
         setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()),
                            SkScalarCeilToInt(fPicture->cullRect().height()));
         setup_bitmap(&bitmap, fTileWidth, fTileHeight);
     }
     bool success = true;
 
     if (fUseMultiPictureDraw) {
         SkMultiPictureDraw mpd;
         SkTDArray<SkSurface*> surfaces;
         surfaces.setReserve(fTileRects.count());
@@ skipping 79 matching lines @@
     } else {
         name.appendf("%i", fTileHeight);
     }
     return name;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
 void PlaybackCreationRenderer::setup() {
     SkAutoTDelete<SkBBHFactory> factory(this->getFactory());
-    fRecorder.reset(SkNEW(SkPictureRecorder));
+    fRecorder.reset(new SkPictureRecorder);
     SkCanvas* canvas = fRecorder->beginRecording(SkIntToScalar(this->getViewWidth()),
                                                  SkIntToScalar(this->getViewHeight()),
                                                  factory.get(),
                                                  this->recordFlags());
     this->scaleToScaleFactor(canvas);
     canvas->drawPicture(fPicture);
 }
 
 bool PlaybackCreationRenderer::render(SkBitmap** out) {
     fPicture.reset(fRecorder->endRecording());
     // Since this class does not actually render, return false.
     return false;
 }
 
 SkString PlaybackCreationRenderer::getConfigNameInternal() {
     return SkString("playback_creation");
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // SkPicture variants for each BBoxHierarchy type
 
 SkBBHFactory* PictureRenderer::getFactory() {
     switch (fBBoxHierarchyType) {
         case kNone_BBoxHierarchyType:
             return NULL;
         case kRTree_BBoxHierarchyType:
-            return SkNEW(SkRTreeFactory);
+            return new SkRTreeFactory;
     }
     SkASSERT(0); // invalid bbhType
     return NULL;
 }
 
 } // namespace sk_tools