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

src/gpu/gl/GrGLCreateNullInterface.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "gl/GrGLInterface.h"
 #include "GrGLDefines.h"
 #include "SkTDArray.h"
 #include "GrGLNoOpInterface.h"
 #include "SkTLS.h"
 
 // TODO: Delete this file after chrome starts using SkNullGLContext.
 
 // added to suppress 'no previous prototype' warning and because this code is duplicated in
 // SkNullGLContext.cpp
 namespace {      
 
 class BufferObj {
 public:
     
 
     BufferObj(GrGLuint id) : fID(id), fDataPtr(NULL), fSize(0), fMapped(false) {
     }
-    ~BufferObj() { SkDELETE_ARRAY(fDataPtr); }
+    ~BufferObj() { delete[] fDataPtr; }
 
     void allocate(GrGLsizeiptr size, const GrGLchar* dataPtr) {
         if (fDataPtr) {
             SkASSERT(0 != fSize);
-            SkDELETE_ARRAY(fDataPtr);
+            delete[] fDataPtr;
         }
 
         fSize = size;
-        fDataPtr = SkNEW_ARRAY(char, size);
+        fDataPtr = new char[size];
     }
 
     GrGLuint id() const          { return fID; }
     GrGLchar* dataPtr()          { return fDataPtr; }
     GrGLsizeiptr size() const    { return fSize; }
 
     void setMapped(bool mapped)  { fMapped = mapped; }
     bool mapped() const          { return fMapped; }
 
 private:
@@ skipping 28 matching lines @@
         return buffer;
     }
 
     BufferObj* create() {
         GrGLuint id;
         BufferObj* buffer;
 
         if (kFreeListEnd == fFreeListHead) {
             // no free slots - create a new one
             id = fBuffers.count();
-            buffer = SkNEW_ARGS(BufferObj, (id));
+            buffer = new BufferObj(id);
             *fBuffers.append() = buffer;
         } else {
             // grab the head of the free list and advance the head to the next free slot.
             id = static_cast<GrGLuint>(fFreeListHead);
             fFreeListHead = reinterpret_cast<intptr_t>(fBuffers[id]);
 
-            buffer = SkNEW_ARGS(BufferObj, (id));
+            buffer = new BufferObj(id);
             fBuffers[id] = buffer;
         }
 
         return buffer;
     }
 
     void free(BufferObj* buffer) {
         SkASSERT(fBuffers.count() > 0);
 
         GrGLuint id = buffer->id();
-        SkDELETE(buffer);
+        delete buffer;
 
         fBuffers[id] = reinterpret_cast<BufferObj*>(fFreeListHead);
         fFreeListHead = id;
     }
 
 private:
     static const intptr_t kFreeListEnd = -1;
     // Index of the first entry of fBuffers in the free list. Free slots in fBuffers are indices to
     // the next free slot. The last free slot has a value of kFreeListEnd.
     intptr_t                fFreeListHead;
@@ skipping 20 matching lines @@
         return reinterpret_cast<ThreadContext*>(SkTLS::Get(Create, Delete));
     }
 
     ThreadContext()
         : fCurrArrayBuffer(0)
         , fCurrElementArrayBuffer(0)
         , fCurrProgramID(0)
         , fCurrShaderID(0) {}
 
 private:
-    static void* Create() { return SkNEW(ThreadContext ); }
-    static void Delete(void* context) { SkDELETE(reinterpret_cast<ThreadContext *>(context)); }
+    static void* Create() { return new ThreadContext; }
+    static void Delete(void* context) { delete reinterpret_cast<ThreadContext*>(context); }
 };
 
 // Functions not declared in GrGLBogusInterface.h (not common with the Debug GL interface).
 
 GrGLvoid GR_GL_FUNCTION_TYPE nullGLActiveTexture(GrGLenum texture) {}
 GrGLvoid GR_GL_FUNCTION_TYPE nullGLAttachShader(GrGLuint program, GrGLuint shader) {}
 GrGLvoid GR_GL_FUNCTION_TYPE nullGLBeginQuery(GrGLenum target, GrGLuint id) {}
 GrGLvoid GR_GL_FUNCTION_TYPE nullGLBindAttribLocation(GrGLuint program, GrGLuint index, const char* name) {}
 GrGLvoid GR_GL_FUNCTION_TYPE nullGLBindTexture(GrGLenum target, GrGLuint texture) {}
 GrGLvoid GR_GL_FUNCTION_TYPE nullGLBindVertexArray(GrGLuint id) {}
@@ skipping 180 matching lines @@
             break; }
         default:
             SkFAIL("Unexpected pname to GetBufferParamateriv");
             break;
     }
 };
 
 } // end anonymous namespace
 
 const GrGLInterface* GrGLCreateNullInterface() {
-    GrGLInterface* interface = SkNEW(GrGLInterface);
+    GrGLInterface* interface = new GrGLInterface;
 
     interface->fStandard = kGL_GrGLStandard;
 
     GrGLInterface::Functions* functions = &interface->fFunctions;
     functions->fActiveTexture = nullGLActiveTexture;
     functions->fAttachShader = nullGLAttachShader;
     functions->fBeginQuery = nullGLBeginQuery;
     functions->fBindAttribLocation = nullGLBindAttribLocation;
     functions->fBindBuffer = nullGLBindBuffer;
     functions->fBindFragDataLocation = noOpGLBindFragDataLocation;
@@ skipping 127 matching lines @@
     functions->fBlitFramebuffer = noOpGLBlitFramebuffer;
     functions->fResolveMultisampleFramebuffer = noOpGLResolveMultisampleFramebuffer;
     functions->fMatrixLoadf = noOpGLMatrixLoadf;
     functions->fMatrixLoadIdentity = noOpGLMatrixLoadIdentity;
     functions->fBindFragDataLocationIndexed = noOpGLBindFragDataLocationIndexed;
 
     interface->fExtensions.init(kGL_GrGLStandard, functions->fGetString, functions->fGetStringi,
                                 functions->fGetIntegerv);
     return interface;
 }