Move to SkDataTable::MakeXXX and sk_sp.

src/ports/SkFontMgr_fontconfig.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDataTable.h"
 #include "SkFixed.h"
 #include "SkFontDescriptor.h"
@@ skipping 485 matching lines @@
         : INHERITED(skfontstyle_from_fcpattern(pattern),
                     FC_PROPORTIONAL != get_int(pattern, FC_SPACING, FC_PROPORTIONAL))
         , fPattern(pattern)
     { };
 
     typedef SkTypeface_FreeType INHERITED;
 };
 
 class SkFontMgr_fontconfig : public SkFontMgr {
     mutable SkAutoFcConfig fFC;
-    SkAutoTUnref<SkDataTable> fFamilyNames;
+    sk_sp<SkDataTable> fFamilyNames;
     SkTypeface_FreeType::Scanner fScanner;
 
     class StyleSet : public SkFontStyleSet {
     public:
         /** @param parent does not take ownership of the reference.
          *  @param fontSet takes ownership of the reference.
          */
         StyleSet(const SkFontMgr_fontconfig* parent, FcFontSet* fontSet)
             : fFontMgr(SkRef(parent)), fFontSet(fontSet)
         { }
@@ skipping 55 matching lines @@
     static bool FindName(const SkTDArray<const char*>& list, const char* str) {
         int count = list.count();
         for (int i = 0; i < count; ++i) {
             if (!strcmp(list[i], str)) {
                 return true;
             }
         }
         return false;
     }
 
-    static SkDataTable* GetFamilyNames(FcConfig* fcconfig) {
+    static sk_sp<SkDataTable> GetFamilyNames(FcConfig* fcconfig) {
         FCLocker lock;
 
         SkTDArray<const char*> names;
         SkTDArray<size_t> sizes;
 
         static const FcSetName fcNameSet[] = { FcSetSystem, FcSetApplication };
         for (int setIndex = 0; setIndex < (int)SK_ARRAY_COUNT(fcNameSet); ++setIndex) {
             // Return value of FcConfigGetFonts must not be destroyed.
             FcFontSet* allFonts(FcConfigGetFonts(fcconfig, fcNameSet[setIndex]));
             if (nullptr == allFonts) {
@@ skipping 13 matching lines @@
                     }
                     const char* familyName = reinterpret_cast<const char*>(fcFamilyName);
                     if (familyName && !FindName(names, familyName)) {
                         *names.append() = familyName;
                         *sizes.append() = strlen(familyName) + 1;
                     }
                 }
             }
         }
 
-        return SkDataTable::NewCopyArrays((void const *const *)names.begin(),
-                                          sizes.begin(), names.count());
+        return SkDataTable::MakeCopyArrays((void const *const *)names.begin(),
+                                           sizes.begin(), names.count());
     }
 
     static bool FindByFcPattern(SkTypeface* cached, void* ctx) {
         SkTypeface_fontconfig* cshFace = static_cast<SkTypeface_fontconfig*>(cached);
         FcPattern* ctxPattern = static_cast<FcPattern*>(ctx);
         return FcTrue == FcPatternEqual(cshFace->fPattern, ctxPattern);
     }
 
     mutable SkMutex fTFCacheMutex;
     mutable SkTypefaceCache fTFCache;
@@ skipping 305 matching lines @@
             return typeface.release();
         }
 
         return this->matchFamilyStyle(nullptr, style);
     }
 };
 
 SK_API SkFontMgr* SkFontMgr_New_FontConfig(FcConfig* fc) {
     return new SkFontMgr_fontconfig(fc);
 }