detach -> release

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 178 matching lines @@
     FcLangSetAdd(strongLangSet, (const FcChar8*)"nomatchlang");
     SkAutoFcPattern strong(FcPatternDuplicate(minimal));
     FcPatternAddLangSet(strong, FC_LANG, strongLangSet);
 
     SkAutoFcLangSet weakLangSet;
     FcLangSetAdd(weakLangSet, (const FcChar8*)"matchlang");
     SkAutoFcPattern weak;
     FcPatternAddString(weak, object, (const FcChar8*)"nomatchstring");
     FcPatternAddLangSet(weak, FC_LANG, weakLangSet);
 
-    FcFontSetAdd(fontSet, strong.detach());
-    FcFontSetAdd(fontSet, weak.detach());
+    FcFontSetAdd(fontSet, strong.release());
+    FcFontSetAdd(fontSet, weak.release());
 
     // Add 'matchlang' to the copy of the pattern.
     FcPatternAddLangSet(minimal, FC_LANG, weakLangSet);
 
     // Run a match against the copy of the pattern.
     // If the 'id' was weak, then we should match the pattern with 'matchlang'.
     // If the 'id' was strong, then we should match the pattern with 'nomatchlang'.
 
     // Note that this config is only used for FcFontRenderPrepare, which we don't even want.
     // However, there appears to be no way to match/sort without it.
@@ skipping 507 matching lines @@
             }
 
             for (int fontIndex = 0; fontIndex < allFonts->nfont; ++fontIndex) {
                 FcPattern* font = allFonts->fonts[fontIndex];
                 if (FontAccessible(font) && FontFamilyNameMatches(font, matchPattern)) {
                     FcFontSetAdd(matches, FcFontRenderPrepare(fFC, pattern, font));
                 }
             }
         }
 
-        return new StyleSet(this, matches.detach());
+        return new StyleSet(this, matches.release());
     }
 
     virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
                                            const SkFontStyle& style) const override
     {
         FCLocker lock;
 
         SkAutoFcPattern pattern;
         FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName);
         fcpattern_from_skfontstyle(style, pattern);
@@ skipping 84 matching lines @@
         if (length <= 0 || (1u << 30) < length) {
             return nullptr;
         }
 
         SkFontStyle style;
         bool isFixedWidth = false;
         if (!fScanner.scanFont(stream, ttcIndex, nullptr, &style, &isFixedWidth, nullptr)) {
             return nullptr;
         }
 
-        return new SkTypeface_stream(new SkFontData(stream.detach(), ttcIndex, nullptr, 0), style,
+        return new SkTypeface_stream(new SkFontData(stream.release(), ttcIndex, nullptr, 0), style,
                                      isFixedWidth);
     }
 
     SkTypeface* onCreateFromStream(SkStreamAsset* s, const FontParameters& params) const override {
         using Scanner = SkTypeface_FreeType::Scanner;
         SkAutoTDelete<SkStreamAsset> stream(s);
         bool isFixedPitch;
         SkFontStyle style;
         SkString name;
         Scanner::AxisDefinitions axisDefinitions;
         if (!fScanner.scanFont(stream, params.getCollectionIndex(), &name, &style, &isFixedPitch,
                                &axisDefinitions))
         {
             return nullptr;
         }
 
         int paramAxisCount;
         const FontParameters::Axis* paramAxes = params.getAxes(&paramAxisCount);
         SkAutoSTMalloc<4, SkFixed> axisValues(axisDefinitions.count());
         Scanner::computeAxisValues(axisDefinitions, paramAxes, paramAxisCount, axisValues, name);
 
-        SkFontData* data(new SkFontData(stream.detach(), params.getCollectionIndex(),
+        SkFontData* data(new SkFontData(stream.release(), params.getCollectionIndex(),
                                         axisValues.get(), axisDefinitions.count()));
         return new SkTypeface_stream(data, style, isFixedPitch);
     }
 
     SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override {
         return this->createFromStream(new SkMemoryStream(data), ttcIndex);
     }
 
     SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
         return this->createFromStream(SkStream::NewFromFile(path), ttcIndex);
@@ skipping 20 matching lines @@
                                                unsigned styleBits) const override {
         bool bold = styleBits & SkTypeface::kBold;
         bool italic = styleBits & SkTypeface::kItalic;
         SkFontStyle style = SkFontStyle(bold ? SkFontStyle::kBold_Weight
                                              : SkFontStyle::kNormal_Weight,
                                         SkFontStyle::kNormal_Width,
                                         italic ? SkFontStyle::kItalic_Slant
                                                : SkFontStyle::kUpright_Slant);
         SkAutoTUnref<SkTypeface> typeface(this->matchFamilyStyle(familyName, style));
         if (typeface.get()) {
-            return typeface.detach();
+            return typeface.release();
         }
 
         return this->matchFamilyStyle(nullptr, style);
     }
 };
 
 SK_API SkFontMgr* SkFontMgr_New_FontConfig(FcConfig* fc) {
     return new SkFontMgr_fontconfig(fc);
 }