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

src/codec/SkCodec_libico.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBmpCodec.h"
 #include "SkCodec_libico.h"
 #include "SkCodec_libpng.h"
@@ skipping 23 matching lines @@
  */
 SkCodec* SkIcoCodec::NewFromStream(SkStream* stream) {
     // Ensure that we do not leak the input stream
     SkAutoTDelete<SkStream> inputStream(stream);
 
     // Header size constants
     static const uint32_t kIcoDirectoryBytes = 6;
     static const uint32_t kIcoDirEntryBytes = 16;
 
     // Read the directory header
-    SkAutoTDeleteArray<uint8_t> dirBuffer(
-            SkNEW_ARRAY(uint8_t, kIcoDirectoryBytes));
+    SkAutoTDeleteArray<uint8_t> dirBuffer(new uint8_t[kIcoDirectoryBytes]);
     if (inputStream.get()->read(dirBuffer.get(), kIcoDirectoryBytes) !=
             kIcoDirectoryBytes) {
         SkCodecPrintf("Error: unable to read ico directory header.\n");
         return NULL;
     }
 
     // Process the directory header
     const uint16_t numImages = get_short(dirBuffer.get(), 4);
     if (0 == numImages) {
         SkCodecPrintf("Error: No images embedded in ico.\n");
         return NULL;
     }
 
     // Ensure that we can read all of indicated directory entries
-    SkAutoTDeleteArray<uint8_t> entryBuffer(
-            SkNEW_ARRAY(uint8_t, numImages*kIcoDirEntryBytes));
+    SkAutoTDeleteArray<uint8_t> entryBuffer(new uint8_t[numImages * kIcoDirEntryBytes]);
     if (inputStream.get()->read(entryBuffer.get(), numImages*kIcoDirEntryBytes) !=
             numImages*kIcoDirEntryBytes) {
         SkCodecPrintf("Error: unable to read ico directory entries.\n");
         return NULL;
     }
 
     // This structure is used to represent the vital information about entries
     // in the directory header.  We will obtain this information for each
     // directory entry.
     struct Entry {
         uint32_t offset;
         uint32_t size;
     };
-    SkAutoTDeleteArray<Entry> directoryEntries(SkNEW_ARRAY(Entry, numImages));
+    SkAutoTDeleteArray<Entry> directoryEntries(new Entry[numImages]);
 
     // Iterate over directory entries
     for (uint32_t i = 0; i < numImages; i++) {
         // The directory entry contains information such as width, height,
         // bits per pixel, and number of colors in the color palette.  We will
         // ignore these fields since they are repeated in the header of the
         // embedded image.  In the event of an inconsistency, we would always
         // defer to the value in the embedded header anyway.
 
         // Specifies the size of the embedded image, including the header
@@ skipping 18 matching lines @@
             return a.offset < b.offset;
         }
     };
     EntryLessThan lessThan;
     SkTQSort(directoryEntries.get(), directoryEntries.get() + numImages - 1,
             lessThan);
 
     // Now will construct a candidate codec for each of the embedded images
     uint32_t bytesRead = kIcoDirectoryBytes + numImages * kIcoDirEntryBytes;
     SkAutoTDelete<SkTArray<SkAutoTDelete<SkCodec>, true>> codecs(
-            SkNEW_ARGS((SkTArray<SkAutoTDelete<SkCodec>, true>), (numImages)));
+            new (SkTArray<SkAutoTDelete<SkCodec>, true>)(numImages));
     for (uint32_t i = 0; i < numImages; i++) {
         uint32_t offset = directoryEntries.get()[i].offset;
         uint32_t size = directoryEntries.get()[i].size;
         
         // Ensure that the offset is valid
         if (offset < bytesRead) {
             SkCodecPrintf("Warning: invalid ico offset.\n");
             continue;
         }
 
         // If we cannot skip, assume we have reached the end of the stream and
         // stop trying to make codecs
         if (inputStream.get()->skip(offset - bytesRead) != offset - bytesRead) {
             SkCodecPrintf("Warning: could not skip to ico offset.\n");
             break;
         }
         bytesRead = offset;
 
         // Create a new stream for the embedded codec
         SkAutoTUnref<SkData> data(
                 SkData::NewFromStream(inputStream.get(), size));
         if (NULL == data.get()) {
             SkCodecPrintf("Warning: could not create embedded stream.\n");
             break;
         }
-        SkAutoTDelete<SkMemoryStream>
-                embeddedStream(SkNEW_ARGS(SkMemoryStream, (data.get())));
+        SkAutoTDelete<SkMemoryStream> embeddedStream(new SkMemoryStream(data.get()));
         bytesRead += size;
 
         // Check if the embedded codec is bmp or png and create the codec
         const bool isPng = SkPngCodec::IsPng(embeddedStream);
         SkAssertResult(embeddedStream->rewind());
         SkCodec* codec = NULL;
         if (isPng) {
             codec = SkPngCodec::NewFromStream(embeddedStream.detach());
         } else {
             codec = SkBmpCodec::NewFromIco(embeddedStream.detach());
@@ skipping 30 matching lines @@
     // FIXME (msarett): The BMP decoder depends on the alpha type in order
     // to decode correctly, otherwise it could report kUnpremul and we would
     // not have to correct it here. Is there a better way?
     // FIXME (msarett): This is only true for BMP in ICO - could a PNG in ICO
     // be opaque? Is it okay that we missed out on the opportunity to mark
     // such an image as opaque?
     info = info.makeAlphaType(kUnpremul_SkAlphaType);
 
     // Note that stream is owned by the embedded codec, the ico does not need
     // direct access to the stream.
-    return SkNEW_ARGS(SkIcoCodec, (info, codecs.detach()));
+    return new SkIcoCodec(info, codecs.detach());
 }
 
 /*
  * Creates an instance of the decoder
  * Called only by NewFromStream
  */
 SkIcoCodec::SkIcoCodec(const SkImageInfo& info,
                        SkTArray<SkAutoTDelete<SkCodec>, true>* codecs)
     : INHERITED(info, NULL)
     , fEmbeddedCodecs(codecs)
@@ skipping 68 matching lines @@
             }
 
             // On success or partial success, return the result
             return result;
         }
     }
 
     SkCodecPrintf("Error: No matching candidate image in ico.\n");
     return result;
 }