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

src/core/SkTLList.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkTLList_DEFINED
 #define SkTLList_DEFINED
 
@@ skipping 52 matching lines @@
                 }
                 sk_free(block);
             }
         }
     }
 
     T* addToHead(const T& t) {
         this->validate();
         Node* node = this->createNode();
         fList.addToHead(node);
-        SkNEW_PLACEMENT_ARGS(node->fObj, T, (t));
+        new (node->fObj) T(t);
         this->validate();
         return reinterpret_cast<T*>(node->fObj);
     }
 
     T* addToHead() {
         this->validate();
         Node* node = this->createNode();
         fList.addToHead(node);
-        SkNEW_PLACEMENT(node->fObj, T);
+        new (node->fObj) T;
         this->validate();
         return reinterpret_cast<T*>(node->fObj);
     }
 
     T* addToTail(const T& t) {
         this->validate();
         Node* node = this->createNode();
         fList.addToTail(node);
-        SkNEW_PLACEMENT_ARGS(node->fObj, T, (t));
+        new (node->fObj) T(t);
         this->validate();
         return reinterpret_cast<T*>(node->fObj);
     }
 
     T* addToTail() {
         this->validate();
         Node* node = this->createNode();
         fList.addToTail(node);
-        SkNEW_PLACEMENT(node->fObj, T);
+        new (node->fObj) T;
         this->validate();
         return reinterpret_cast<T*>(node->fObj);
     }
 
     /** Adds a new element to the list before the location indicated by the iterator. If the
         iterator refers to a NULL location then the new element is added at the tail */
     T* addBefore(const T& t, const Iter& location) {
-        return SkNEW_PLACEMENT_ARGS(this->internalAddBefore(location), T, (t));
+        return new (this->internalAddBefore(location)) T(t);
     }
 
     /** Adds a new element to the list after the location indicated by the iterator. If the
         iterator refers to a NULL location then the new element is added at the head */
     T* addAfter(const T& t, const Iter& location) {
-        return SkNEW_PLACEMENT_ARGS(this->internalAddAfter(location), T, (t));
+        return new (this->internalAddAfter(location)) T(t);
     }
 
     /** Convenience methods for getting an iterator initialized to the head/tail of the list. */
     Iter headIter() const { return Iter(*this, Iter::kHead_IterStart); }
     Iter tailIter() const { return Iter(*this, Iter::kTail_IterStart); }
 
     T* head() { return Iter(*this, Iter::kHead_IterStart).get(); }
     T* tail() { return Iter(*this, Iter::kTail_IterStart).get(); }
     const T* head() const { return Iter(*this, Iter::kHead_IterStart).get(); }
     const T* tail() const { return Iter(*this, Iter::kTail_IterStart).get(); }
@@ skipping 117 matching lines @@
     size_t blockSize() const { return sizeof(Block) + sizeof(Node) * (fAllocCnt-1); }
 
     Node* createNode() {
         Node* node = fFreeList.head();
         if (node) {
             fFreeList.remove(node);
             ++node->fBlock->fNodesInUse;
         } else {
             Block* block = reinterpret_cast<Block*>(sk_malloc_flags(this->blockSize(), 0));
             node = &block->fNodes[0];
-            SkNEW_PLACEMENT(node, Node);
+            new (node) Node;
             node->fBlock = block;
             block->fNodesInUse = 1;
             for (int i = 1; i < fAllocCnt; ++i) {
-                SkNEW_PLACEMENT(block->fNodes + i, Node);
+                new (block->fNodes + i) Node;
                 fFreeList.addToHead(block->fNodes + i);
                 block->fNodes[i].fBlock = block;
             }
         }
         ++fCount;
         return node;
     }
 
     void removeNode(Node* node) {
         SkASSERT(node);
@@ skipping 127 matching lines @@
 #define SkNEW_INSERT_IN_LLIST_AFTER(list, location, type_name, args) \
     (new ((list), SkTLList< type_name >::kAfter_Placement, (location)) type_name args)
 
 #define SkNEW_INSERT_AT_LLIST_HEAD(list, type_name, args) \
     SkNEW_INSERT_IN_LLIST_BEFORE((list), (list)->headIter(), type_name, args)
 
 #define SkNEW_INSERT_AT_LLIST_TAIL(list, type_name, args) \
     SkNEW_INSERT_IN_LLIST_AFTER((list), (list)->tailIter(), type_name, args)
 
 #endif