Move to SkDataTable::MakeXXX and sk_sp.

src/core/SkDataTable.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkData.h"
 #include "SkDataTable.h"
+#include "SkOnce.h"
 
 static void malloc_freeproc(void* context) {
     sk_free(context);
 }
 
 // Makes empty table
 SkDataTable::SkDataTable() {
     fCount = 0;
     fElemSize = 0;   // 0 signals that we use fDir instead of fElems
     fU.fDir = nullptr;
@@ skipping 49 matching lines @@
     } else {
         if (size) {
             *size = fU.fDir[index].fSize;
         }
         return fU.fDir[index].fPtr;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkDataTable* SkDataTable::NewEmpty() {
-    static SkDataTable* gEmpty;
-    if (nullptr == gEmpty) {
-        gEmpty = new SkDataTable;
-    }
-    gEmpty->ref();
-    return gEmpty;
+sk_sp<SkDataTable> SkDataTable::MakeEmpty() {
+    static SkDataTable* singleton;
+    static SkOnce once;
+    once([]{ singleton = new SkDataTable(); });
+    return sk_ref_sp(singleton);
 }
 
-SkDataTable* SkDataTable::NewCopyArrays(const void * const * ptrs,
-                                        const size_t sizes[], int count) {
+sk_sp<SkDataTable> SkDataTable::MakeCopyArrays(const void * const * ptrs,
+                                               const size_t sizes[], int count) {
     if (count <= 0) {
-        return SkDataTable::NewEmpty();
+        return SkDataTable::MakeEmpty();
     }
 
     size_t dataSize = 0;
     for (int i = 0; i < count; ++i) {
         dataSize += sizes[i];
     }
 
     size_t bufferSize = count * sizeof(Dir) + dataSize;
     void* buffer = sk_malloc_throw(bufferSize);
 
     Dir* dir = (Dir*)buffer;
     char* elem = (char*)(dir + count);
     for (int i = 0; i < count; ++i) {
         dir[i].fPtr = elem;
         dir[i].fSize = sizes[i];
         memcpy(elem, ptrs[i], sizes[i]);
         elem += sizes[i];
     }
 
-    return new SkDataTable(dir, count, malloc_freeproc, buffer);
+    return sk_sp<SkDataTable>(new SkDataTable(dir, count, malloc_freeproc, buffer));
 }
 
-SkDataTable* SkDataTable::NewCopyArray(const void* array, size_t elemSize,
-                                       int count) {
+sk_sp<SkDataTable> SkDataTable::MakeCopyArray(const void* array, size_t elemSize, int count) {
     if (count <= 0) {
-        return SkDataTable::NewEmpty();
+        return SkDataTable::MakeEmpty();
     }
 
     size_t bufferSize = elemSize * count;
     void* buffer = sk_malloc_throw(bufferSize);
     memcpy(buffer, array, bufferSize);
 
-    return new SkDataTable(buffer, elemSize, count, malloc_freeproc, buffer);
+    return sk_sp<SkDataTable>(new SkDataTable(buffer, elemSize, count, malloc_freeproc, buffer));
 }
 
-SkDataTable* SkDataTable::NewArrayProc(const void* array, size_t elemSize,
-                                       int count, FreeProc proc, void* ctx) {
+sk_sp<SkDataTable> SkDataTable::MakeArrayProc(const void* array, size_t elemSize, int count,
+                                              FreeProc proc, void* ctx) {
     if (count <= 0) {
-        return SkDataTable::NewEmpty();
+        return SkDataTable::MakeEmpty();
     }
-    return new SkDataTable(array, elemSize, count, proc, ctx);
+    return sk_sp<SkDataTable>(new SkDataTable(array, elemSize, count, proc, ctx));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void chunkalloc_freeproc(void* context) { delete (SkChunkAlloc*)context; }
 
 SkDataTableBuilder::SkDataTableBuilder(size_t minChunkSize)
     : fHeap(nullptr)
     , fMinChunkSize(minChunkSize) {}
 
@@ skipping 14 matching lines @@
     }
 
     void* dst = fHeap->alloc(size, SkChunkAlloc::kThrow_AllocFailType);
     memcpy(dst, src, size);
 
     SkDataTable::Dir* dir = fDir.append();
     dir->fPtr = dst;
     dir->fSize = size;
 }
 
-SkDataTable* SkDataTableBuilder::detachDataTable() {
+sk_sp<SkDataTable> SkDataTableBuilder::detachDataTable() {
     const int count = fDir.count();
     if (0 == count) {
-        return SkDataTable::NewEmpty();
+        return SkDataTable::MakeEmpty();
     }
 
     // Copy the dir into the heap;
-    void* dir = fHeap->alloc(count * sizeof(SkDataTable::Dir),
-                             SkChunkAlloc::kThrow_AllocFailType);
+    void* dir = fHeap->alloc(count * sizeof(SkDataTable::Dir), SkChunkAlloc::kThrow_AllocFailType);
     memcpy(dir, fDir.begin(), count * sizeof(SkDataTable::Dir));
 
-    SkDataTable* table = new SkDataTable((SkDataTable::Dir*)dir, count, chunkalloc_freeproc, fHeap);
+    sk_sp<SkDataTable> table(
+        new SkDataTable((SkDataTable::Dir*)dir, count, chunkalloc_freeproc, fHeap));
     // we have to detach our fHeap, since we are giving that to the table
     fHeap = nullptr;
     fDir.reset();
     return table;
 }