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

src/gpu/GrTessellatingPathRenderer.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 "GrTessellatingPathRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 71 matching lines @@
  */
 #define LOGGING_ENABLED 0
 #define WIREFRAME 0
 
 #if LOGGING_ENABLED
 #define LOG printf
 #else
 #define LOG(...)
 #endif
 
-#define ALLOC_NEW(Type, args, alloc) \
-    SkNEW_PLACEMENT_ARGS(alloc.allocThrow(sizeof(Type)), Type, args)
+#define ALLOC_NEW(Type, args, alloc) new (alloc.allocThrow(sizeof(Type))) Type args
 
 namespace {
 
 struct Vertex;
 struct Edge;
 struct Poly;
 
 template <class T, T* T::*Prev, T* T::*Next>
 void insert(T* t, T* prev, T* next, T** head, T** tail) {
     t->*Prev = prev;
@@ skipping 1281 matching lines @@
 }
 
 class TessellatingPathBatch : public GrVertexBatch {
 public:
 
     static GrDrawBatch* Create(const GrColor& color,
                                const SkPath& path,
                                const GrStrokeInfo& stroke,
                                const SkMatrix& viewMatrix,
                                SkRect clipBounds) {
-        return SkNEW_ARGS(TessellatingPathBatch, (color, path, stroke, viewMatrix, clipBounds));
+        return new TessellatingPathBatch(color, path, stroke, viewMatrix, clipBounds);
     }
 
     const char* name() const override { return "TessellatingPathBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         out->setKnownFourComponents(fColor);
     }
 
     void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
         out->setUnknownSingleComponent();
@@ skipping 48 matching lines @@
         if (maxPts > ((int)SK_MaxU16 + 1)) {
             SkDebugf("Path not rendered, too many verts (%d)\n", maxPts);
             return 0;
         }
         SkPath::FillType fillType = path.getFillType();
         if (SkPath::IsInverseFillType(fillType)) {
             contourCnt++;
         }
 
         LOG("got %d pts, %d contours\n", maxPts, contourCnt);
-        SkAutoTDeleteArray<Vertex*> contours(SkNEW_ARRAY(Vertex *, contourCnt));
+        SkAutoTDeleteArray<Vertex*> contours(new Vertex* [contourCnt]);
 
         // For the initial size of the chunk allocator, estimate based on the point count:
         // one vertex per point for the initial passes, plus two for the vertices in the
         // resulting Polys, since the same point may end up in two Polys.  Assume minimal
         // connectivity of one Edge per Vertex (will grow for intersections).
         SkChunkAlloc alloc(maxPts * (3 * sizeof(Vertex) + sizeof(Edge)));
         bool isLinear;
         path_to_contours(path, tol, fClipBounds, contours.get(), alloc, &isLinear);
         Poly* polys;
         polys = contours_to_polys(contours.get(), contourCnt, c, alloc);
@@ skipping 13 matching lines @@
                 size, GrResourceProvider::kStatic_BufferUsage, 0));
         }
         if (!vertexBuffer.get()) {
             SkDebugf("Could not allocate vertices\n");
             return 0;
         }
         SkPoint* verts;
         if (canMapVB) {
             verts = static_cast<SkPoint*>(vertexBuffer->map());
         } else {
-            verts = SkNEW_ARRAY(SkPoint, count);
+            verts = new SkPoint[count];
         }
         SkPoint* end = polys_to_triangles(polys, fillType, verts);
         int actualCount = static_cast<int>(end - verts);
         LOG("actual count: %d\n", actualCount);
         SkASSERT(actualCount <= count);
         if (canMapVB) {
             vertexBuffer->unmap();
         } else {
             vertexBuffer->updateData(verts, actualCount * sizeof(SkPoint));
-            SkDELETE_ARRAY(verts);
+            delete[] verts;
         }
 
 
         if (!fPath.isVolatile()) {
             TessInfo info;
             info.fTolerance = isLinear ? 0 : tol;
             info.fCount = actualCount;
             SkAutoTUnref<SkData> data(SkData::NewWithCopy(&info, sizeof(info)));
             key->setCustomData(data.get());
             resourceProvider->assignUniqueKeyToResource(*key, vertexBuffer.get());
-            SkPathPriv::AddGenIDChangeListener(fPath, SkNEW(PathInvalidator(*key)));
+            SkPathPriv::AddGenIDChangeListener(fPath, new PathInvalidator(*key));
         }
         return actualCount;
     }
 
     void onPrepareDraws(Target* target) override {
         // construct a cache key from the path's genID and the view matrix
         static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
         GrUniqueKey key;
         int clipBoundsSize32 =
             fPath.isInverseFillType() ? sizeof(fClipBounds) / sizeof(uint32_t) : 0;
@@ skipping 123 matching lines @@
     bool result = viewMatrix.invert(&vmi);
     if (!result) {
         SkFAIL("Cannot invert matrix\n");
     }
     vmi.mapRect(&clipBounds);
     GrStrokeInfo strokeInfo = GrTest::TestStrokeInfo(random);
     return TessellatingPathBatch::Create(color, path, strokeInfo, viewMatrix, clipBounds);
 }
 
 #endif