Move SkTypeface to sk_sp.
Committed: https://skia.googlesource.com/skia/+/6296da736fbf40aae881650c239420f64e576c3f
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1933393002
Review-Url: https://codereview.chromium.org/1933393002
diff --git a/bench/CmapBench.cpp b/bench/CmapBench.cpp
index a2fb506..49e89be 100644
--- a/bench/CmapBench.cpp
+++ b/bench/CmapBench.cpp
@@ -77,7 +77,7 @@
// we're jamming values into utf8, so we must keep it legal utf8
fText[i] = 'A' + (i & 31);
}
- fPaint.setTypeface(SkTypeface::RefDefault())->unref();
+ fPaint.setTypeface(SkTypeface::MakeDefault());
}
protected:
diff --git a/bench/SkGlyphCacheBench.cpp b/bench/SkGlyphCacheBench.cpp
index 2e0429f..c5e40af 100644
--- a/bench/SkGlyphCacheBench.cpp
+++ b/bench/SkGlyphCacheBench.cpp
@@ -53,18 +53,15 @@
void onDraw(int loops, SkCanvas*) override {
size_t oldCacheLimitSize = SkGraphics::GetFontCacheLimit();
SkGraphics::SetFontCacheLimit(fCacheSize);
- SkTypeface* typeface = sk_tool_utils::create_portable_typeface(
- "serif", SkTypeface::kItalic);
SkPaint paint;
paint.setAntiAlias(true);
paint.setSubpixelText(true);
- paint.setTypeface(typeface);
+ paint.setTypeface(sk_tool_utils::create_portable_typeface("serif", SkTypeface::kItalic));
for (int work = 0; work < loops; work++) {
do_font_stuff(&paint);
}
SkGraphics::SetFontCacheLimit(oldCacheLimitSize);
- SkSafeUnref(typeface);
}
private:
@@ -90,7 +87,7 @@
void onDraw(int loops, SkCanvas*) override {
size_t oldCacheLimitSize = SkGraphics::GetFontCacheLimit();
SkGraphics::SetFontCacheLimit(fCacheSize);
- SkTypeface* typefaces[] =
+ sk_sp<SkTypeface> typefaces[] =
{sk_tool_utils::create_portable_typeface("serif", SkTypeface::kItalic),
sk_tool_utils::create_portable_typeface("sans-serif", SkTypeface::kItalic)};
@@ -104,8 +101,6 @@
});
}
SkGraphics::SetFontCacheLimit(oldCacheLimitSize);
- SkSafeUnref(typefaces[0]);
- SkSafeUnref(typefaces[1]);
}
private:
diff --git a/bench/TextBench.cpp b/bench/TextBench.cpp
index 04f824c..a048ffd 100644
--- a/bench/TextBench.cpp
+++ b/bench/TextBench.cpp
@@ -47,7 +47,7 @@
FontQuality fFQ;
bool fDoPos;
bool fDoColorEmoji;
- SkAutoTUnref<SkTypeface> fColorEmojiTypeface;
+ sk_sp<SkTypeface> fColorEmojiTypeface;
SkPoint* fPos;
public:
TextBench(const char text[], int ps,
@@ -71,7 +71,7 @@
void onDelayedSetup() override {
if (fDoColorEmoji) {
SkASSERT(kBW == fFQ);
- fColorEmojiTypeface.reset(GetResourceAsTypeface("/fonts/Funkster.ttf"));
+ fColorEmojiTypeface = MakeResourceAsTypeface("/fonts/Funkster.ttf");
}
if (fDoPos) {
diff --git a/bench/TextBlobBench.cpp b/bench/TextBlobBench.cpp
index a350e7b..37bf311 100644
--- a/bench/TextBlobBench.cpp
+++ b/bench/TextBlobBench.cpp
@@ -23,13 +23,11 @@
*/
class TextBlobBench : public Benchmark {
public:
- TextBlobBench()
- : fTypeface(nullptr) {
- }
+ TextBlobBench() {}
protected:
void onDelayedSetup() override {
- fTypeface.reset(sk_tool_utils::create_portable_typeface("serif", SkTypeface::kNormal));
+ fTypeface = sk_tool_utils::create_portable_typeface("serif", SkTypeface::kNormal);
// make textblob
SkPaint paint;
paint.setTypeface(fTypeface);
@@ -64,9 +62,9 @@
private:
- SkAutoTUnref<const SkTextBlob> fBlob;
- SkTDArray<uint16_t> fGlyphs;
- SkAutoTUnref<SkTypeface> fTypeface;
+ SkAutoTUnref<const SkTextBlob> fBlob;
+ SkTDArray<uint16_t> fGlyphs;
+ sk_sp<SkTypeface> fTypeface;
typedef Benchmark INHERITED;
};
diff --git a/dm/DM.cpp b/dm/DM.cpp
index 5ebabc0..5660296 100644
--- a/dm/DM.cpp
+++ b/dm/DM.cpp
@@ -1286,7 +1286,7 @@
#define PORTABLE_FONT_PREFIX "Toy Liberation "
-static SkTypeface* create_from_name(const char familyName[], SkTypeface::Style style) {
+static sk_sp<SkTypeface> create_from_name(const char familyName[], SkTypeface::Style style) {
if (familyName && strlen(familyName) > sizeof(PORTABLE_FONT_PREFIX)
&& !strncmp(familyName, PORTABLE_FONT_PREFIX, sizeof(PORTABLE_FONT_PREFIX) - 1)) {
return sk_tool_utils::create_portable_typeface(familyName, style);
@@ -1296,7 +1296,7 @@
#undef PORTABLE_FONT_PREFIX
-extern SkTypeface* (*gCreateTypefaceDelegate)(const char [], SkTypeface::Style );
+extern sk_sp<SkTypeface> (*gCreateTypefaceDelegate)(const char [], SkTypeface::Style );
int dm_main();
int dm_main() {
diff --git a/fuzz/FilterFuzz.cpp b/fuzz/FilterFuzz.cpp
index cad3246..bbc403c 100644
--- a/fuzz/FilterFuzz.cpp
+++ b/fuzz/FilterFuzz.cpp
@@ -512,9 +512,7 @@
if (false) {
// our validating buffer does not support typefaces yet, so skip this for now
- SkAutoTUnref<SkTypeface> typeface(
- SkTypeface::CreateFromName(make_font_name().c_str(), make_typeface_style()));
- paint.setTypeface(typeface);
+ paint.setTypeface(SkTypeface::MakeFromName(make_font_name().c_str(),make_typeface_style()));
}
SkLayerRasterizer::Builder rasterizerBuilder;
diff --git a/gm/coloremoji.cpp b/gm/coloremoji.cpp
index ebb3c67..b29040a 100644
--- a/gm/coloremoji.cpp
+++ b/gm/coloremoji.cpp
@@ -50,11 +50,11 @@
protected:
struct EmojiFont {
- SkAutoTUnref<SkTypeface> typeface;
+ sk_sp<SkTypeface> typeface;
const char* text;
} emojiFont;
virtual void onOnceBeforeDraw() override {
- sk_tool_utils::emoji_typeface(&emojiFont.typeface);
+ emojiFont.typeface = sk_tool_utils::emoji_typeface();
emojiFont.text = sk_tool_utils::emoji_sample_text();
}
@@ -92,7 +92,7 @@
for (int makeBlur = 0; makeBlur < 2; makeBlur++) {
for (int makeGray = 0; makeGray < 2; makeGray++) {
SkPaint shaderPaint;
- shaderPaint.setTypeface(paint.getTypeface());
+ shaderPaint.setTypeface(sk_ref_sp(paint.getTypeface()));
if (SkToBool(makeLinear)) {
shaderPaint.setShader(MakeLinear());
}
diff --git a/gm/colortype.cpp b/gm/colortype.cpp
index c9314de..68dfeee 100644
--- a/gm/colortype.cpp
+++ b/gm/colortype.cpp
@@ -12,13 +12,7 @@
class ColorTypeGM : public skiagm::GM {
public:
- ColorTypeGM()
- : fColorType(nullptr) {
- }
-
- virtual ~ColorTypeGM() {
- SkSafeUnref(fColorType);
- }
+ ColorTypeGM() {}
protected:
void onOnceBeforeDraw() override {
@@ -33,12 +27,11 @@
paint.setShader(SkGradientShader::MakeSweep(0, 0, colors, nullptr, SK_ARRAY_COUNT(colors),
0, &local));
- SkTypeface* orig = sk_tool_utils::create_portable_typeface("serif", SkTypeface::kBold);
+ sk_sp<SkTypeface> orig(sk_tool_utils::create_portable_typeface("serif", SkTypeface::kBold));
if (nullptr == orig) {
- orig = SkTypeface::RefDefault();
+ orig = SkTypeface::MakeDefault();
}
- fColorType = new SkGTypeface(orig, paint);
- orig->unref();
+ fColorType = sk_make_sp<SkGTypeface>(std::move(orig), paint);
}
SkString onShortName() override {
@@ -62,7 +55,7 @@
}
private:
- SkTypeface* fColorType;
+ sk_sp<SkTypeface> fColorType;
typedef skiagm::GM INHERITED;
};
diff --git a/gm/colortypexfermode.cpp b/gm/colortypexfermode.cpp
index 36db2aa..058b92d 100644
--- a/gm/colortypexfermode.cpp
+++ b/gm/colortypexfermode.cpp
@@ -19,13 +19,7 @@
public:
const static int W = 64;
const static int H = 64;
- ColorTypeXfermodeGM()
- : fColorType(nullptr) {
- }
-
- virtual ~ColorTypeXfermodeGM() {
- SkSafeUnref(fColorType);
- }
+ ColorTypeXfermodeGM() {}
protected:
void onOnceBeforeDraw() override {
@@ -40,12 +34,11 @@
paint.setShader(SkGradientShader::MakeSweep(0, 0, colors, nullptr, SK_ARRAY_COUNT(colors),
0, &local));
- SkTypeface* orig = sk_tool_utils::create_portable_typeface("serif", SkTypeface::kBold);
+ sk_sp<SkTypeface> orig(sk_tool_utils::create_portable_typeface("serif", SkTypeface::kBold));
if (nullptr == orig) {
- orig = SkTypeface::RefDefault();
+ orig = SkTypeface::MakeDefault();
}
- fColorType = new SkGTypeface(orig, paint);
- orig->unref();
+ fColorType = sk_make_sp<SkGTypeface>(orig, paint);
fBG.installPixels(SkImageInfo::Make(2, 2, kARGB_4444_SkColorType,
kOpaque_SkAlphaType), gData, 4);
@@ -149,8 +142,8 @@
}
private:
- SkBitmap fBG;
- SkTypeface* fColorType;
+ SkBitmap fBG;
+ sk_sp<SkTypeface> fColorType;
typedef GM INHERITED;
};
diff --git a/gm/dftext.cpp b/gm/dftext.cpp
index e6aba08..c7d9a8b 100644
--- a/gm/dftext.cpp
+++ b/gm/dftext.cpp
@@ -19,7 +19,7 @@
protected:
void onOnceBeforeDraw() override {
- sk_tool_utils::emoji_typeface(&fEmojiTypeface);
+ fEmojiTypeface = sk_tool_utils::emoji_typeface();
fEmojiText = sk_tool_utils::emoji_sample_text();
}
@@ -210,7 +210,7 @@
}
private:
- SkAutoTUnref<SkTypeface> fEmojiTypeface;
+ sk_sp<SkTypeface> fEmojiTypeface;
const char* fEmojiText;
typedef skiagm::GM INHERITED;
diff --git a/gm/fontcache.cpp b/gm/fontcache.cpp
index 30f8892..c4af489 100644
--- a/gm/fontcache.cpp
+++ b/gm/fontcache.cpp
@@ -20,15 +20,7 @@
class FontCacheGM : public skiagm::GM {
public:
- FontCacheGM() {
- fTypefaces[0] = nullptr;
- fTypefaces[1] = nullptr;
- }
-
- virtual ~FontCacheGM() {
- SkSafeUnref(fTypefaces[0]);
- SkSafeUnref(fTypefaces[1]);
- }
+ FontCacheGM() {}
protected:
SkString onShortName() override {
@@ -76,7 +68,7 @@
}
private:
- SkTypeface* fTypefaces[2];
+ sk_sp<SkTypeface> fTypefaces[2];
typedef GM INHERITED;
};
diff --git a/gm/fontmgr.cpp b/gm/fontmgr.cpp
index 1975f99..a4dc263 100644
--- a/gm/fontmgr.cpp
+++ b/gm/fontmgr.cpp
@@ -31,9 +31,9 @@
// find typeface containing the requested character and draw it
SkString ch;
ch.appendUnichar(character);
- SkTypeface* typeface = fm->matchFamilyStyleCharacter(fontName, fontStyle,
- bcp47, bcp47Count, character);
- SkSafeUnref(paint.setTypeface(typeface));
+ sk_sp<SkTypeface> typeface(fm->matchFamilyStyleCharacter(fontName, fontStyle,
+ bcp47, bcp47Count, character));
+ paint.setTypeface(typeface);
x = drawString(canvas, ch, x, y, paint) + 20;
if (nullptr == typeface) {
@@ -45,8 +45,8 @@
// it expects to get the same glyph when following this pattern.
SkString familyName;
typeface->getFamilyName(&familyName);
- SkTypeface* typefaceCopy = fm->legacyCreateTypeface(familyName.c_str(), typeface->fontStyle());
- SkSafeUnref(paint.setTypeface(typefaceCopy));
+ paint.setTypeface(sk_sp<SkTypeface>(fm->legacyCreateTypeface(familyName.c_str(),
+ typeface->fontStyle())));
return drawString(canvas, ch, x, y, paint) + 20;
}
@@ -104,7 +104,7 @@
set->getStyle(j, &fs, &sname);
sname.appendf(" [%d %d %d]", fs.weight(), fs.width(), fs.slant());
- SkSafeUnref(paint.setTypeface(set->createTypeface(j)));
+ paint.setTypeface(sk_sp<SkTypeface>(set->createTypeface(j)));
x = drawString(canvas, sname, x, y, paint) + 20;
// check to see that we get different glyphs in japanese and chinese
@@ -155,7 +155,7 @@
sname.appendf(" [%d %d]", fs.weight(), fs.width());
- SkSafeUnref(p.setTypeface(fset->createTypeface(j)));
+ p.setTypeface(sk_sp<SkTypeface>(fset->createTypeface(j)));
(void)drawString(canvas, sname, 0, y, p);
y += 24;
}
@@ -169,11 +169,11 @@
for (int weight = 100; weight <= 900; weight += 200) {
for (int width = 1; width <= 9; width += 2) {
SkFontStyle fs(weight, width, SkFontStyle::kUpright_Slant);
- SkTypeface* face = fset->matchStyle(fs);
+ sk_sp<SkTypeface> face(fset->matchStyle(fs));
if (face) {
SkString str;
str.printf("request [%d %d]", fs.weight(), fs.width());
- p.setTypeface(face)->unref();
+ p.setTypeface(std::move(face));
(void)drawString(canvas, str, 0, y, p);
y += 24;
}
@@ -274,7 +274,7 @@
for (int i = 0; i < count; ++i) {
SkAutoTUnref<SkFontStyleSet> set(fm->createStyleSet(i));
for (int j = 0; j < set->count(); ++j) {
- SkSafeUnref(paint.setTypeface(set->createTypeface(j)));
+ paint.setTypeface(sk_sp<SkTypeface>(set->createTypeface(j)));
if (paint.getTypeface()) {
show_bounds(canvas, paint, x, y, boundsColors[index & 1]);
index += 1;
diff --git a/gm/fontscalerdistortable.cpp b/gm/fontscalerdistortable.cpp
index f83365b..b4f2ca3 100644
--- a/gm/fontscalerdistortable.cpp
+++ b/gm/fontscalerdistortable.cpp
@@ -58,9 +58,8 @@
SkFourByteTag tag = SkSetFourByteTag('w','g','h','t');
SkScalar styleValue = SkDoubleToScalar(0.5 + (5*j + i) * ((2.0 - 0.5) / (2 * 5)));
SkFontMgr::FontParameters::Axis axes[] = { { tag, styleValue } };
- SkAutoTUnref<SkTypeface> typeface(fontMgr->createFromStream(
- distortable->duplicate(), SkFontMgr::FontParameters().setAxes(axes, 1)));
- paint.setTypeface(typeface);
+ paint.setTypeface(sk_sp<SkTypeface>(fontMgr->createFromStream(
+ distortable->duplicate(), SkFontMgr::FontParameters().setAxes(axes, 1))));
SkAutoCanvasRestore acr(canvas, true);
canvas->translate(SkIntToScalar(30 + i * 100), SkIntToScalar(20));
diff --git a/gm/gammatext.cpp b/gm/gammatext.cpp
index bc5feb3..c7d4309 100644
--- a/gm/gammatext.cpp
+++ b/gm/gammatext.cpp
@@ -19,12 +19,8 @@
}
static bool setFont(SkPaint* paint, const char name[]) {
- SkTypeface* tf = SkTypeface::CreateFromName(name, SkTypeface::kNormal);
- if (tf) {
- paint->setTypeface(tf)->unref();
- return true;
- }
- return false;
+ paint->setTypeface(SkTypeface::MakeFromName(name, SkTypeface::kNormal));
+ return SkToBool(paint->getTypeface());
}
/**
@@ -108,8 +104,7 @@
}
static void set_face(SkPaint* paint) {
- SkTypeface* face = SkTypeface::CreateFromName("serif", SkTypeface::kItalic);
- SkSafeUnref(paint->setTypeface(face));
+ paint->setTypeface(SkTypeface::MakeFromName("serif", SkTypeface::kItalic));
}
static void draw_pair(SkCanvas* canvas, SkPaint* paint, const sk_sp<SkShader>& shader) {
diff --git a/gm/mixedtextblobs.cpp b/gm/mixedtextblobs.cpp
index e66e73c..9a9bded 100644
--- a/gm/mixedtextblobs.cpp
+++ b/gm/mixedtextblobs.cpp
@@ -39,9 +39,9 @@
protected:
void onOnceBeforeDraw() override {
- sk_tool_utils::emoji_typeface(&fEmojiTypeface);
+ fEmojiTypeface = sk_tool_utils::emoji_typeface();
fEmojiText = sk_tool_utils::emoji_sample_text();
- fReallyBigATypeface.reset(GetResourceAsTypeface("/fonts/ReallyBigA.ttf"));
+ fReallyBigATypeface = MakeResourceAsTypeface("/fonts/ReallyBigA.ttf");
SkTextBlobBuilder builder;
@@ -150,8 +150,8 @@
}
private:
- SkAutoTUnref<SkTypeface> fEmojiTypeface;
- SkAutoTUnref<SkTypeface> fReallyBigATypeface;
+ sk_sp<SkTypeface> fEmojiTypeface;
+ sk_sp<SkTypeface> fReallyBigATypeface;
const char* fEmojiText;
SkAutoTUnref<const SkTextBlob> fBlob;
diff --git a/gm/pdf_never_embed.cpp b/gm/pdf_never_embed.cpp
index ef7974e..4fba40e 100644
--- a/gm/pdf_never_embed.cpp
+++ b/gm/pdf_never_embed.cpp
@@ -25,16 +25,15 @@
}
DEF_SIMPLE_GM(pdf_never_embed, canvas, 512, 512) {
- const char resource[] = "fonts/Roboto2-Regular_NoEmbed.ttf";
- SkAutoTUnref<SkTypeface> typeface(GetResourceAsTypeface(resource));
- if (!typeface) {
- return;
- }
SkPaint p;
p.setTextSize(60);
- p.setTypeface(typeface);
+ p.setTypeface(MakeResourceAsTypeface("fonts/Roboto2-Regular_NoEmbed.ttf"));
p.setAntiAlias(true);
+ if (!p.getTypeface()) {
+ return;
+ }
+
const char text[] = "HELLO, WORLD!";
canvas->drawColor(SK_ColorWHITE);
diff --git a/gm/poly2poly.cpp b/gm/poly2poly.cpp
index ea77033..4eb9936 100644
--- a/gm/poly2poly.cpp
+++ b/gm/poly2poly.cpp
@@ -224,7 +224,7 @@
}
void onOnceBeforeDraw() override {
- fEmFace.reset(GetResourceAsTypeface("/fonts/Em.ttf"));
+ fEmFace = MakeResourceAsTypeface("/fonts/Em.ttf");
}
void onDraw(SkCanvas* canvas) override {
@@ -273,7 +273,7 @@
private:
typedef skiagm::GM INHERITED;
- SkAutoTUnref<SkTypeface> fEmFace;
+ sk_sp<SkTypeface> fEmFace;
};
//////////////////////////////////////////////////////////////////////////////
diff --git a/gm/textblob.cpp b/gm/textblob.cpp
index 02f3c87..525cfd2 100644
--- a/gm/textblob.cpp
+++ b/gm/textblob.cpp
@@ -72,7 +72,7 @@
protected:
void onOnceBeforeDraw() override {
- fTypeface.reset(sk_tool_utils::create_portable_typeface("serif", SkTypeface::kNormal));
+ fTypeface = sk_tool_utils::create_portable_typeface("serif", SkTypeface::kNormal);
SkPaint p;
p.setTypeface(fTypeface);
size_t txtLen = strlen(fText);
@@ -180,9 +180,9 @@
return builder.build();
}
- SkTDArray<uint16_t> fGlyphs;
- SkAutoTUnref<SkTypeface> fTypeface;
- const char* fText;
+ SkTDArray<uint16_t> fGlyphs;
+ sk_sp<SkTypeface> fTypeface;
+ const char* fText;
typedef skiagm::GM INHERITED;
};
diff --git a/gm/textblobmixedsizes.cpp b/gm/textblobmixedsizes.cpp
index 9e57c2f..8f5dc85 100644
--- a/gm/textblobmixedsizes.cpp
+++ b/gm/textblobmixedsizes.cpp
@@ -27,7 +27,6 @@
protected:
void onOnceBeforeDraw() override {
- SkAutoTUnref<SkTypeface> typeface(GetResourceAsTypeface("/fonts/HangingS.ttf"));
SkTextBlobBuilder builder;
// make textblob. To stress distance fields, we choose sizes appropriately
@@ -35,7 +34,7 @@
paint.setAntiAlias(true);
paint.setSubpixelText(true);
paint.setLCDRenderText(true);
- paint.setTypeface(typeface);
+ paint.setTypeface(MakeResourceAsTypeface("/fonts/HangingS.ttf"));
const char* text = "Skia";
diff --git a/gm/textblobrandomfont.cpp b/gm/textblobrandomfont.cpp
index 267fe7a..51dbfce 100644
--- a/gm/textblobrandomfont.cpp
+++ b/gm/textblobrandomfont.cpp
@@ -39,13 +39,12 @@
paint.setLCDRenderText(true);
// Setup our random scaler context
- SkAutoTUnref<SkTypeface> orig(sk_tool_utils::create_portable_typeface("sans-serif",
- SkTypeface::kBold));
+ sk_sp<SkTypeface> orig(sk_tool_utils::create_portable_typeface("sans-serif",
+ SkTypeface::kBold));
if (nullptr == orig) {
- orig.reset(SkTypeface::RefDefault());
+ orig = SkTypeface::MakeDefault();
}
- SkAutoTUnref<SkTypeface> random(new SkRandomTypeface(orig, paint, false));
- paint.setTypeface(random);
+ paint.setTypeface(sk_make_sp<SkRandomTypeface>(orig, paint, false));
SkRect bounds;
paint.measureText(text, strlen(text), &bounds);
@@ -66,16 +65,14 @@
sk_tool_utils::add_to_text_blob(&builder, bigtext2, paint, 0, offset);
// color emoji
- SkAutoTUnref<SkTypeface> origEmoji;
- sk_tool_utils::emoji_typeface(&origEmoji);
+ sk_sp<SkTypeface> origEmoji = sk_tool_utils::emoji_typeface();
const char* osName = sk_tool_utils::platform_os_name();
// The mac emoji string will break us
if (origEmoji && (!strcmp(osName, "Android") || !strcmp(osName, "Ubuntu"))) {
const char* emojiText = sk_tool_utils::emoji_sample_text();
paint.measureText(emojiText, strlen(emojiText), &bounds);
offset += bounds.height();
- SkAutoTUnref<SkTypeface> randomEmoji(new SkRandomTypeface(orig, paint, false));
- paint.setTypeface(randomEmoji);
+ paint.setTypeface(sk_make_sp<SkRandomTypeface>(orig, paint, false));
sk_tool_utils::add_to_text_blob(&builder, emojiText, paint, 0, offset);
}
diff --git a/gm/typeface.cpp b/gm/typeface.cpp
index d88efa5..e77d277 100644
--- a/gm/typeface.cpp
+++ b/gm/typeface.cpp
@@ -90,7 +90,7 @@
static const int gFaceStylesCount = SK_ARRAY_COUNT(gFaceStyles);
class TypefaceStylesGM : public skiagm::GM {
- SkTypeface* fFaces[gFaceStylesCount];
+ sk_sp<SkTypeface> fFaces[gFaceStylesCount];
bool fApplyKerning;
public:
@@ -99,16 +99,10 @@
memset(fFaces, 0, sizeof(fFaces));
}
- virtual ~TypefaceStylesGM() {
- for (int i = 0; i < gFaceStylesCount; i++) {
- SkSafeUnref(fFaces[i]);
- }
- }
-
protected:
void onOnceBeforeDraw() override {
for (int i = 0; i < gFaceStylesCount; i++) {
- fFaces[i] = SkTypeface::CreateFromName(
+ fFaces[i] = SkTypeface::MakeFromName(
sk_tool_utils::platform_font_name(gFaceStyles[i].fName), gFaceStyles[i].fStyle);
}
}
diff --git a/gm/variedtext.cpp b/gm/variedtext.cpp
index 83fe720..e295cbc 100644
--- a/gm/variedtext.cpp
+++ b/gm/variedtext.cpp
@@ -21,13 +21,6 @@
VariedTextGM(bool effectiveClip, bool lcd)
: fEffectiveClip(effectiveClip)
, fLCD(lcd) {
- memset(fTypefacesToUnref, 0, sizeof(fTypefacesToUnref));
- }
-
- ~VariedTextGM() {
- for (size_t i = 0; i < SK_ARRAY_COUNT(fTypefacesToUnref); ++i) {
- SkSafeUnref(fTypefacesToUnref[i]);
- }
}
protected:
@@ -58,11 +51,11 @@
SkScalar w = SkIntToScalar(size.fWidth);
SkScalar h = SkIntToScalar(size.fHeight);
- static_assert(4 == SK_ARRAY_COUNT(fTypefacesToUnref), "typeface_cnt");
- fTypefacesToUnref[0] = sk_tool_utils::create_portable_typeface("sans-serif", SkTypeface::kNormal);
- fTypefacesToUnref[1] = sk_tool_utils::create_portable_typeface("sans-serif", SkTypeface::kBold);
- fTypefacesToUnref[2] = sk_tool_utils::create_portable_typeface("serif", SkTypeface::kNormal);
- fTypefacesToUnref[3] = sk_tool_utils::create_portable_typeface("serif", SkTypeface::kBold);
+ static_assert(4 == SK_ARRAY_COUNT(fTypefaces), "typeface_cnt");
+ fTypefaces[0] = sk_tool_utils::create_portable_typeface("sans-serif", SkTypeface::kNormal);
+ fTypefaces[1] = sk_tool_utils::create_portable_typeface("sans-serif", SkTypeface::kBold);
+ fTypefaces[2] = sk_tool_utils::create_portable_typeface("serif", SkTypeface::kNormal);
+ fTypefaces[3] = sk_tool_utils::create_portable_typeface("serif", SkTypeface::kBold);
SkRandom random;
for (int i = 0; i < kCnt; ++i) {
@@ -82,12 +75,11 @@
fPtSizes[i] = random.nextRangeScalar(kMinPtSize, kMaxPtSize);
- fTypefaces[i] = fTypefacesToUnref[
- random.nextULessThan(SK_ARRAY_COUNT(fTypefacesToUnref))];
+ fTypefaceIndices[i] = random.nextULessThan(SK_ARRAY_COUNT(fTypefaces));
SkRect r;
fPaint.setColor(fColors[i]);
- fPaint.setTypeface(fTypefaces[i]);
+ fPaint.setTypeface(fTypefaces[fTypefaceIndices[i]]);
fPaint.setTextSize(fPtSizes[i]);
fPaint.measureText(fStrings[i].c_str(), fStrings[i].size(), &r);
@@ -116,7 +108,7 @@
for (int i = 0; i < kCnt; ++i) {
fPaint.setColor(fColors[i]);
fPaint.setTextSize(fPtSizes[i]);
- fPaint.setTypeface(fTypefaces[i]);
+ fPaint.setTypeface(fTypefaces[fTypefaceIndices[i]]);
canvas->save();
canvas->clipRect(fClipRects[i]);
@@ -146,14 +138,14 @@
bool fEffectiveClip;
bool fLCD;
- SkTypeface* fTypefacesToUnref[4];
+ sk_sp<SkTypeface> fTypefaces[4];
SkPaint fPaint;
// precomputed for each text draw
SkString fStrings[kCnt];
SkColor fColors[kCnt];
SkScalar fPtSizes[kCnt];
- SkTypeface* fTypefaces[kCnt];
+ int fTypefaceIndices[kCnt];
SkPoint fPositions[kCnt];
SkRect fClipRects[kCnt];
diff --git a/gm/verttext2.cpp b/gm/verttext2.cpp
index 12576c2..79cbdbc 100644
--- a/gm/verttext2.cpp
+++ b/gm/verttext2.cpp
@@ -17,23 +17,15 @@
class VertText2GM : public GM {
public:
- VertText2GM()
- : fProp(nullptr)
- , fMono(nullptr) {
- }
-
- virtual ~VertText2GM() {
- SkSafeUnref(fProp);
- SkSafeUnref(fMono);
- }
+ VertText2GM() {}
protected:
void onOnceBeforeDraw() override {
const int pointSize = 24;
textHeight = SkIntToScalar(pointSize);
- fProp = SkTypeface::CreateFromName(sk_tool_utils::platform_font_name("sans-serif"),
+ fProp = SkTypeface::MakeFromName(sk_tool_utils::platform_font_name("sans-serif"),
SkTypeface::kNormal);
- fMono = SkTypeface::CreateFromName(sk_tool_utils::platform_font_name("monospace"),
+ fMono = SkTypeface::MakeFromName(sk_tool_utils::platform_font_name("monospace"),
SkTypeface::kNormal);
}
@@ -74,13 +66,13 @@
}
void drawText(SkCanvas* canvas, const SkString& string,
- SkTypeface* family, SkPaint::Align alignment) {
+ sk_sp<SkTypeface> family, SkPaint::Align alignment) {
SkPaint paint;
paint.setColor(SK_ColorBLACK);
paint.setAntiAlias(true);
paint.setVerticalText(true);
paint.setTextAlign(alignment);
- paint.setTypeface(family);
+ paint.setTypeface(std::move(family));
paint.setTextSize(textHeight);
canvas->drawText(string.c_str(), string.size(), y,
@@ -92,8 +84,8 @@
private:
typedef GM INHERITED;
SkScalar y, textHeight;
- SkTypeface* fProp;
- SkTypeface* fMono;
+ sk_sp<SkTypeface> fProp;
+ sk_sp<SkTypeface> fMono;
};
///////////////////////////////////////////////////////////////////////////////
diff --git a/gyp/skia_for_android_framework_defines.gypi b/gyp/skia_for_android_framework_defines.gypi
index 5512333..619e42e 100644
--- a/gyp/skia_for_android_framework_defines.gypi
+++ b/gyp/skia_for_android_framework_defines.gypi
@@ -28,6 +28,7 @@
'SK_SUPPORT_LEGACY_MASKFILTER_PTR',
'SK_SUPPORT_LEGACY_IMAGEFACTORY',
'SK_SUPPORT_LEGACY_XFERMODE_PTR',
+ 'SK_SUPPORT_LEGACY_TYPEFACE_PTR',
],
},
}
diff --git a/include/core/SkFont.h b/include/core/SkFont.h
index e4ebebb..6c231c9 100644
--- a/include/core/SkFont.h
+++ b/include/core/SkFont.h
@@ -117,17 +117,17 @@
kLCD_MaskType,
};
- static SkFont* Create(SkTypeface*, SkScalar size, MaskType, uint32_t flags);
- static SkFont* Create(SkTypeface*, SkScalar size, SkScalar scaleX, SkScalar skewX,
- MaskType, uint32_t flags);
+ static sk_sp<SkFont> Make(sk_sp<SkTypeface>, SkScalar size, MaskType, uint32_t flags);
+ static sk_sp<SkFont> Make(sk_sp<SkTypeface>, SkScalar size, SkScalar scaleX, SkScalar skewX,
+ MaskType, uint32_t flags);
/**
* Return a font with the same attributes of this font, but with the specified size.
* If size is not supported (e.g. <= 0 or non-finite) NULL will be returned.
*/
- SkFont* cloneWithSize(SkScalar size) const;
+ sk_sp<SkFont> makeWithSize(SkScalar size) const;
- SkTypeface* getTypeface() const { return fTypeface; }
+ SkTypeface* getTypeface() const { return fTypeface.get(); }
SkScalar getSize() const { return fSize; }
SkScalar getScaleX() const { return fScaleX; }
SkScalar getSkewX() const { return fSkewX; }
@@ -145,17 +145,17 @@
SkScalar measureText(const void* text, size_t byteLength, SkTextEncoding) const;
- static SkFont* Testing_CreateFromPaint(const SkPaint&);
+ static sk_sp<SkFont> Testing_CreateFromPaint(const SkPaint&);
private:
enum {
kAllFlags = 0xFF,
};
- SkFont(SkTypeface*, SkScalar size, SkScalar scaleX, SkScalar skewX, MaskType, uint32_t flags);
- virtual ~SkFont();
+ SkFont(sk_sp<SkTypeface>, SkScalar size, SkScalar scaleX, SkScalar skewX, MaskType,
+ uint32_t flags);
- SkTypeface* fTypeface;
+ sk_sp<SkTypeface> fTypeface;
SkScalar fSize;
SkScalar fScaleX;
SkScalar fSkewX;
diff --git a/include/core/SkPaint.h b/include/core/SkPaint.h
index 7367fc6..293ffed 100644
--- a/include/core/SkPaint.h
+++ b/include/core/SkPaint.h
@@ -614,8 +614,10 @@
paint
@return typeface
*/
- SkTypeface* setTypeface(SkTypeface* typeface);
void setTypeface(sk_sp<SkTypeface>);
+#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
+ SkTypeface* setTypeface(SkTypeface* typeface);
+#endif
/** Get the paint's rasterizer (or NULL).
<p />
diff --git a/include/core/SkTypeface.h b/include/core/SkTypeface.h
index f22d2bd..3a47bd2 100644
--- a/include/core/SkTypeface.h
+++ b/include/core/SkTypeface.h
@@ -92,51 +92,75 @@
*/
static bool Equal(const SkTypeface* facea, const SkTypeface* faceb);
- /**
- * Returns a ref() to the default typeface. The caller must call unref()
- * when they are done referencing the object. Never returns NULL.
- */
- static SkTypeface* RefDefault(Style style = SkTypeface::kNormal);
+ /** Returns the default typeface, which is never nullptr. */
+ static sk_sp<SkTypeface> MakeDefault(Style style = SkTypeface::kNormal);
+#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
+ static SkTypeface* RefDefault(Style style = SkTypeface::kNormal) {
+ return MakeDefault(style).release();
+ }
+#endif
- /** Return a new reference to the typeface that most closely matches the
- requested familyName and style. Pass null as the familyName to return
- the default font for the requested style. Will never return null
+ /** Return the typeface that most closely matches the requested familyName and style.
+ Pass nullptr as the familyName to request the default font for the requested style.
+ Will never return nullptr.
@param familyName May be NULL. The name of the font family.
@param style The style (normal, bold, italic) of the typeface.
- @return reference to the closest-matching typeface. Call must call
- unref() when they are done.
+ @return the closest-matching typeface.
*/
- static SkTypeface* CreateFromName(const char familyName[], Style style);
+ static sk_sp<SkTypeface> MakeFromName(const char familyName[], Style style);
+#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
+ static SkTypeface* CreateFromName(const char familyName[], Style style) {
+ return MakeFromName(familyName, style).release();
+ }
+#endif
- /** Return a new reference to the typeface that most closely matches the
- requested typeface and specified Style. Use this call if you want to
- pick a new style from the same family of the existing typeface.
- If family is NULL, this selects from the default font's family.
+ /** Return the typeface that most closely matches the requested typeface and style.
+ Use this to pick a new style from the same family of the existing typeface.
+ If family is nullptr, this selects from the default font's family.
@param family May be NULL. The name of the existing type face.
@param s The style (normal, bold, italic) of the type face.
- @return reference to the closest-matching typeface. Call must call
- unref() when they are done.
+ @return the closest-matching typeface.
*/
- static SkTypeface* CreateFromTypeface(const SkTypeface* family, Style s);
+ static sk_sp<SkTypeface> MakeFromTypeface(SkTypeface* family, Style);
+#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
+ static SkTypeface* CreateFromTypeface(const SkTypeface* family, Style style) {
+ return MakeFromTypeface(const_cast<SkTypeface*>(family), style).release();
+ }
+#endif
/** Return a new typeface given a file. If the file does not exist, or is
- not a valid font file, returns null.
+ not a valid font file, returns nullptr.
*/
- static SkTypeface* CreateFromFile(const char path[], int index = 0);
+ static sk_sp<SkTypeface> MakeFromFile(const char path[], int index = 0);
+#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
+ static SkTypeface* CreateFromFile(const char path[], int index = 0) {
+ return MakeFromFile(path, index).release();
+ }
+#endif
/** Return a new typeface given a stream. If the stream is
- not a valid font file, returns null. Ownership of the stream is
+ not a valid font file, returns nullptr. Ownership of the stream is
transferred, so the caller must not reference it again.
*/
- static SkTypeface* CreateFromStream(SkStreamAsset* stream, int index = 0);
+ static sk_sp<SkTypeface> MakeFromStream(SkStreamAsset* stream, int index = 0);
+#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
+ static SkTypeface* CreateFromStream(SkStreamAsset* stream, int index = 0) {
+ return MakeFromStream(stream, index).release();
+ }
+#endif
/** Return a new typeface given font data and configuration. If the data
- is not valid font data, returns null. Ownership of the font data is
+ is not valid font data, returns nullptr. Ownership of the font data is
transferred, so the caller must not reference it again.
*/
- static SkTypeface* CreateFromFontData(SkFontData*);
+ static sk_sp<SkTypeface> MakeFromFontData(SkFontData*);
+#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
+ static SkTypeface* CreateFromFontData(SkFontData* fd) {
+ return MakeFromFontData(fd).release();
+ }
+#endif
/** Write a unique signature to a stream, sufficient to reconstruct a
typeface referencing the same font when Deserialize is called.
@@ -144,12 +168,16 @@
void serialize(SkWStream*) const;
/** Given the data previously written by serialize(), return a new instance
- to a typeface referring to the same font. If that font is not available,
- return null. If an instance is returned, the caller is responsible for
- calling unref() when they are done with it.
+ of a typeface referring to the same font. If that font is not available,
+ return nullptr.
Does not affect ownership of SkStream.
*/
- static SkTypeface* Deserialize(SkStream*);
+ static sk_sp<SkTypeface> MakeDeserialize(SkStream*);
+#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
+ static SkTypeface* Deserialize(SkStream* stream) {
+ return MakeDeserialize(stream).release();
+ }
+#endif
enum Encoding {
kUTF8_Encoding,
@@ -395,9 +423,6 @@
uint32_t glyphIDsCount = 0) const;
private:
- static SkTypeface* CreateDefault(int style); // SkLazyPtr requires an int, not a Style.
- static void DeleteDefault(SkTypeface*);
-
SkFontID fUniqueID;
SkFontStyle fStyle;
mutable SkRect fBounds;
diff --git a/include/ports/SkFontConfigInterface.h b/include/ports/SkFontConfigInterface.h
index 9f98e35..dfa5bd0 100644
--- a/include/ports/SkFontConfigInterface.h
+++ b/include/ports/SkFontConfigInterface.h
@@ -97,12 +97,15 @@
*
* The default implementation simply returns a new typeface built using data obtained from
* openStream(), but derived classes may implement more complex caching schemes.
- *
- * Callers are responsible for unref-ing the result.
*/
- virtual SkTypeface* createTypeface(const FontIdentity& identity) {
- return SkTypeface::CreateFromStream(this->openStream(identity), identity.fTTCIndex);
+ virtual sk_sp<SkTypeface> makeTypeface(const FontIdentity& identity) {
+ return SkTypeface::MakeFromStream(this->openStream(identity), identity.fTTCIndex);
}
+#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
+ virtual SkTypeface* createTypeface(const FontIdentity& identity) {
+ return this->makeTypeface(identity).release();
+ }
+#endif
/**
* Return a singleton instance of a direct subclass that calls into
diff --git a/public.bzl b/public.bzl
index 8eb4d85..4cd2145 100644
--- a/public.bzl
+++ b/public.bzl
@@ -590,6 +590,7 @@
"SK_SUPPORT_LEGACY_MASKFILTER_PTR",
"SK_SUPPORT_LEGACY_IMAGEFACTORY",
"SK_SUPPORT_LEGACY_XFERMODE_PTR",
+ "SK_SUPPORT_LEGACY_TYPEFACE_PTR",
]
################################################################################
diff --git a/samplecode/ClockFaceView.cpp b/samplecode/ClockFaceView.cpp
index 6e2b2b1..7c6158a 100644
--- a/samplecode/ClockFaceView.cpp
+++ b/samplecode/ClockFaceView.cpp
@@ -170,21 +170,17 @@
}
class ClockFaceView : public SkView {
- SkTypeface* fFace;
+ sk_sp<SkTypeface> fFace;
SkScalar fInterp;
SkScalar fDx;
public:
ClockFaceView() {
- fFace = SkTypeface::CreateFromFile("/Users/reed/Downloads/p052024l.pfb");
+ fFace = SkTypeface::MakeFromFile("/Users/reed/Downloads/p052024l.pfb");
fInterp = 0;
fDx = SK_Scalar1/64;
}
- virtual ~ClockFaceView() {
- SkSafeUnref(fFace);
- }
-
protected:
// overrides from SkEventSink
virtual bool onQuery(SkEvent* evt) {
@@ -225,8 +221,7 @@
paint.setAntiAlias(true);
paint.setTextSize(SkIntToScalar(240));
- paint.setTypeface(SkTypeface::CreateFromName("sans-serif",
- SkTypeface::kBold));
+ paint.setTypeface(SkTypeface::MakeFromName("sans-serif", SkTypeface::kBold));
SkString str("9");
diff --git a/samplecode/SampleAll.cpp b/samplecode/SampleAll.cpp
index 357a437..738b34e 100644
--- a/samplecode/SampleAll.cpp
+++ b/samplecode/SampleAll.cpp
@@ -527,8 +527,7 @@
paint.setAntiAlias(true);
paint.setTextSize(SkIntToScalar(48));
- paint.setTypeface(SkTypeface::CreateFromName("sans-serif",
- SkTypeface::kBold));
+ paint.setTypeface(SkTypeface::MakeFromName("sans-serif", SkTypeface::kBold));
SkString str("GOOGLE");
diff --git a/samplecode/SampleAnimatedText.cpp b/samplecode/SampleAnimatedText.cpp
index 89ea692..6bd6d82 100755
--- a/samplecode/SampleAnimatedText.cpp
+++ b/samplecode/SampleAnimatedText.cpp
@@ -73,7 +73,7 @@
void onDrawContent(SkCanvas* canvas) override {
SkPaint paint;
- SkSafeUnref(paint.setTypeface(SkTypeface::CreateFromFile("/skimages/samplefont.ttf")));
+ paint.setTypeface(SkTypeface::MakeFromFile("/skimages/samplefont.ttf"));
paint.setAntiAlias(true);
paint.setFilterQuality(kMedium_SkFilterQuality);
diff --git a/samplecode/SampleApp.cpp b/samplecode/SampleApp.cpp
index 1df96c8..e4362c5 100644
--- a/samplecode/SampleApp.cpp
+++ b/samplecode/SampleApp.cpp
@@ -935,7 +935,7 @@
fMouseX = fMouseY = 0;
fFatBitsScale = 8;
- fTypeface = SkTypeface::CreateFromTypeface(nullptr, SkTypeface::kBold);
+ fTypeface = SkTypeface::MakeFromTypeface(nullptr, SkTypeface::kBold);
fShowZoomer = false;
fZoomLevel = 0;
@@ -1061,7 +1061,6 @@
}
SampleWindow::~SampleWindow() {
- SkSafeUnref(fTypeface);
SkSafeUnref(fDevManager);
}
diff --git a/samplecode/SampleApp.h b/samplecode/SampleApp.h
index ad7a871..7734ac9 100644
--- a/samplecode/SampleApp.h
+++ b/samplecode/SampleApp.h
@@ -204,7 +204,7 @@
int fMouseX, fMouseY;
int fFatBitsScale;
// Used by the text showing position and color values.
- SkTypeface* fTypeface;
+ sk_sp<SkTypeface> fTypeface;
bool fShowZoomer;
SkOSMenu::TriState fLCDState;
diff --git a/samplecode/SampleFilterFuzz.cpp b/samplecode/SampleFilterFuzz.cpp
index 6a4f1f8..8837241 100644
--- a/samplecode/SampleFilterFuzz.cpp
+++ b/samplecode/SampleFilterFuzz.cpp
@@ -515,9 +515,8 @@
if (false) {
// our validating buffer does not support typefaces yet, so skip this for now
- SkAutoTUnref<SkTypeface> typeface(
- SkTypeface::CreateFromName(make_font_name().c_str(), make_typeface_style()));
- paint.setTypeface(typeface);
+ paint.setTypeface(SkTypeface::MakeFromName(make_font_name().c_str(),
+ make_typeface_style()));
}
SkLayerRasterizer::Builder rasterizerBuilder;
diff --git a/samplecode/SampleFontScalerTest.cpp b/samplecode/SampleFontScalerTest.cpp
index ce3b81e..72371ed 100644
--- a/samplecode/SampleFontScalerTest.cpp
+++ b/samplecode/SampleFontScalerTest.cpp
@@ -36,23 +36,16 @@
static const int gFaceCount = SK_ARRAY_COUNT(gFaces);
class FontScalerTestView : public SampleView {
- SkTypeface* fFaces[gFaceCount];
+ sk_sp<SkTypeface> fFaces[gFaceCount];
public:
FontScalerTestView() {
for (int i = 0; i < gFaceCount; i++) {
- fFaces[i] = SkTypeface::CreateFromName(gFaces[i].fName,
- gFaces[i].fStyle);
+ fFaces[i] = SkTypeface::MakeFromName(gFaces[i].fName, gFaces[i].fStyle);
}
// this->setBGColor(0xFFDDDDDD);
}
- virtual ~FontScalerTestView() {
- for (int i = 0; i < gFaceCount; i++) {
- SkSafeUnref(fFaces[i]);
- }
- }
-
protected:
// overrides from SkEventSink
virtual bool onQuery(SkEvent* evt) {
@@ -92,7 +85,7 @@
// paint.setSubpixelText(true);
paint.setAntiAlias(true);
paint.setLCDRenderText(true);
- SkSafeUnref(paint.setTypeface(SkTypeface::CreateFromName("Times Roman", SkTypeface::kNormal)));
+ paint.setTypeface(SkTypeface::MakeFromName("Times Roman", SkTypeface::kNormal));
// const char* text = "abcdefghijklmnopqrstuvwxyz";
const char* text = "Hamburgefons ooo mmm";
diff --git a/samplecode/SampleSlides.cpp b/samplecode/SampleSlides.cpp
index 9f57907..edc2dd7 100644
--- a/samplecode/SampleSlides.cpp
+++ b/samplecode/SampleSlides.cpp
@@ -625,7 +625,7 @@
SkScalar x = 20;
SkScalar y = 80;
SkPaint paint;
- paint.setTypeface(SkTypeface::CreateFromName("Georgia", SkTypeface::kItalic));
+ paint.setTypeface(SkTypeface::MakeFromName("Georgia", SkTypeface::kItalic));
paint.setTextSize(75);
paint.setAntiAlias(true);
paint.setColor(SK_ColorBLUE);
diff --git a/samplecode/SampleText.cpp b/samplecode/SampleText.cpp
index 6dca100..ca09cc7 100644
--- a/samplecode/SampleText.cpp
+++ b/samplecode/SampleText.cpp
@@ -122,7 +122,7 @@
// canvas->drawText(style, strlen(style), SkIntToScalar(20), SkIntToScalar(20), paint);
- SkSafeUnref(paint.setTypeface(SkTypeface::CreateFromFile("/skimages/samplefont.ttf")));
+ paint.setTypeface(SkTypeface::MakeFromFile("/skimages/samplefont.ttf"));
paint.setAntiAlias(true);
paint.setFlags(paint.getFlags() | gHints[index].fFlags);
diff --git a/samplecode/SampleXfermodesBlur.cpp b/samplecode/SampleXfermodesBlur.cpp
index af75f89..8a69f00 100644
--- a/samplecode/SampleXfermodesBlur.cpp
+++ b/samplecode/SampleXfermodesBlur.cpp
@@ -28,9 +28,7 @@
#include "SkBlurMaskFilter.h"
static void setNamedTypeface(SkPaint* paint, const char name[]) {
- SkTypeface* face = SkTypeface::CreateFromName(name, SkTypeface::kNormal);
- paint->setTypeface(face);
- SkSafeUnref(face);
+ paint->setTypeface(SkTypeface::MakeFromName(name, SkTypeface::kNormal));
}
static uint16_t gBG[] = { 0xFFFF, 0xCCCF, 0xCCCF, 0xFFFF };
@@ -92,8 +90,7 @@
SkPaint paint;
paint.setAntiAlias(true);
paint.setTextSize(50);
- paint.setTypeface(SkTypeface::CreateFromName("Arial Unicode MS", SkTypeface::kNormal));
- SkSafeUnref(paint.getTypeface());
+ paint.setTypeface(SkTypeface::MakeFromName("Arial Unicode MS", SkTypeface::kNormal));
char buffer[10];
size_t len = SkUTF8_FromUnichar(0x8500, buffer);
canvas->drawText(buffer, len, 40, 40, paint);
diff --git a/src/animator/SkDrawPaint.cpp b/src/animator/SkDrawPaint.cpp
index 1336ea2..1026630 100644
--- a/src/animator/SkDrawPaint.cpp
+++ b/src/animator/SkDrawPaint.cpp
@@ -259,7 +259,7 @@
if (typeface == nullptr)
paint->setTypeface(nullptr);
else if (typeface != (SkDrawTypeface*) -1)
- SkSafeUnref(paint->setTypeface(typeface->getTypeface()));
+ paint->setTypeface(typeface->getTypeface());
if (underline != -1)
paint->setUnderlineText(SkToBool(underline));
if (xfermode != -1)
diff --git a/src/animator/SkPaintPart.h b/src/animator/SkPaintPart.h
index a7e28ed..5d94f04 100644
--- a/src/animator/SkPaintPart.h
+++ b/src/animator/SkPaintPart.h
@@ -62,8 +62,7 @@
#ifdef SK_DUMP_ENABLED
void dump(SkAnimateMaker *) override;
#endif
- SkTypeface* getTypeface() {
- return SkTypeface::CreateFromName(fontName.c_str(), style); }
+ sk_sp<SkTypeface> getTypeface() { return SkTypeface::MakeFromName(fontName.c_str(), style); }
protected:
bool add() override;
SkString fontName;
diff --git a/src/core/SkFont.cpp b/src/core/SkFont.cpp
index c39cc18..1300011 100644
--- a/src/core/SkFont.cpp
+++ b/src/core/SkFont.cpp
@@ -9,13 +9,9 @@
#include "SkTypeface.h"
#include "SkUtils.h"
-static SkTypeface* ref_or_default(SkTypeface* face) {
- return face ? SkRef(face) : SkTypeface::RefDefault();
-}
-
-SkFont::SkFont(SkTypeface* face, SkScalar size, SkScalar scaleX, SkScalar skewX, MaskType mt,
+SkFont::SkFont(sk_sp<SkTypeface> face, SkScalar size, SkScalar scaleX, SkScalar skewX, MaskType mt,
uint32_t flags)
- : fTypeface(ref_or_default(face))
+ : fTypeface(face ? std::move(face) : SkTypeface::MakeDefault())
, fSize(size)
, fScaleX(scaleX)
, fSkewX(skewX)
@@ -28,8 +24,8 @@
SkASSERT(0 == (flags & ~kAllFlags));
}
-SkFont* SkFont::Create(SkTypeface* face, SkScalar size, SkScalar scaleX, SkScalar skewX,
- MaskType mt, uint32_t flags) {
+sk_sp<SkFont> SkFont::Make(sk_sp<SkTypeface> face, SkScalar size, SkScalar scaleX, SkScalar skewX,
+ MaskType mt, uint32_t flags) {
if (size <= 0 || !SkScalarIsFinite(size)) {
return nullptr;
}
@@ -40,24 +36,20 @@
return nullptr;
}
flags &= kAllFlags;
- return new SkFont(face, size, scaleX, skewX, mt, flags);
+ return sk_sp<SkFont>(new SkFont(std::move(face), size, scaleX, skewX, mt, flags));
}
-SkFont* SkFont::Create(SkTypeface* face, SkScalar size, MaskType mt, uint32_t flags) {
- return SkFont::Create(face, size, 1, 0, mt, flags);
+sk_sp<SkFont> SkFont::Make(sk_sp<SkTypeface> face, SkScalar size, MaskType mt, uint32_t flags) {
+ return SkFont::Make(std::move(face), size, 1, 0, mt, flags);
}
-SkFont* SkFont::cloneWithSize(SkScalar newSize) const {
- return SkFont::Create(this->getTypeface(), newSize, this->getScaleX(), this->getSkewX(),
- this->getMaskType(), this->getFlags());
+sk_sp<SkFont> SkFont::makeWithSize(SkScalar newSize) const {
+ return SkFont::Make(sk_ref_sp(this->getTypeface()), newSize, this->getScaleX(),
+ this->getSkewX(), this->getMaskType(), this->getFlags());
}
///////////////////////////////////////////////////////////////////////////////////////////////////
-SkFont::~SkFont() {
- SkSafeUnref(fTypeface);
-}
-
int SkFont::textToGlyphs(const void* text, size_t byteLength, SkTextEncoding encoding,
uint16_t glyphs[], int maxGlyphCount) const {
if (0 == byteLength) {
@@ -118,7 +110,7 @@
#include "SkPaint.h"
-SkFont* SkFont::Testing_CreateFromPaint(const SkPaint& paint) {
+sk_sp<SkFont> SkFont::Testing_CreateFromPaint(const SkPaint& paint) {
uint32_t flags = 0;
if (paint.isVerticalText()) {
flags |= kVertical_Flag;
@@ -150,7 +142,6 @@
maskType = paint.isLCDRenderText() ? kLCD_MaskType : kA8_MaskType;
}
- return Create(paint.getTypeface(),
- paint.getTextSize(), paint.getTextScaleX(), paint.getTextSkewX(),
- maskType, flags);
+ return Make(sk_ref_sp(paint.getTypeface()), paint.getTextSize(), paint.getTextScaleX(),
+ paint.getTextSkewX(), maskType, flags);
}
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index 67bbda1..25b6aec 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -369,7 +369,9 @@
this->f##Field.reset(SkSafeRef(f)); \
return f; \
}
+#ifdef SK_SUPPORT_LEGACY_TYPEFACE_PTR
SET_PTR(Typeface)
+#endif
#ifdef SK_SUPPORT_LEGACY_MINOR_EFFECT_PTR
SET_PTR(Rasterizer)
#endif
@@ -1896,7 +1898,7 @@
this->setTextEncoding(static_cast<TextEncoding>((tmp >> 0) & 0xFF));
if (flatFlags & kHasTypeface_FlatFlag) {
- this->setTypeface(buffer.readTypeface());
+ this->setTypeface(sk_ref_sp(buffer.readTypeface()));
} else {
this->setTypeface(nullptr);
}
diff --git a/src/core/SkPictureData.cpp b/src/core/SkPictureData.cpp
index ed32c6c..873c0c4 100644
--- a/src/core/SkPictureData.cpp
+++ b/src/core/SkPictureData.cpp
@@ -405,13 +405,13 @@
const int count = SkToInt(size);
fTFPlayback.setCount(count);
for (int i = 0; i < count; i++) {
- SkAutoTUnref<SkTypeface> tf(SkTypeface::Deserialize(stream));
+ sk_sp<SkTypeface> tf(SkTypeface::MakeDeserialize(stream));
if (!tf.get()) { // failed to deserialize
// fTFPlayback asserts it never has a null, so we plop in
// the default here.
- tf.reset(SkTypeface::RefDefault());
+ tf = SkTypeface::MakeDefault();
}
- fTFPlayback.set(i, tf);
+ fTFPlayback.set(i, tf.get());
}
} break;
case SK_PICT_PICTURE_TAG: {
diff --git a/src/core/SkTextBlob.cpp b/src/core/SkTextBlob.cpp
index 463312a..1cbb2b6 100644
--- a/src/core/SkTextBlob.cpp
+++ b/src/core/SkTextBlob.cpp
@@ -27,7 +27,7 @@
void applyToPaint(SkPaint* paint) const {
paint->setTextEncoding(SkPaint::kGlyphID_TextEncoding);
- paint->setTypeface(fTypeface.get());
+ paint->setTypeface(fTypeface);
paint->setTextSize(fSize);
paint->setTextScaleX(fScaleX);
paint->setTextSkewX(fSkewX);
@@ -73,7 +73,7 @@
// Keep this SkAutoTUnref off the first position, to avoid interfering with SkNoncopyable
// empty baseclass optimization (http://code.google.com/p/skia/issues/detail?id=3694).
- SkAutoTUnref<SkTypeface> fTypeface;
+ sk_sp<SkTypeface> fTypeface;
SkScalar fSkewX;
static_assert(SkPaint::kAlignCount < 4, "insufficient_align_bits");
diff --git a/src/core/SkTypeface.cpp b/src/core/SkTypeface.cpp
index 75bb05c..3c15878 100644
--- a/src/core/SkTypeface.cpp
+++ b/src/core/SkTypeface.cpp
@@ -27,9 +27,9 @@
#define SK_TYPEFACE_DELEGATE nullptr
#endif
-SkTypeface* (*gCreateTypefaceDelegate)(const char [], SkTypeface::Style ) = nullptr;
+sk_sp<SkTypeface> (*gCreateTypefaceDelegate)(const char [], SkTypeface::Style ) = nullptr;
void (*gSerializeTypefaceDelegate)(const SkTypeface*, SkWStream* ) = SK_TYPEFACE_DELEGATE;
-SkTypeface* (*gDeserializeTypefaceDelegate)(SkStream* ) = nullptr;
+sk_sp<SkTypeface> (*gDeserializeTypefaceDelegate)(SkStream* ) = nullptr;
///////////////////////////////////////////////////////////////////////////////
@@ -98,8 +98,8 @@
return defaults[style];
}
-SkTypeface* SkTypeface::RefDefault(Style style) {
- return SkRef(GetDefaultTypeface(style));
+sk_sp<SkTypeface> SkTypeface::MakeDefault(Style style) {
+ return sk_ref_sp(GetDefaultTypeface(style));
}
uint32_t SkTypeface::UniqueID(const SkTypeface* face) {
@@ -115,47 +115,46 @@
///////////////////////////////////////////////////////////////////////////////
-SkTypeface* SkTypeface::CreateFromName(const char name[], Style style) {
+sk_sp<SkTypeface> SkTypeface::MakeFromName(const char name[], Style style) {
if (gCreateTypefaceDelegate) {
- SkTypeface* result = (*gCreateTypefaceDelegate)(name, style);
+ sk_sp<SkTypeface> result = (*gCreateTypefaceDelegate)(name, style);
if (result) {
return result;
}
}
if (nullptr == name) {
- return RefDefault(style);
+ return MakeDefault(style);
}
SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
- return fm->legacyCreateTypeface(name, SkFontStyle::FromOldStyle(style));
+ return sk_sp<SkTypeface>(fm->legacyCreateTypeface(name, SkFontStyle::FromOldStyle(style)));
}
-SkTypeface* SkTypeface::CreateFromTypeface(const SkTypeface* family, Style s) {
+sk_sp<SkTypeface> SkTypeface::MakeFromTypeface(SkTypeface* family, Style s) {
if (!family) {
- return SkTypeface::RefDefault(s);
+ return SkTypeface::MakeDefault(s);
}
if (family->style() == s) {
- family->ref();
- return const_cast<SkTypeface*>(family);
+ return sk_ref_sp(family);
}
SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
- return fm->matchFaceStyle(family, SkFontStyle::FromOldStyle(s));
+ return sk_sp<SkTypeface>(fm->matchFaceStyle(family, SkFontStyle::FromOldStyle(s)));
}
-SkTypeface* SkTypeface::CreateFromStream(SkStreamAsset* stream, int index) {
+sk_sp<SkTypeface> SkTypeface::MakeFromStream(SkStreamAsset* stream, int index) {
SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
- return fm->createFromStream(stream, index);
+ return sk_sp<SkTypeface>(fm->createFromStream(stream, index));
}
-SkTypeface* SkTypeface::CreateFromFontData(SkFontData* data) {
+sk_sp<SkTypeface> SkTypeface::MakeFromFontData(SkFontData* data) {
SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
- return fm->createFromFontData(data);
+ return sk_sp<SkTypeface>(fm->createFromFontData(data));
}
-SkTypeface* SkTypeface::CreateFromFile(const char path[], int index) {
+sk_sp<SkTypeface> SkTypeface::MakeFromFile(const char path[], int index) {
SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
- return fm->createFromFile(path, index);
+ return sk_sp<SkTypeface>(fm->createFromFile(path, index));
}
///////////////////////////////////////////////////////////////////////////////
@@ -176,7 +175,7 @@
desc.serialize(wstream);
}
-SkTypeface* SkTypeface::Deserialize(SkStream* stream) {
+sk_sp<SkTypeface> SkTypeface::MakeDeserialize(SkStream* stream) {
if (gDeserializeTypefaceDelegate) {
return (*gDeserializeTypefaceDelegate)(stream);
}
@@ -188,12 +187,12 @@
SkFontData* data = desc.detachFontData();
if (data) {
- SkTypeface* typeface = SkTypeface::CreateFromFontData(data);
+ sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFontData(data));
if (typeface) {
return typeface;
}
}
- return SkTypeface::CreateFromName(desc.getFamilyName(), desc.getStyle());
+ return SkTypeface::MakeFromName(desc.getFamilyName(), desc.getStyle());
}
///////////////////////////////////////////////////////////////////////////////
@@ -335,7 +334,7 @@
const SkScalar invTextSize = 1 / textSize;
SkPaint paint;
- paint.setTypeface(const_cast<SkTypeface*>(this));
+ paint.setTypeface(sk_ref_sp(const_cast<SkTypeface*>(this)));
paint.setTextSize(textSize);
paint.setLinearText(true);
diff --git a/src/core/SkTypefacePriv.h b/src/core/SkTypefacePriv.h
index dc993d0..f8d7e63 100644
--- a/src/core/SkTypefacePriv.h
+++ b/src/core/SkTypefacePriv.h
@@ -16,23 +16,23 @@
* If the parameter is non-null, it will be ref'd and returned, otherwise
* it will be the default typeface.
*/
-static inline SkTypeface* ref_or_default(SkTypeface* face) {
- return face ? SkRef(face) : SkTypeface::RefDefault();
+static inline sk_sp<SkTypeface> ref_or_default(SkTypeface* face) {
+ return face ? sk_ref_sp(face) : SkTypeface::MakeDefault();
}
/**
* Always resolves to a non-null typeface, either the value passed to its
* constructor, or the default typeface if null was passed.
*/
-class SkAutoResolveDefaultTypeface : public SkAutoTUnref<SkTypeface> {
+class SkAutoResolveDefaultTypeface : public sk_sp<SkTypeface> {
public:
- SkAutoResolveDefaultTypeface() : INHERITED(SkTypeface::RefDefault()) {}
+ SkAutoResolveDefaultTypeface() : INHERITED(SkTypeface::MakeDefault()) {}
SkAutoResolveDefaultTypeface(SkTypeface* face)
: INHERITED(ref_or_default(face)) {}
private:
- typedef SkAutoTUnref<SkTypeface> INHERITED;
+ typedef sk_sp<SkTypeface> INHERITED;
};
#endif
diff --git a/src/fonts/SkGScalerContext.cpp b/src/fonts/SkGScalerContext.cpp
index 0a9601b..1d34536 100644
--- a/src/fonts/SkGScalerContext.cpp
+++ b/src/fonts/SkGScalerContext.cpp
@@ -151,14 +151,11 @@
#include "SkTypefaceCache.h"
-SkGTypeface::SkGTypeface(SkTypeface* proxy, const SkPaint& paint)
+SkGTypeface::SkGTypeface(sk_sp<SkTypeface> proxy, const SkPaint& paint)
: SkTypeface(proxy->fontStyle(), SkTypefaceCache::NewFontID(), false)
- , fProxy(SkRef(proxy))
- , fPaint(paint) {}
-
-SkGTypeface::~SkGTypeface() {
- fProxy->unref();
-}
+ , fProxy(std::move(proxy))
+ , fPaint(paint)
+{}
SkScalerContext* SkGTypeface::onCreateScalerContext(const SkScalerContextEffects& effects,
const SkDescriptor* desc) const {
diff --git a/src/fonts/SkGScalerContext.h b/src/fonts/SkGScalerContext.h
index 69d02dd..3eb25a8 100644
--- a/src/fonts/SkGScalerContext.h
+++ b/src/fonts/SkGScalerContext.h
@@ -13,10 +13,9 @@
class SkGTypeface : public SkTypeface {
public:
- SkGTypeface(SkTypeface* proxy, const SkPaint&);
- virtual ~SkGTypeface();
+ SkGTypeface(sk_sp<SkTypeface> proxy, const SkPaint&);
- SkTypeface* proxy() const { return fProxy; }
+ SkTypeface* proxy() const { return fProxy.get(); }
const SkPaint& paint() const { return fPaint; }
protected:
@@ -43,8 +42,8 @@
size_t length, void* data) const override;
private:
- SkTypeface* fProxy;
- SkPaint fPaint;
+ sk_sp<SkTypeface> fProxy;
+ SkPaint fPaint;
};
#endif
diff --git a/src/fonts/SkRandomScalerContext.cpp b/src/fonts/SkRandomScalerContext.cpp
index 2450520..6d3718c 100644
--- a/src/fonts/SkRandomScalerContext.cpp
+++ b/src/fonts/SkRandomScalerContext.cpp
@@ -190,16 +190,12 @@
#include "SkTypefaceCache.h"
-SkRandomTypeface::SkRandomTypeface(SkTypeface* proxy, const SkPaint& paint, bool fakeIt)
+SkRandomTypeface::SkRandomTypeface(sk_sp<SkTypeface> proxy, const SkPaint& paint, bool fakeIt)
: SkTypeface(proxy->fontStyle(), SkTypefaceCache::NewFontID(), false)
- , fProxy(SkRef(proxy))
+ , fProxy(std::move(proxy))
, fPaint(paint)
, fFakeIt(fakeIt) {}
-SkRandomTypeface::~SkRandomTypeface() {
- fProxy->unref();
-}
-
SkScalerContext* SkRandomTypeface::onCreateScalerContext(const SkScalerContextEffects& effects,
const SkDescriptor* desc) const {
return new SkRandomScalerContext(const_cast<SkRandomTypeface*>(this), effects, desc, fFakeIt);
diff --git a/src/fonts/SkRandomScalerContext.h b/src/fonts/SkRandomScalerContext.h
index 0e08f4b..076689d 100644
--- a/src/fonts/SkRandomScalerContext.h
+++ b/src/fonts/SkRandomScalerContext.h
@@ -18,10 +18,9 @@
class SkRandomTypeface : public SkTypeface {
public:
- SkRandomTypeface(SkTypeface* proxy, const SkPaint&, bool fakeit);
- virtual ~SkRandomTypeface();
+ SkRandomTypeface(sk_sp<SkTypeface> proxy, const SkPaint&, bool fakeit);
- SkTypeface* proxy() const { return fProxy; }
+ SkTypeface* proxy() const { return fProxy.get(); }
const SkPaint& paint() const { return fPaint; }
protected:
@@ -48,9 +47,9 @@
size_t length, void* data) const override;
private:
- SkTypeface* fProxy;
- SkPaint fPaint;
- bool fFakeIt;
+ sk_sp<SkTypeface> fProxy;
+ SkPaint fPaint;
+ bool fFakeIt;
};
#endif
diff --git a/src/pdf/SkPDFFont.cpp b/src/pdf/SkPDFFont.cpp
index 7a66bcd..97be32c 100644
--- a/src/pdf/SkPDFFont.cpp
+++ b/src/pdf/SkPDFFont.cpp
@@ -1327,7 +1327,7 @@
bool SkPDFType3Font::populate(uint16_t glyphID) {
SkPaint paint;
- paint.setTypeface(typeface());
+ paint.setTypeface(sk_ref_sp(this->typeface()));
paint.setTextSize(1000);
const SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
SkAutoGlyphCache autoCache(paint, &props, nullptr);
diff --git a/src/ports/SkFontMgr_android.cpp b/src/ports/SkFontMgr_android.cpp
index 4aea047..2e619af 100644
--- a/src/ports/SkFontMgr_android.cpp
+++ b/src/ports/SkFontMgr_android.cpp
@@ -364,14 +364,14 @@
return nullptr;
}
- static SkTypeface_AndroidSystem* find_family_style_character(
+ static sk_sp<SkTypeface_AndroidSystem> find_family_style_character(
const SkTDArray<NameToFamily>& fallbackNameToFamilyMap,
const SkFontStyle& style, bool elegant,
const SkString& langTag, SkUnichar character)
{
for (int i = 0; i < fallbackNameToFamilyMap.count(); ++i) {
SkFontStyleSet_Android* family = fallbackNameToFamilyMap[i].styleSet;
- SkAutoTUnref<SkTypeface_AndroidSystem> face(family->matchStyle(style));
+ sk_sp<SkTypeface_AndroidSystem> face(family->matchStyle(style));
if (!langTag.isEmpty() && !face->fLang.getTag().startsWith(langTag.c_str())) {
continue;
@@ -388,7 +388,7 @@
uint16_t glyphID;
paint.textToGlyphs(&character, sizeof(character), &glyphID);
if (glyphID != 0) {
- return face.release();
+ return face;
}
}
return nullptr;
@@ -410,23 +410,23 @@
for (int bcp47Index = bcp47Count; bcp47Index --> 0;) {
SkLanguage lang(bcp47[bcp47Index]);
while (!lang.getTag().isEmpty()) {
- SkTypeface_AndroidSystem* matchingTypeface =
+ sk_sp<SkTypeface_AndroidSystem> matchingTypeface =
find_family_style_character(fFallbackNameToFamilyMap,
style, SkToBool(elegant),
lang.getTag(), character);
if (matchingTypeface) {
- return matchingTypeface;
+ return matchingTypeface.release();
}
lang = lang.getParent();
}
}
- SkTypeface_AndroidSystem* matchingTypeface =
+ sk_sp<SkTypeface_AndroidSystem> matchingTypeface =
find_family_style_character(fFallbackNameToFamilyMap,
style, SkToBool(elegant),
SkString(), character);
if (matchingTypeface) {
- return matchingTypeface;
+ return matchingTypeface.release();
}
}
return nullptr;
diff --git a/src/svg/SkSVGDevice.cpp b/src/svg/SkSVGDevice.cpp
index 4c679df..f0805b5 100644
--- a/src/svg/SkSVGDevice.cpp
+++ b/src/svg/SkSVGDevice.cpp
@@ -534,8 +534,8 @@
SkString familyName;
SkTHashSet<SkString> familySet;
- SkAutoTUnref<const SkTypeface> tface(paint.getTypeface() ?
- SkRef(paint.getTypeface()) : SkTypeface::RefDefault());
+ sk_sp<const SkTypeface> tface(paint.getTypeface() ?
+ sk_ref_sp(paint.getTypeface()) : SkTypeface::MakeDefault());
SkASSERT(tface);
SkTypeface::Style style = tface->style();
diff --git a/src/utils/SkLua.cpp b/src/utils/SkLua.cpp
index 886f3d4..4409e47 100644
--- a/src/utils/SkLua.cpp
+++ b/src/utils/SkLua.cpp
@@ -925,7 +925,7 @@
}
static int lpaint_setTypeface(lua_State* L) {
- get_obj<SkPaint>(L, 1)->setTypeface(get_ref<SkTypeface>(L, 2));
+ get_obj<SkPaint>(L, 1)->setTypeface(sk_ref_sp(get_ref<SkTypeface>(L, 2)));
return 0;
}
@@ -2049,13 +2049,12 @@
}
}
- SkTypeface* face = SkTypeface::CreateFromName(name,
- (SkTypeface::Style)style);
+ sk_sp<SkTypeface> face(SkTypeface::MakeFromName(name, (SkTypeface::Style)style));
// SkDebugf("---- name <%s> style=%d, face=%p ref=%d\n", name, style, face, face->getRefCnt());
if (nullptr == face) {
- face = SkTypeface::RefDefault();
+ face = SkTypeface::MakeDefault();
}
- push_ref(L, face)->unref();
+ push_ref(L, std::move(face));
return 1;
}
diff --git a/src/utils/SkWhitelistTypefaces.cpp b/src/utils/SkWhitelistTypefaces.cpp
index 66d3218..3368178 100644
--- a/src/utils/SkWhitelistTypefaces.cpp
+++ b/src/utils/SkWhitelistTypefaces.cpp
@@ -18,7 +18,7 @@
#define WHITELIST_DEBUG 0
extern void WhitelistSerializeTypeface(const SkTypeface*, SkWStream* );
-extern SkTypeface* WhitelistDeserializeTypeface(SkStream* );
+sk_sp<SkTypeface> WhitelistDeserializeTypeface(SkStream* );
extern bool CheckChecksums();
extern bool GenerateChecksums();
@@ -32,8 +32,8 @@
if (!strcmp(fontName, "DejaVu Sans")) {
return true;
}
- SkTypeface* defaultFace = SkTypeface::CreateFromName(nullptr, style);
- SkTypeface* foundFace = SkTypeface::CreateFromName(fontName, style);
+ sk_sp<SkTypeface> defaultFace(SkTypeface::MakeFromName(nullptr, style));
+ sk_sp<SkTypeface> foundFace(SkTypeface::MakeFromName(fontName, style));
return defaultFace != foundFace;
}
@@ -183,7 +183,7 @@
serialize_sub(fontName, tf->style(), wstream);
}
-SkTypeface* WhitelistDeserializeTypeface(SkStream* stream) {
+sk_sp<SkTypeface> WhitelistDeserializeTypeface(SkStream* stream) {
SkFontDescriptor desc;
if (!SkFontDescriptor::Deserialize(stream, &desc)) {
return nullptr;
@@ -191,7 +191,7 @@
SkFontData* data = desc.detachFontData();
if (data) {
- SkTypeface* typeface = SkTypeface::CreateFromFontData(data);
+ sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFontData(data));
if (typeface) {
return typeface;
}
@@ -200,14 +200,14 @@
if (!strncmp(SUBNAME_PREFIX, familyName, sizeof(SUBNAME_PREFIX) - 1)) {
familyName += sizeof(SUBNAME_PREFIX) - 1;
}
- return SkTypeface::CreateFromName(familyName, desc.getStyle());
+ return SkTypeface::MakeFromName(familyName, desc.getStyle());
}
bool CheckChecksums() {
for (int i = 0; i < whitelistCount; ++i) {
const char* fontName = whitelist[i].fFontName;
- SkTypeface* tf = SkTypeface::CreateFromName(fontName, SkTypeface::kNormal);
- uint32_t checksum = compute_checksum(tf);
+ sk_sp<SkTypeface> tf(SkTypeface::MakeFromName(fontName, SkTypeface::kNormal));
+ uint32_t checksum = compute_checksum(tf.get());
if (whitelist[i].fChecksum != checksum) {
return false;
}
@@ -261,8 +261,8 @@
sk_fwrite(line.c_str(), line.size(), file);
for (int i = 0; i < whitelistCount; ++i) {
const char* fontName = whitelist[i].fFontName;
- SkTypeface* tf = SkTypeface::CreateFromName(fontName, SkTypeface::kNormal);
- uint32_t checksum = compute_checksum(tf);
+ sk_sp<SkTypeface> tf(SkTypeface::MakeFromName(fontName, SkTypeface::kNormal));
+ uint32_t checksum = compute_checksum(tf.get());
line.printf(checksumEntry, fontName, checksum);
sk_fwrite(line.c_str(), line.size(), file);
}
diff --git a/tests/FontHostStreamTest.cpp b/tests/FontHostStreamTest.cpp
index 0b43655..ec32d9f 100644
--- a/tests/FontHostStreamTest.cpp
+++ b/tests/FontHostStreamTest.cpp
@@ -69,9 +69,7 @@
paint.setColor(SK_ColorGRAY);
paint.setTextSize(SkIntToScalar(30));
- SkTypeface* fTypeface = SkTypeface::CreateFromName("Georgia",
- SkTypeface::kNormal);
- SkSafeUnref(paint.setTypeface(fTypeface));
+ paint.setTypeface(SkTypeface::MakeFromName("Georgia", SkTypeface::kNormal));
SkIRect origRect = SkIRect::MakeWH(64, 64);
SkBitmap origBitmap;
@@ -89,23 +87,18 @@
drawBG(&origCanvas);
origCanvas.drawText("A", 1, point.fX, point.fY, paint);
- SkTypeface* origTypeface = paint.getTypeface();
- SkAutoTUnref<SkTypeface> aur;
- if (nullptr == origTypeface) {
- aur.reset(SkTypeface::RefDefault());
- origTypeface = aur.get();
- }
-
+ sk_sp<SkTypeface> typeface(SkToBool(paint.getTypeface()) ? sk_ref_sp(paint.getTypeface())
+ : SkTypeface::MakeDefault());
int ttcIndex;
- SkAutoTDelete<SkStreamAsset> fontData(origTypeface->openStream(&ttcIndex));
- SkTypeface* streamTypeface = SkTypeface::CreateFromStream(fontData.release());
+ SkAutoTDelete<SkStreamAsset> fontData(typeface->openStream(&ttcIndex));
+ sk_sp<SkTypeface> streamTypeface(SkTypeface::MakeFromStream(fontData.release()));
SkFontDescriptor desc;
bool isLocalStream = false;
streamTypeface->getFontDescriptor(&desc, &isLocalStream);
REPORTER_ASSERT(reporter, isLocalStream);
- SkSafeUnref(paint.setTypeface(streamTypeface));
+ paint.setTypeface(streamTypeface);
drawBG(&streamCanvas);
streamCanvas.drawPosText("A", 1, &point, paint);
diff --git a/tests/FontHostTest.cpp b/tests/FontHostTest.cpp
index d9a3df4..ebcc4ab 100644
--- a/tests/FontHostTest.cpp
+++ b/tests/FontHostTest.cpp
@@ -31,7 +31,7 @@
// Test that getUnitsPerEm() agrees with a direct lookup in the 'head' table
// (if that table is available).
-static void test_unitsPerEm(skiatest::Reporter* reporter, SkTypeface* face) {
+static void test_unitsPerEm(skiatest::Reporter* reporter, const sk_sp<SkTypeface>& face) {
int nativeUPEM = face->getUnitsPerEm();
int tableUPEM = -1;
@@ -50,7 +50,7 @@
// Test that countGlyphs() agrees with a direct lookup in the 'maxp' table
// (if that table is available).
-static void test_countGlyphs(skiatest::Reporter* reporter, SkTypeface* face) {
+static void test_countGlyphs(skiatest::Reporter* reporter, const sk_sp<SkTypeface>& face) {
int nativeGlyphs = face->countGlyphs();
int tableGlyphs = -1;
@@ -86,7 +86,7 @@
};
// Test that SkPaint::textToGlyphs agrees with SkTypeface::charsToGlyphs.
-static void test_charsToGlyphs(skiatest::Reporter* reporter, SkTypeface* face) {
+static void test_charsToGlyphs(skiatest::Reporter* reporter, const sk_sp<SkTypeface>& face) {
uint16_t paintGlyphIds[256];
uint16_t faceGlyphIds[256];
@@ -154,22 +154,22 @@
}
static void test_symbolfont(skiatest::Reporter* reporter) {
- SkAutoTUnref<SkTypeface> typeface(GetResourceAsTypeface("/fonts/SpiderSymbol.ttf"));
- if (!typeface) {
+ SkUnichar c = 0xf021;
+ uint16_t g;
+ SkPaint paint;
+ paint.setTypeface(MakeResourceAsTypeface("/fonts/SpiderSymbol.ttf"));
+ paint.setTextEncoding(SkPaint::kUTF32_TextEncoding);
+ paint.textToGlyphs(&c, 4, &g);
+
+ if (!paint.getTypeface()) {
SkDebugf("Skipping FontHostTest::test_symbolfont\n");
return;
}
- SkUnichar c = 0xf021;
- uint16_t g;
- SkPaint paint;
- paint.setTypeface(typeface);
- paint.setTextEncoding(SkPaint::kUTF32_TextEncoding);
- paint.textToGlyphs(&c, 4, &g);
REPORTER_ASSERT(reporter, g == 3);
}
-static void test_tables(skiatest::Reporter* reporter, SkTypeface* face) {
+static void test_tables(skiatest::Reporter* reporter, const sk_sp<SkTypeface>& face) {
if (false) { // avoid bit rot, suppress warning
SkFontID fontID = face->uniqueID();
REPORTER_ASSERT(reporter, fontID);
@@ -223,7 +223,7 @@
};
for (size_t i = 0; i < SK_ARRAY_COUNT(gNames); ++i) {
- SkAutoTUnref<SkTypeface> face(SkTypeface::CreateFromName(gNames[i], SkTypeface::kNormal));
+ sk_sp<SkTypeface> face(SkTypeface::MakeFromName(gNames[i], SkTypeface::kNormal));
if (face) {
#ifdef DUMP_TABLES
SkDebugf("%s\n", gNames[i]);
@@ -277,8 +277,7 @@
char txt[] = "long.text.with.lots.of.dots.";
for (size_t i = 0; i < SK_ARRAY_COUNT(faces); i++) {
- SkAutoTUnref<SkTypeface> face(SkTypeface::CreateFromName(faces[i], SkTypeface::kNormal));
- paint.setTypeface(face);
+ paint.setTypeface(SkTypeface::MakeFromName(faces[i], SkTypeface::kNormal));
for (size_t j = 0; j < SK_ARRAY_COUNT(settings); j++) {
paint.setHinting(settings[j].hinting);
diff --git a/tests/FontMgrTest.cpp b/tests/FontMgrTest.cpp
index 92dc18b..414631c 100644
--- a/tests/FontMgrTest.cpp
+++ b/tests/FontMgrTest.cpp
@@ -19,7 +19,7 @@
static void test_font(skiatest::Reporter* reporter) {
uint32_t flags = 0;
- SkAutoTUnref<SkFont> font(SkFont::Create(nullptr, 24, SkFont::kA8_MaskType, flags));
+ sk_sp<SkFont> font(SkFont::Make(nullptr, 24, SkFont::kA8_MaskType, flags));
REPORTER_ASSERT(reporter, font->getTypeface());
REPORTER_ASSERT(reporter, 24 == font->getSize());
@@ -39,7 +39,7 @@
REPORTER_ASSERT(reporter, glyphs[0] != glyphs[1]); // 'h' != 'e'
REPORTER_ASSERT(reporter, glyphs[2] == glyphs[3]); // 'l' == 'l'
- SkAutoTUnref<SkFont> newFont(font->cloneWithSize(36));
+ sk_sp<SkFont> newFont(font->makeWithSize(36));
REPORTER_ASSERT(reporter, newFont.get());
REPORTER_ASSERT(reporter, font->getTypeface() == newFont->getTypeface());
REPORTER_ASSERT(reporter, 36 == newFont->getSize()); // double check we haven't changed
@@ -47,7 +47,7 @@
SkPaint paint;
paint.setTextSize(18);
- font.reset(SkFont::Testing_CreateFromPaint(paint));
+ font = SkFont::Testing_CreateFromPaint(paint);
REPORTER_ASSERT(reporter, font.get());
REPORTER_ASSERT(reporter, font->getSize() == paint.getTextSize());
REPORTER_ASSERT(reporter, SkFont::kBW_MaskType == font->getMaskType());
@@ -64,14 +64,12 @@
};
for (size_t i = 0; i < SK_ARRAY_COUNT(inNames); ++i) {
- SkAutoTUnref<SkTypeface> first(SkTypeface::CreateFromName(inNames[i],
- SkTypeface::kNormal));
+ sk_sp<SkTypeface> first(SkTypeface::MakeFromName(inNames[i], SkTypeface::kNormal));
if (nullptr == first.get()) {
continue;
}
for (int j = 0; j < 10; ++j) {
- SkAutoTUnref<SkTypeface> face(SkTypeface::CreateFromName(inNames[i],
- SkTypeface::kNormal));
+ sk_sp<SkTypeface> face(SkTypeface::MakeFromName(inNames[i], SkTypeface::kNormal));
#if 0
SkString name;
face->getFamilyName(&name);
diff --git a/tests/FontObjTest.cpp b/tests/FontObjTest.cpp
index 9d18ce6..66c8bd5 100644
--- a/tests/FontObjTest.cpp
+++ b/tests/FontObjTest.cpp
@@ -23,7 +23,7 @@
}
static void test_cachedfont(skiatest::Reporter* reporter, const SkPaint& paint) {
- SkAutoTUnref<SkFont> font(SkFont::Testing_CreateFromPaint(paint));
+ sk_sp<SkFont> font(SkFont::Testing_CreateFromPaint(paint));
// Currently SkFont resolves null into the default, so only test if paint's is not null
if (paint.getTypeface()) {
@@ -78,8 +78,7 @@
char txt[] = "long.text.with.lots.of.dots.";
for (size_t i = 0; i < SK_ARRAY_COUNT(faces); i++) {
- SkAutoTUnref<SkTypeface> face(SkTypeface::CreateFromName(faces[i], SkTypeface::kNormal));
- paint.setTypeface(face);
+ paint.setTypeface(SkTypeface::MakeFromName(faces[i], SkTypeface::kNormal));
for (size_t j = 0; j < SK_ARRAY_COUNT(settings); j++) {
paint.setHinting(settings[j].hinting);
@@ -103,7 +102,7 @@
REPORTER_ASSERT(reporter, width1 == width2);
- SkAutoTUnref<SkFont> font(SkFont::Testing_CreateFromPaint(paint));
+ sk_sp<SkFont> font(SkFont::Testing_CreateFromPaint(paint));
SkScalar font_width1 = font->measureText(txt, strlen(txt), kUTF8_SkTextEncoding);
// measureText not yet implemented...
REPORTER_ASSERT(reporter, font_width1 == -1);
diff --git a/tests/PDFPrimitivesTest.cpp b/tests/PDFPrimitivesTest.cpp
index 58dd773..07ddabc 100644
--- a/tests/PDFPrimitivesTest.cpp
+++ b/tests/PDFPrimitivesTest.cpp
@@ -430,7 +430,7 @@
SkPDFCanon canon;
const char resource[] = "fonts/Roboto2-Regular_NoEmbed.ttf";
- sk_sp<SkTypeface> noEmbedTypeface(GetResourceAsTypeface(resource));
+ sk_sp<SkTypeface> noEmbedTypeface(MakeResourceAsTypeface(resource));
if (noEmbedTypeface) {
REPORTER_ASSERT(reporter,
!SkPDFFont::CanEmbedTypeface(noEmbedTypeface.get(), &canon));
diff --git a/tests/PaintTest.cpp b/tests/PaintTest.cpp
index bd00adb..f507467 100644
--- a/tests/PaintTest.cpp
+++ b/tests/PaintTest.cpp
@@ -80,7 +80,7 @@
SkRandom rand;
SkPaint paint;
- paint.setTypeface(SkTypeface::RefDefault())->unref();
+ paint.setTypeface(SkTypeface::MakeDefault());
SkTypeface* face = paint.getTypeface();
for (int i = 0; i < 1000; ++i) {
@@ -333,7 +333,7 @@
REPORTER_ASSERT(r, paint.getHash() == defaultHash);
// SkTypeface is the first field we hash, so test it specially.
- paint.setTypeface(SkTypeface::RefDefault())->unref();
+ paint.setTypeface(SkTypeface::MakeDefault());
REPORTER_ASSERT(r, paint.getHash() != defaultHash);
paint.setTypeface(nullptr);
REPORTER_ASSERT(r, paint.getHash() == defaultHash);
diff --git a/tests/PictureTest.cpp b/tests/PictureTest.cpp
index 9e36d84..832a80f 100644
--- a/tests/PictureTest.cpp
+++ b/tests/PictureTest.cpp
@@ -1177,7 +1177,7 @@
SkPictureRecorder recorder;
SkCanvas* canvas = recorder.beginRecording(10, 10);
SkPaint paint;
- paint.setTypeface(SkTypeface::CreateFromName("Arial", SkTypeface::kItalic));
+ paint.setTypeface(SkTypeface::MakeFromName("Arial", SkTypeface::kItalic));
canvas->drawText("Q", 1, 0, 10, paint);
sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
REPORTER_ASSERT(reporter, picture->hasText());
diff --git a/tests/SerializationTest.cpp b/tests/SerializationTest.cpp
index 4750bbe..9e9b221 100644
--- a/tests/SerializationTest.cpp
+++ b/tests/SerializationTest.cpp
@@ -322,14 +322,14 @@
}
REPORTER_ASSERT(reporter, 0 == pixelErrors);
}
-static void serialize_and_compare_typeface(SkTypeface* typeface, const char* text,
+static void serialize_and_compare_typeface(sk_sp<SkTypeface> typeface, const char* text,
skiatest::Reporter* reporter)
{
// Create a paint with the typeface.
SkPaint paint;
paint.setColor(SK_ColorGRAY);
paint.setTextSize(SkIntToScalar(30));
- paint.setTypeface(typeface);
+ paint.setTypeface(std::move(typeface));
// Paint some text.
SkPictureRecorder recorder;
@@ -357,11 +357,11 @@
{
// Load typeface from file to test CreateFromFile with index.
SkString filename = GetResourcePath("/fonts/test.ttc");
- SkAutoTUnref<SkTypeface> typeface(SkTypeface::CreateFromFile(filename.c_str(), 1));
+ sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFile(filename.c_str(), 1));
if (!typeface) {
INFOF(reporter, "Could not run fontstream test because test.ttc not found.");
} else {
- serialize_and_compare_typeface(typeface, "A!", reporter);
+ serialize_and_compare_typeface(std::move(typeface), "A!", reporter);
}
}
@@ -372,12 +372,12 @@
INFOF(reporter, "Could not run fontstream test because Distortable.ttf not found.");
} else {
SkFixed axis = SK_FixedSqrt2;
- SkAutoTUnref<SkTypeface> typeface(SkTypeface::CreateFromFontData(
+ sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFontData(
new SkFontData(distortable.release(), 0, &axis, 1)));
if (!typeface) {
INFOF(reporter, "Could not run fontstream test because Distortable.ttf not created.");
} else {
- serialize_and_compare_typeface(typeface, "abc", reporter);
+ serialize_and_compare_typeface(std::move(typeface), "abc", reporter);
}
}
}
diff --git a/tests/TextBlobCacheTest.cpp b/tests/TextBlobCacheTest.cpp
index 23f45a4..cbc6b99 100644
--- a/tests/TextBlobCacheTest.cpp
+++ b/tests/TextBlobCacheTest.cpp
@@ -99,12 +99,11 @@
set->getStyle(j, &fs, nullptr);
// We use a typeface which randomy returns unexpected mask formats to fuzz
- SkAutoTUnref<SkTypeface> orig(set->createTypeface(j));
+ sk_sp<SkTypeface> orig(set->createTypeface(j));
if (normal) {
paint.setTypeface(orig);
} else {
- SkAutoTUnref<SkTypeface> typeface(new SkRandomTypeface(orig, paint, true));
- paint.setTypeface(typeface);
+ paint.setTypeface(sk_make_sp<SkRandomTypeface>(orig, paint, true));
}
SkTextBlobBuilder builder;
diff --git a/tests/TextBlobTest.cpp b/tests/TextBlobTest.cpp
index 923669e..6107024 100644
--- a/tests/TextBlobTest.cpp
+++ b/tests/TextBlobTest.cpp
@@ -178,12 +178,10 @@
SkPaint font;
font.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
- SkAutoTUnref<SkTypeface> typeface(SkTypeface::RefDefault());
-
// Kitchen sink font.
font.setTextSize(42);
font.setTextScaleX(4.2f);
- font.setTypeface(typeface);
+ font.setTypeface(SkTypeface::MakeDefault());
font.setTextSkewX(0.42f);
font.setTextAlign(SkPaint::kCenter_Align);
font.setHinting(SkPaint::kFull_Hinting);
diff --git a/tests/TypefaceTest.cpp b/tests/TypefaceTest.cpp
index 950449d..6a606d4 100644
--- a/tests/TypefaceTest.cpp
+++ b/tests/TypefaceTest.cpp
@@ -12,8 +12,8 @@
DEF_TEST(Typeface, reporter) {
- SkAutoTUnref<SkTypeface> t1(SkTypeface::CreateFromName(nullptr, SkTypeface::kNormal));
- SkAutoTUnref<SkTypeface> t2(SkTypeface::RefDefault(SkTypeface::kNormal));
+ sk_sp<SkTypeface> t1(SkTypeface::MakeFromName(nullptr, SkTypeface::kNormal));
+ sk_sp<SkTypeface> t2(SkTypeface::MakeDefault(SkTypeface::kNormal));
REPORTER_ASSERT(reporter, SkTypeface::Equal(t1.get(), t2.get()));
REPORTER_ASSERT(reporter, SkTypeface::Equal(0, t1.get()));
@@ -22,8 +22,8 @@
REPORTER_ASSERT(reporter, SkTypeface::Equal(t2.get(), 0));
#ifdef SK_BUILD_FOR_ANDROID
- SkAutoTUnref<SkTypeface> t3(SkTypeface::CreateFromName("non-existent-font", SkTypeface::kNormal));
- REPORTER_ASSERT(reporter, nullptr == t3.get());
+ sk_sp<SkTypeface> t3(SkTypeface::MakeFromName("non-existent-font", SkTypeface::kNormal));
+ REPORTER_ASSERT(reporter, nullptr == t3);
#endif
}
diff --git a/tools/Resources.cpp b/tools/Resources.cpp
index 0117404..6d3054a 100644
--- a/tools/Resources.cpp
+++ b/tools/Resources.cpp
@@ -49,10 +49,10 @@
}
}
-SkTypeface* GetResourceAsTypeface(const char* resource) {
+sk_sp<SkTypeface> MakeResourceAsTypeface(const char* resource) {
SkAutoTDelete<SkStreamAsset> stream(GetResourceAsStream(resource));
if (!stream) {
return nullptr;
}
- return SkTypeface::CreateFromStream(stream.release());
+ return SkTypeface::MakeFromStream(stream.release());
}
diff --git a/tools/Resources.h b/tools/Resources.h
index 678e4c8..8115fbb 100644
--- a/tools/Resources.h
+++ b/tools/Resources.h
@@ -22,6 +22,6 @@
bool GetResourceAsBitmap(const char* resource, SkBitmap* dst);
sk_sp<SkImage> GetResourceAsImage(const char* resource);
SkStreamAsset* GetResourceAsStream(const char* resource);
-SkTypeface* GetResourceAsTypeface(const char* resource);
+sk_sp<SkTypeface> MakeResourceAsTypeface(const char* resource);
#endif // Resources_DEFINED
diff --git a/tools/debugger/SkDrawCommand.cpp b/tools/debugger/SkDrawCommand.cpp
index 4a88fa1..b95a9b8 100644
--- a/tools/debugger/SkDrawCommand.cpp
+++ b/tools/debugger/SkDrawCommand.cpp
@@ -1214,8 +1214,7 @@
const void* data;
Json::ArrayIndex length = decode_data(jsonData, urlDataManager, &data);
SkMemoryStream buffer(data, length);
- SkTypeface* typeface = SkTypeface::Deserialize(&buffer);
- target->setTypeface(typeface);
+ target->setTypeface(SkTypeface::MakeDeserialize(&buffer));
}
}
diff --git a/tools/sk_tool_utils.cpp b/tools/sk_tool_utils.cpp
index f46ebb6..7343ce4 100644
--- a/tools/sk_tool_utils.cpp
+++ b/tools/sk_tool_utils.cpp
@@ -1,4 +1,4 @@
-/*
+/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
@@ -75,17 +75,14 @@
return "";
}
-void emoji_typeface(SkAutoTUnref<SkTypeface>* tf) {
+sk_sp<SkTypeface> emoji_typeface() {
if (!strcmp(sk_tool_utils::platform_os_emoji(), "CBDT")) {
- tf->reset(GetResourceAsTypeface("/fonts/Funkster.ttf"));
- return;
+ return MakeResourceAsTypeface("/fonts/Funkster.ttf");
}
if (!strcmp(sk_tool_utils::platform_os_emoji(), "SBIX")) {
- tf->reset(SkTypeface::CreateFromName("Apple Color Emoji", SkTypeface::kNormal));
- return;
+ return SkTypeface::MakeFromName("Apple Color Emoji", SkTypeface::kNormal);
}
- tf->reset(nullptr);
- return;
+ return nullptr;
}
const char* emoji_sample_text() {
@@ -159,13 +156,12 @@
return SkPixel16ToColor(color16);
}
-SkTypeface* create_portable_typeface(const char* name, SkTypeface::Style style) {
+sk_sp<SkTypeface> create_portable_typeface(const char* name, SkTypeface::Style style) {
return create_font(name, style);
}
void set_portable_typeface(SkPaint* paint, const char* name, SkTypeface::Style style) {
- SkTypeface* face = create_font(name, style);
- SkSafeUnref(paint->setTypeface(face));
+ paint->setTypeface(create_font(name, style));
}
void write_pixels(SkCanvas* canvas, const SkBitmap& bitmap, int x, int y,
diff --git a/tools/sk_tool_utils.h b/tools/sk_tool_utils.h
index 1d80731..a16c2a2 100644
--- a/tools/sk_tool_utils.h
+++ b/tools/sk_tool_utils.h
@@ -36,7 +36,7 @@
/**
* Return a color emoji typeface if available.
*/
- void emoji_typeface(SkAutoTUnref<SkTypeface>* );
+ sk_sp<SkTypeface> emoji_typeface();
/**
* If the platform supports color emoji, return sample text the emoji can render.
@@ -77,7 +77,7 @@
/**
* Returns a platform-independent text renderer.
*/
- SkTypeface* create_portable_typeface(const char* name, SkTypeface::Style style);
+ sk_sp<SkTypeface> create_portable_typeface(const char* name, SkTypeface::Style style);
/** Call to clean up portable font references. */
void release_portable_typefaces();
@@ -89,7 +89,7 @@
void write_pixels(SkCanvas*, const SkBitmap&, int x, int y, SkColorType, SkAlphaType);
// private to sk_tool_utils
- SkTypeface* create_font(const char* name, SkTypeface::Style);
+ sk_sp<SkTypeface> create_font(const char* name, SkTypeface::Style);
/** Returns a newly created CheckerboardShader. */
sk_sp<SkShader> create_checkerboard_shader(SkColor c1, SkColor c2, int size);
diff --git a/tools/sk_tool_utils_font.cpp b/tools/sk_tool_utils_font.cpp
index adbfa16..f73576d 100644
--- a/tools/sk_tool_utils_font.cpp
+++ b/tools/sk_tool_utils_font.cpp
@@ -29,7 +29,7 @@
SK_DECLARE_STATIC_MUTEX(gTestFontMutex);
-SkTypeface* create_font(const char* name, SkTypeface::Style style) {
+sk_sp<SkTypeface> create_font(const char* name, SkTypeface::Style style) {
SkTestFontData* fontData = nullptr;
const SubFont* sub;
if (name) {
@@ -47,7 +47,8 @@
// If we called SkTypeface::CreateFromName() here we'd recurse infinitely,
// so we reimplement its core logic here inline without the recursive aspect.
SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
- return fm->legacyCreateTypeface(name, SkFontStyle::FromOldStyle(style));
+ return sk_sp<SkTypeface>(fm->legacyCreateTypeface(name,
+ SkFontStyle::FromOldStyle(style)));
}
} else {
sub = &gSubFonts[gDefaultFontIndex];
@@ -65,7 +66,7 @@
fontData->fFontCache = SkSafeRef(font);
}
}
- return new SkTestTypeface(font, SkFontStyle::FromOldStyle(style));
+ return sk_make_sp<SkTestTypeface>(font, SkFontStyle::FromOldStyle(style));
}
}
diff --git a/tools/using_skia_and_harfbuzz.cpp b/tools/using_skia_and_harfbuzz.cpp
index 413939d..86c9acc 100644
--- a/tools/using_skia_and_harfbuzz.cpp
+++ b/tools/using_skia_and_harfbuzz.cpp
@@ -142,9 +142,7 @@
auto data = SkData::MakeFromFileName(path);
assert(data);
if (!data) { return; }
- fSkiaTypeface.reset(
- SkTypeface::CreateFromStream(
- new SkMemoryStream(data), index));
+ fSkiaTypeface = SkTypeface::MakeFromStream(new SkMemoryStream(data), index);
assert(fSkiaTypeface);
if (!fSkiaTypeface) { return; }
auto destroy = [](void *d) { static_cast<SkData*>(d)->unref(); };