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

src/pipe/SkGPipeWrite.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 "SkAnnotation.h"
 #include "SkBitmapHeap.h"
@@ skipping 419 matching lines @@
     return index;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #define MIN_BLOCK_SIZE  (16 * 1024)
 #define BITMAPS_TO_KEEP 5
 #define FLATTENABLES_TO_KEEP 10
 
 SkGPipeCanvas::SkGPipeCanvas(SkGPipeController* controller,
-                             SkWriter32* writer, uint32_t flags,
-                             uint32_t width, uint32_t height)
+                             SkWriter32* writer,
+                             uint32_t flags,
+                             uint32_t width,
+                             uint32_t height)
     : SkCanvas(width, height)
-    , fFactorySet(is_cross_process(flags) ? SkNEW(SkNamedFactorySet) : NULL)
+    , fFactorySet(is_cross_process(flags) ? new SkNamedFactorySet : NULL)
     , fWriter(*writer)
     , fFlags(flags)
     , fFlattenableHeap(FLATTENABLES_TO_KEEP, fFactorySet, is_cross_process(flags))
-    , fFlatDictionary(&fFlattenableHeap)
-{
+    , fFlatDictionary(&fFlattenableHeap) {
     fController = controller;
     fDone = false;
     fBlockSize = 0; // need first block from controller
     fBytesNotified = 0;
     sk_bzero(fCurrFlatIndex, sizeof(fCurrFlatIndex));
 
     // Tell the reader the appropriate flags to use.
     if (this->needOpBytes()) {
         this->writeOp(kReportFlags_DrawOp, fFlags, 0);
     }
 
     if (shouldFlattenBitmaps(flags)) {
-        fBitmapShuttle.reset(SkNEW_ARGS(BitmapShuttle, (this)));
-        fBitmapHeap = SkNEW_ARGS(SkBitmapHeap, (fBitmapShuttle.get(), BITMAPS_TO_KEEP));
+        fBitmapShuttle.reset(new BitmapShuttle(this));
+        fBitmapHeap = new SkBitmapHeap(fBitmapShuttle.get(), BITMAPS_TO_KEEP);
     } else {
-        fBitmapHeap = SkNEW_ARGS(SkBitmapHeap,
-                                 (BITMAPS_TO_KEEP, controller->numberOfReaders()));
+        fBitmapHeap = new SkBitmapHeap(BITMAPS_TO_KEEP, controller->numberOfReaders());
         if (this->needOpBytes(sizeof(void*))) {
             this->writeOp(kShareBitmapHeap_DrawOp);
             fWriter.writePtr(static_cast<void*>(fBitmapHeap));
         }
     }
     fFlattenableHeap.setBitmapStorage(fBitmapHeap);
 
-    fImageHeap = SkNEW(SkImageHeap);
+    fImageHeap = new SkImageHeap;
     if (this->needOpBytes(sizeof(void*))) {
         this->writeOp(kShareImageHeap_DrawOp);
         fWriter.writePtr(static_cast<void*>(fImageHeap));
     }
 
     this->doNotify();
 }
 
 SkGPipeCanvas::~SkGPipeCanvas() {
     this->finish(true);
@@ skipping 908 matching lines @@
 }
 
 SkGPipeWriter::~SkGPipeWriter() {
     this->endRecording();
 }
 
 SkCanvas* SkGPipeWriter::startRecording(SkGPipeController* controller, uint32_t flags,
                                         uint32_t width, uint32_t height) {
     if (NULL == fCanvas) {
         fWriter.reset(NULL, 0);
-        fCanvas = SkNEW_ARGS(SkGPipeCanvas, (controller, &fWriter, flags, width, height));
+        fCanvas = new SkGPipeCanvas(controller, &fWriter, flags, width, height);
     }
     controller->setCanvas(fCanvas);
     return fCanvas;
 }
 
 void SkGPipeWriter::endRecording() {
     if (fCanvas) {
         fCanvas->finish(true);
         fCanvas->unref();
         fCanvas = NULL;
@@ skipping 73 matching lines @@
     int32_t slot = this->find(img);
     if (slot) {
         return slot;
     }
     // TODO: SkImage does not expose bytes per pixel, 4 is just a best guess.
     fBytesInCache += img->width() * img->height() * 4;
     *fArray.append() = SkRef(img);
     return fArray.count();  // slot is always index+1
 }