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

src/gpu/gl/SkNullGLContext.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/SkNullGLContext.h"
 #include "gl/GrGLInterface.h"
 #include "GrGLDefines.h"
 #include "GrGLNoOpInterface.h"
 #include "SkTDArray.h"
 #include "SkTLS.h"
 
 static SkNullGLContext::ContextState* current_context();
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
 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 227 matching lines @@
     NullInterface(State* state) : fState(SkRef(state)) {}
     ~NullInterface() override {
         fState->unref();
     }
     State* fState;
 };
 
 } // end anonymous namespace
 
 static GrGLInterface* create_null_interface(State* state) {
-    GrGLInterface* interface = SkNEW_ARGS(NullInterface, (state));
+    GrGLInterface* interface = new NullInterface(state);
 
     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 131 matching lines @@
     functions->fBindFragDataLocationIndexed = noOpGLBindFragDataLocationIndexed;
 
     interface->fExtensions.init(kGL_GrGLStandard, functions->fGetString, functions->fGetStringi,
                                 functions->fGetIntegerv);
     return interface;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 static void* create_tls() {
-    State** current = SkNEW(State*);
+    State** current = new State*;
     *current = NULL;
     return current;
 }
 
 static void delete_tls(void* ctx) {
     State** current = static_cast<State**>(ctx);
     if (*current) {
         (*current)->unref();
     }
-    SkDELETE(current);
+    delete current;
 }
 
 static State* current_context() {
     return *static_cast<State**>(SkTLS::Get(create_tls, delete_tls));
 }
 
 static void set_current_context(State* state) {
     State** current = static_cast<State**>(SkTLS::Get(create_tls, delete_tls));
     if (*current) {
         (*current)->unref();
     }
     *current = state;
     if (state) {
         state->ref();
     }
 }
 
 #if GR_GL_PER_GL_FUNC_CALLBACK
 static void set_current_context_from_interface(const GrGLInterface* interface) {
     set_current_context(reinterpret_cast<State*>(interface->fCallbackData));
 }
 #endif
 
 SkNullGLContext* SkNullGLContext::Create(GrGLStandard forcedGpuAPI) {
     if (kGLES_GrGLStandard == forcedGpuAPI) {
         return NULL;
     }
-    SkNullGLContext* ctx = SkNEW(SkNullGLContext);
+    SkNullGLContext* ctx = new SkNullGLContext;
     if (!ctx->isValid()) {
-        SkDELETE(ctx);
+        delete ctx;
         return NULL;
     }
     return ctx;
 }
 
 SkNullGLContext::SkNullGLContext() {
-    fState = SkNEW(ContextState);
+    fState = new ContextState;
     GrGLInterface* interface = create_null_interface(fState);
     this->init(interface);
 #if GR_GL_PER_GL_FUNC_CALLBACK
     interface->fCallback = set_current_context_from_interface;
     interface->fCallbackData = reinterpret_cast<GrGLInterfaceCallbackData>(fState);
 #endif
 }
 
 SkNullGLContext::~SkNullGLContext() {
     this->teardown();
     fState->unref();
 }
 
 void SkNullGLContext::onPlatformMakeCurrent() const { set_current_context(fState); }