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

src/codec/SkBmpCodec.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 "SkBmpMaskCodec.h"
 #include "SkBmpRLECodec.h"
@@ skipping 95 matching lines @@
     // check that it is valid in the RLE case.
     uint32_t totalBytes;
     // The offset from the start of the file where the pixel data begins
     uint32_t offset;
     // The size of the second (info) header in bytes
     uint32_t infoBytes;
 
     // Bmps embedded in Icos skip the first Bmp header
     if (!inIco) {
         // Read the first header and the size of the second header
-        SkAutoTDeleteArray<uint8_t> hBuffer(
-                SkNEW_ARRAY(uint8_t, kBmpHeaderBytesPlusFour));
+        SkAutoTDeleteArray<uint8_t> hBuffer(new uint8_t[kBmpHeaderBytesPlusFour]);
         if (stream->read(hBuffer.get(), kBmpHeaderBytesPlusFour) !=
                 kBmpHeaderBytesPlusFour) {
             SkCodecPrintf("Error: unable to read first bitmap header.\n");
             return false;
         }
 
         totalBytes = get_int(hBuffer.get(), 2);
         offset = get_int(hBuffer.get(), 10);
         if (offset < kBmpHeaderBytes + kBmpOS2V1Bytes) {
             SkCodecPrintf("Error: invalid starting location for pixel data\n");
@@ skipping 13 matching lines @@
         // use RLE.  If the compression field is incorrectly signaled as RLE,
         // we will catch this and signal an error below.
         totalBytes = 0;
 
         // Bmps in Ico cannot specify an offset.  We will always assume that
         // pixel data begins immediately after the color table.  This value
         // will be corrected below.
         offset = 0;
 
         // Read the size of the second header
-        SkAutoTDeleteArray<uint8_t> hBuffer(
-                SkNEW_ARRAY(uint8_t, 4));
+        SkAutoTDeleteArray<uint8_t> hBuffer(new uint8_t[4]);
         if (stream->read(hBuffer.get(), 4) != 4) {
             SkCodecPrintf("Error: unable to read size of second bitmap header.\n");
             return false;
         }
         infoBytes = get_int(hBuffer.get(), 0);
         if (infoBytes < kBmpOS2V1Bytes) {
             SkCodecPrintf("Error: invalid second header size.\n");
             return false;
         }
     }
 
     // We already read the first four bytes of the info header to get the size
     const uint32_t infoBytesRemaining = infoBytes - 4;
 
     // Read the second header
-    SkAutoTDeleteArray<uint8_t> iBuffer(
-            SkNEW_ARRAY(uint8_t, infoBytesRemaining));
+    SkAutoTDeleteArray<uint8_t> iBuffer(new uint8_t[infoBytesRemaining]);
     if (stream->read(iBuffer.get(), infoBytesRemaining) != infoBytesRemaining) {
         SkCodecPrintf("Error: unable to read second bitmap header.\n");
         return false;
     }
 
     // The number of bits used per pixel in the pixel data
     uint16_t bitsPerPixel;
 
     // The compression method for the pixel data
     uint32_t compression = kNone_BmpCompressionMethod;
@@ skipping 126 matching lines @@
             }
             inputFormat = kRLE_BmpInputFormat;
             break;
         case kAlphaBitMasks_BmpCompressionMethod:
         case kBitMasks_BmpCompressionMethod:
             // Load the masks
             inputFormat = kBitMask_BmpInputFormat;
             switch (headerType) {
                 case kInfoV1_BmpHeaderType: {
                     // The V1 header stores the bit masks after the header
-                    SkAutoTDeleteArray<uint8_t> mBuffer(
-                            SkNEW_ARRAY(uint8_t, kBmpMaskBytes));
+                    SkAutoTDeleteArray<uint8_t> mBuffer(new uint8_t[kBmpMaskBytes]);
                     if (stream->read(mBuffer.get(), kBmpMaskBytes) !=
                             kBmpMaskBytes) {
                         SkCodecPrintf("Error: unable to read bit inputMasks.\n");
                         return false;
                     }
                     maskBytes = kBmpMaskBytes;
                     inputMasks.red = get_int(mBuffer.get(), 0);
                     inputMasks.green = get_int(mBuffer.get(), 4);
                     inputMasks.blue = get_int(mBuffer.get(), 8);
                     break;
@@ skipping 137 matching lines @@
     }
 
     if (codecOut) {
         // Set the image info
         const SkImageInfo& imageInfo = SkImageInfo::Make(width, height,
                 colorType, alphaType);
 
         // Return the codec
         switch (inputFormat) {
             case kStandard_BmpInputFormat:
-                *codecOut = SkNEW_ARGS(SkBmpStandardCodec, (imageInfo, stream,
-                        bitsPerPixel, numColors, bytesPerColor,
-                        offset - bytesRead, rowOrder, inIco));
+                *codecOut =
+                        new SkBmpStandardCodec(imageInfo, stream, bitsPerPixel, numColors,
+                                               bytesPerColor, offset - bytesRead, rowOrder, inIco);
                 return true;
             case kBitMask_BmpInputFormat:
                 // Bmp-in-Ico must be standard mode
                 if (inIco) {
                     SkCodecPrintf("Error: Icos may not use bit mask format.\n");
                     return false;
                 }
                 // Skip to the start of the pixel array.
                 // We can do this here because there is no color table to read
                 // in bit mask mode.
                 if (stream->skip(offset - bytesRead) != offset - bytesRead) {
                     SkCodecPrintf("Error: unable to skip to image data.\n");
                     return false;
                 }
 
-                *codecOut = SkNEW_ARGS(SkBmpMaskCodec, (imageInfo, stream,
-                        bitsPerPixel, masks.detach(), rowOrder));
+                *codecOut = new SkBmpMaskCodec(imageInfo, stream, bitsPerPixel, masks.detach(),
+                                               rowOrder);
                 return true;
             case kRLE_BmpInputFormat:
                 // Bmp-in-Ico must be standard mode
                 // When inIco is true, this line cannot be reached, since we
                 // require that RLE Bmps have a valid number of totalBytes, and
                 // Icos skip the header that contains totalBytes.
                 SkASSERT(!inIco);
-                *codecOut = SkNEW_ARGS(SkBmpRLECodec, (
-                        imageInfo, stream, bitsPerPixel, numColors,
-                        bytesPerColor, offset - bytesRead, rowOrder, RLEBytes));
+                *codecOut =
+                        new SkBmpRLECodec(imageInfo, stream, bitsPerPixel, numColors, bytesPerColor,
+                                          offset - bytesRead, rowOrder, RLEBytes);
                 return true;
             default:
                 SkASSERT(false);
                 return false;
         }
     }
 
     return true;
 }
 
@@ skipping 41 matching lines @@
  */
 uint32_t SkBmpCodec::computeNumColors(uint32_t numColors) {
     // Zero is a default for maxColors
     // Also set numColors to maxColors when it is too large
     uint32_t maxColors = 1 << fBitsPerPixel;
     if (numColors == 0 || numColors >= maxColors) {
         return maxColors;
     }
     return numColors;
 }