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

src/gpu/GrLayerCache.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrLayerCache_DEFINED
 #define GrLayerCache_DEFINED
 
@@ skipping 68 matching lines @@
     struct Key {
         Key(uint32_t pictureID, const SkMatrix& initialMat,
             const int* key, int keySize, bool copyKey = false)
         : fKeySize(keySize)
         , fFreeKey(copyKey) {
             fIDMatrix.fPictureID = pictureID;
             fIDMatrix.fInitialMat = initialMat;
             fIDMatrix.fInitialMat.getType(); // force initialization of type so hashes match
 
             if (copyKey) {
-                int* tempKey = SkNEW_ARRAY(int, keySize);
+                int* tempKey = new int[keySize];
                 memcpy(tempKey, key, keySize*sizeof(int));
                 fKey = tempKey;
             } else {
                 fKey = key;
             }
 
             // The pictureID/matrix portion needs to be tightly packed.
             GR_STATIC_ASSERT(sizeof(IDMatrix) == sizeof(uint32_t)+                     // pictureID
                                              9 * sizeof(SkScalar) + sizeof(uint32_t)); // matrix
         }
 
         ~Key() {
             if (fFreeKey) {
-                SkDELETE_ARRAY(fKey);
+                delete[] fKey;
             }
         }
 
         bool operator==(const Key& other) const {
             if (fKeySize != other.fKeySize) {
                 return false;
             }
             return fIDMatrix.fPictureID == other.fIDMatrix.fPictureID &&
                    fIDMatrix.fInitialMat.cheapEqualTo(other.fIDMatrix.fInitialMat) &&
                    !memcmp(fKey, other.fKey, fKeySize * sizeof(int));
@@ skipping 22 matching lines @@
 
         const int* fKey;
         const int  fKeySize;
         bool       fFreeKey;
     };
 
     static const Key& GetKey(const GrCachedLayer& layer) { return layer.fKey; }
     static uint32_t Hash(const Key& key) { return key.hash(); }
 
     // GrCachedLayer proper
-    GrCachedLayer(uint32_t pictureID, int start, int stop,
-                  const SkIRect& srcIR, const SkIRect& dstIR,
+    GrCachedLayer(uint32_t pictureID,
+                  int start,
+                  int stop,
+                  const SkIRect& srcIR,
+                  const SkIRect& dstIR,
                   const SkMatrix& ctm,
-                  const int* key, int keySize,
+                  const int* key,
+                  int keySize,
                   const SkPaint* paint)
         : fKey(pictureID, ctm, key, keySize, true)
         , fStart(start)
         , fStop(stop)
         , fSrcIR(srcIR)
         , fDstIR(dstIR)
         , fOffset(SkIPoint::Make(0, 0))
-        , fPaint(paint ? SkNEW_ARGS(SkPaint, (*paint)) : NULL)
+        , fPaint(paint ? new SkPaint(*paint) : NULL)
         , fFilter(NULL)
         , fTexture(NULL)
         , fRect(SkIRect::MakeEmpty())
         , fPlot(NULL)
         , fUses(0)
         , fLocked(false) {
         SkASSERT(SK_InvalidGenID != pictureID);
 
         if (fPaint) {
             if (fPaint->getImageFilter()) {
                 fFilter = SkSafeRef(fPaint->getImageFilter());
                 fPaint->setImageFilter(NULL);
             }
         }
     }
 
     ~GrCachedLayer() {
         SkSafeUnref(fTexture);
         SkSafeUnref(fFilter);
-        SkDELETE(fPaint);
+        delete fPaint;
     }
 
     uint32_t pictureID() const { return fKey.pictureID(); }
     // TODO: remove these when GrCachedLayer & ReplacementInfo fuse
     const int* key() const { return fKey.key(); }
     int keySize() const { return fKey.keySize(); }
 
     int start() const { return fStart; }
     // TODO: make bound debug only
     const SkIRect& srcIR() const { return fSrcIR; }
@@ skipping 210 matching lines @@
         SkASSERT(fPlotLocks[plotIdx] > 0);
         --fPlotLocks[plotIdx];
     }
 
     // for testing
     friend class TestingAccess;
     int numLayers() const { return fLayerHash.count(); }
 };
 
 #endif