Move to SkDataTable::MakeXXX and sk_sp.

include/core/SkDataTable.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkDataTable_DEFINED
 #define SkDataTable_DEFINED
 
@@ skipping 45 matching lines @@
      */
     const char* atStr(int index) const {
         size_t size;
         const char* str = this->atT<const char>(index, &size);
         SkASSERT(strlen(str) + 1 == size);
         return str;
     }
 
     typedef void (*FreeProc)(void* context);
 
-    static SkDataTable* NewEmpty();
+    static sk_sp<SkDataTable> MakeEmpty();
 
     /**
      *  Return a new DataTable that contains a copy of the data stored in each
      *  "array".
      *
      *  @param ptrs array of points to each element to be copied into the table.
      *  @param sizes array of byte-lengths for each entry in the corresponding
      *               ptrs[] array.
      *  @param count the number of array elements in ptrs[] and sizes[] to copy.
      */
-    static SkDataTable* NewCopyArrays(const void * const * ptrs,
-                                      const size_t sizes[], int count);
+    static sk_sp<SkDataTable> MakeCopyArrays(const void * const * ptrs,
+                                             const size_t sizes[], int count);
 
     /**
      *  Return a new table that contains a copy of the data in array.
      *
      *  @param array contiguous array of data for all elements to be copied.
      *  @param elemSize byte-length for a given element.
      *  @param count the number of entries to be copied out of array. The number
      *               of bytes that will be copied is count * elemSize.
      */
-    static SkDataTable* NewCopyArray(const void* array, size_t elemSize,
-                                     int count);
+    static sk_sp<SkDataTable> MakeCopyArray(const void* array, size_t elemSize, int count);
 
-    static SkDataTable* NewArrayProc(const void* array, size_t elemSize,
-                                     int count, FreeProc proc, void* context);
+    static sk_sp<SkDataTable> MakeArrayProc(const void* array, size_t elemSize, int count,
+                                            FreeProc proc, void* context);
 
 private:
     struct Dir {
         const void* fPtr;
         uintptr_t   fSize;
     };
 
     int         fCount;
     size_t      fElemSize;
     union {
@@ skipping 54 matching lines @@
      */
     void appendString(const SkString& string) {
         this->append(string.c_str(), string.size() + 1);
     }
 
     /**
      *  Return an SkDataTable from the accumulated entries that were added by
      *  calls to append(). This call also clears any accumluated entries from
      *  this builder, so its count() will be 0 after this call.
      */
-    SkDataTable* detachDataTable();
+    sk_sp<SkDataTable> detachDataTable();
 
 private:
     SkTDArray<SkDataTable::Dir> fDir;
     SkChunkAlloc*               fHeap;
     size_t                      fMinChunkSize;
 };
 
 #endif