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

src/core/SkPictureData.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 <new>
 #include "SkPictureData.h"
 #include "SkPictureRecord.h"
 #include "SkReadBuffer.h"
@@ skipping 34 matching lines @@
 
     fBitmaps = record.fBitmaps;
     fPaints  = record.fPaints;
     fPaths   = record.fPaths;
 
     this->initForPlayback();
 
     const SkTDArray<const SkPicture* >& pictures = record.getPictureRefs();
     fPictureCount = pictures.count();
     if (fPictureCount > 0) {
-        fPictureRefs = SkNEW_ARRAY(const SkPicture*, fPictureCount);
+        fPictureRefs = new const SkPicture* [fPictureCount];
         for (int i = 0; i < fPictureCount; i++) {
             fPictureRefs[i] = pictures[i];
             fPictureRefs[i]->ref();
         }
     }
 
     // templatize to consolidate with similar picture logic?
     const SkTDArray<const SkTextBlob*>& blobs = record.getTextBlobRefs();
     fTextBlobCount = blobs.count();
     if (fTextBlobCount > 0) {
-        fTextBlobRefs = SkNEW_ARRAY(const SkTextBlob*, fTextBlobCount);
+        fTextBlobRefs = new const SkTextBlob* [fTextBlobCount];
         for (int i = 0; i < fTextBlobCount; ++i) {
             fTextBlobRefs[i] = SkRef(blobs[i]);
         }
     }
 
     const SkTDArray<const SkImage*>& imgs = record.getImageRefs();
     fImageCount = imgs.count();
     if (fImageCount > 0) {
-        fImageRefs = SkNEW_ARRAY(const SkImage*, fImageCount);
+        fImageRefs = new const SkImage* [fImageCount];
         for (int i = 0; i < fImageCount; ++i) {
             fImageRefs[i] = SkRef(imgs[i]);
         }
     }
 }
 
 void SkPictureData::init() {
     fPictureRefs = NULL;
     fPictureCount = 0;
     fTextBlobRefs = NULL;
     fTextBlobCount = 0;
     fImageRefs = NULL;
     fImageCount = 0;
     fOpData = NULL;
     fFactoryPlayback = NULL;
 }
 
 SkPictureData::~SkPictureData() {
     SkSafeUnref(fOpData);
 
     for (int i = 0; i < fPictureCount; i++) {
         fPictureRefs[i]->unref();
     }
-    SkDELETE_ARRAY(fPictureRefs);
+    delete[] fPictureRefs;
 
     for (int i = 0; i < fTextBlobCount; i++) {
         fTextBlobRefs[i]->unref();
     }
-    SkDELETE_ARRAY(fTextBlobRefs);
+    delete[] fTextBlobRefs;
 
     for (int i = 0; i < fImageCount; i++) {
         fImageRefs[i]->unref();
     }
-    SkDELETE_ARRAY(fImageRefs);
+    delete[] fImageRefs;
 
-    SkDELETE(fFactoryPlayback);
+    delete fFactoryPlayback;
 }
 
 bool SkPictureData::containsBitmaps() const {
     if (fBitmaps.count() > 0 || fImageCount > 0) {
         return true;
     }
     for (int i = 0; i < fPictureCount; ++i) {
         if (fPictureRefs[i]->willPlayBackBitmaps()) {
             return true;
         }
@@ skipping 235 matching lines @@
         case SK_PICT_READER_TAG:
             SkASSERT(NULL == fOpData);
             fOpData = SkData::NewFromStream(stream, size);
             if (!fOpData) {
                 return false;
             }
             break;
         case SK_PICT_FACTORY_TAG: {
             SkASSERT(!haveBuffer);
             size = stream->readU32();
-            fFactoryPlayback = SkNEW_ARGS(SkFactoryPlayback, (size));
+            fFactoryPlayback = new SkFactoryPlayback(size);
             for (size_t i = 0; i < size; i++) {
                 SkString str;
                 const size_t len = stream->readPackedUInt();
                 str.resize(len);
                 if (stream->read(str.writable_str(), len) != len) {
                     return false;
                 }
                 fFactoryPlayback->base()[i] = SkFlattenable::NameToFactory(str.c_str());
             }
         } break;
         case SK_PICT_TYPEFACE_TAG: {
             SkASSERT(!haveBuffer);
             const int count = SkToInt(size);
             fTFPlayback.setCount(count);
             for (int i = 0; i < count; i++) {
                 SkAutoTUnref<SkTypeface> tf(SkTypeface::Deserialize(stream));
                 if (!tf.get()) {    // failed to deserialize
                     // fTFPlayback asserts it never has a null, so we plop in
                     // the default here.
                     tf.reset(SkTypeface::RefDefault());
                 }
                 fTFPlayback.set(i, tf);
             }
         } break;
         case SK_PICT_PICTURE_TAG: {
             fPictureCount = 0;
-            fPictureRefs = SkNEW_ARRAY(const SkPicture*, size);
+            fPictureRefs = new const SkPicture* [size];
             for (uint32_t i = 0; i < size; i++) {
                 fPictureRefs[i] = SkPicture::CreateFromStream(stream, proc, topLevelTFPlayback);
                 if (!fPictureRefs[i]) {
                     return false;
                 }
                 fPictureCount++;
             }
         } break;
         case SK_PICT_BUFFER_SIZE_TAG: {
             SkAutoMalloc storage(size);
@@ skipping 62 matching lines @@
 template <typename T>
 bool new_array_from_buffer(SkReadBuffer& buffer, uint32_t inCount,
                            const T*** array, int* outCount, const T* (*factory)(SkReadBuffer&)) {
     if (!buffer.validate((0 == *outCount) && (NULL == *array))) {
         return false;
     }
     if (0 == inCount) {
         return true;
     }
     *outCount = inCount;
-    *array = SkNEW_ARRAY(const T*, *outCount);
+    *array = new const T* [*outCount];
     bool success = true;
     int i = 0;
     for (; i < *outCount; i++) {
         (*array)[i] = factory(buffer);
         if (NULL == (*array)[i]) {
             success = false;
             break;
         }
     }
     if (!success) {
         // Delete all of the blobs that were already created (up to but excluding i):
         for (int j = 0; j < i; j++) {
             (*array)[j]->unref();
         }
         // Delete the array
-        SkDELETE_ARRAY(*array);
+        delete[] * array;
         *array = NULL;
         *outCount = 0;
         return false;
     }
     return true;
 }
 
 bool SkPictureData::parseBufferTag(SkReadBuffer& buffer, uint32_t tag, uint32_t size) {
     switch (tag) {
         case SK_PICT_BITMAP_BUFFER_TAG: {
@@ skipping 54 matching lines @@
             // The tag was invalid.
             return false;
     }
     return true;    // success
 }
 
 SkPictureData* SkPictureData::CreateFromStream(SkStream* stream,
                                                const SkPictInfo& info,
                                                SkPicture::InstallPixelRefProc proc,
                                                SkTypefacePlayback* topLevelTFPlayback) {
-    SkAutoTDelete<SkPictureData> data(SkNEW_ARGS(SkPictureData, (info)));
+    SkAutoTDelete<SkPictureData> data(new SkPictureData(info));
     if (!topLevelTFPlayback) {
         topLevelTFPlayback = &data->fTFPlayback;
     }
 
     if (!data->parseStream(stream, proc, topLevelTFPlayback)) {
         return NULL;
     }
     return data.detach();
 }
 
 SkPictureData* SkPictureData::CreateFromBuffer(SkReadBuffer& buffer,
                                                const SkPictInfo& info) {
-    SkAutoTDelete<SkPictureData> data(SkNEW_ARGS(SkPictureData, (info)));
+    SkAutoTDelete<SkPictureData> data(new SkPictureData(info));
     buffer.setVersion(info.fVersion);
 
     if (!data->parseBuffer(buffer)) {
         return NULL;
     }
     return data.detach();
 }
 
 bool SkPictureData::parseStream(SkStream* stream,
                                 SkPicture::InstallPixelRefProc proc,
@@ skipping 47 matching lines @@
     }
 }
 
 bool SkPictureData::suitableForLayerOptimization() const {
     return fContentInfo.numLayers() > 0;
 }
 #endif
 ///////////////////////////////////////////////////////////////////////////////