AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert r10788 (allow both GDI and DW fontmgrs at the same time) due to Chromium XP bot failures

Browse Source 
git-svn-id: http://skia.googlecode.com/svn/trunk@10813 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
robertphillips@google.com 2013-08-20 14:36:59 +00:00
parent bee5f97c73
commit bcb88e51cd
6 changed files with 159 additions and 244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
gm/fontmgr.cpp
View File

@ -11,11 +11,6 @@
#include "SkGraphics.h"
#include "SkTypeface.h"
#ifdef SK_BUILD_FOR_WIN
extern SkFontMgr* SkFontMgr_New_GDI();
extern SkFontMgr* SkFontMgr_New_DirectWrite();
#endif
// limit this just so we don't take too long to draw
#define MAX_FAMILIES 30
@ -27,21 +22,13 @@ static SkScalar drawString(SkCanvas* canvas, const SkString& text, SkScalar x,
class FontMgrGM : public skiagm::GM {
public:
FontMgrGM(SkFontMgr* (*factory)() = NULL) {
FontMgrGM() {
SkGraphics::SetFontCacheLimit(16 * 1024 * 1024);
fName.set("fontmgr_iter");
if (factory) {
fName.append("_factory");
fFM.reset(factory());
} else {
fFM.reset(SkFontMgr::RefDefault());
}
}
protected:
virtual SkString onShortName() {
return fName;
return SkString("fontmgr_iter");
}
virtual SkISize onISize() {
@ -56,7 +43,7 @@ protected:
paint.setSubpixelText(true);
paint.setTextSize(17);
SkFontMgr* fm = fFM;
SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
int count = SkMin32(fm->countFamilies(), MAX_FAMILIES);
for (int i = 0; i < count; ++i) {
@ -92,8 +79,6 @@ protected:
}
private:
SkAutoTUnref<SkFontMgr> fFM;
SkString fName;
typedef GM INHERITED;
};
@ -196,7 +181,3 @@ private:
DEF_GM( return SkNEW(FontMgrGM); )
DEF_GM( return SkNEW(FontMgrMatchGM); )
#ifdef SK_BUILD_FOR_WIN
DEF_GM( return SkNEW_ARGS(FontMgrGM, (SkFontMgr_New_DirectWrite)); )
#endif

29
gyp/ports.gyp
View File

@ -26,12 +26,8 @@
'../src/ports/SkDebug_nacl.cpp',
'../src/ports/SkDebug_stdio.cpp',
'../src/ports/SkDebug_win.cpp',
'../src/ports/SkFontHost_win.cpp',
'../src/ports/SkFontHost_win_dw.cpp',
'../src/ports/SkFontMgr_default_gdi.cpp',
'../src/ports/SkFontMgr_default_dw.cpp',
'../src/ports/SkGlobalInitialization_default.cpp',
'../src/ports/SkMemory_malloc.cpp',
'../src/ports/SkOSFile_posix.cpp',
@ -118,6 +114,17 @@
'config/win',
'../src/utils/win',
],
'conditions': [
[ 'skia_directwrite', {
'sources!': [
'../src/ports/SkFontHost_win.cpp',
],
}, { # else !skia_directwrite
'sources!': [
'../src/ports/SkFontHost_win_dw.cpp',
],
}],
],
'sources!': [ # these are used everywhere but windows
'../src/ports/SkDebug_stdio.cpp',
'../src/ports/SkOSFile_posix.cpp',
@ -125,25 +132,11 @@
'../src/ports/SkTime_Unix.cpp',
'../src/ports/SkTLS_pthread.cpp',
],
'conditions': [
# when we build for win, we only want one of these default files
[ 'skia_directwrite', {
'sources!': [
'../src/ports/SkFontMgr_default_gdi.cpp',
],
}, { # else gdi
'sources!': [
'../src/ports/SkFontMgr_default_dw.cpp',
],
}],
],
}, { # else !win
'sources!': [
'../src/ports/SkDebug_win.cpp',
'../src/ports/SkFontHost_win.cpp',
'../src/ports/SkFontHost_win_dw.cpp',
'../src/ports/SkFontMgr_default_gdi.cpp',
'../src/ports/SkFontMgr_default_dw.cpp',
'../src/ports/SkOSFile_win.cpp',
'../src/ports/SkThread_win.cpp',
'../src/ports/SkTime_win.cpp',

3
src/ports/SkFontHost_win.cpp
View File

@ -2371,7 +2371,6 @@ SkTypeface* SkFontHost::CreateTypefaceFromStream(SkStream* stream) {
#endif
extern SkFontMgr* SkFontMgr_New_GDI();
SkFontMgr* SkFontMgr_New_GDI() {
SkFontMgr* SkFontMgr::Factory() {
return SkNEW(SkFontMgrGDI);
}

332
src/ports/SkFontHost_win_dw.cpp
View File

@ -16,7 +16,6 @@
#include "SkEndian.h"
#include "SkFontDescriptor.h"
#include "SkFontHost.h"
#include "SkFontMgr.h"
#include "SkFontStream.h"
#include "SkGlyph.h"
#include "SkHRESULT.h"
@ -76,68 +75,6 @@ static HRESULT wchar_to_skstring(WCHAR* name, SkString* skname) {
///////////////////////////////////////////////////////////////////////////////
class StreamFontFileLoader;
class SkFontMgr_DirectWrite : public SkFontMgr {
public:
/** localeNameLength must include the null terminator. */
SkFontMgr_DirectWrite(IDWriteFontCollection* fontCollection,
WCHAR* localeName, int localeNameLength)
: fFontCollection(SkRefComPtr(fontCollection))
, fLocaleName(localeNameLength)
{
memcpy(fLocaleName.get(), localeName, localeNameLength * sizeof(WCHAR));
}
SkTypefaceCache* getTypefaceCache() { return &fTFCache; }
SkTypeface* createTypefaceFromDWriteFont(IDWriteFontFace* fontFace,
IDWriteFont* font,
IDWriteFontFamily* fontFamily,
StreamFontFileLoader* = NULL,
IDWriteFontCollectionLoader* = NULL);
protected:
virtual int onCountFamilies() SK_OVERRIDE;
virtual void onGetFamilyName(int index, SkString* familyName) SK_OVERRIDE;
virtual SkFontStyleSet* onCreateStyleSet(int index) SK_OVERRIDE;
virtual SkFontStyleSet* onMatchFamily(const char familyName[]) SK_OVERRIDE;
virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
const SkFontStyle& fontstyle) SK_OVERRIDE;
virtual SkTypeface* onMatchFaceStyle(const SkTypeface* familyMember,
const SkFontStyle& fontstyle) SK_OVERRIDE;
virtual SkTypeface* onCreateFromStream(SkStream* stream, int ttcIndex) SK_OVERRIDE;
virtual SkTypeface* onCreateFromData(SkData* data, int ttcIndex) SK_OVERRIDE;
virtual SkTypeface* onCreateFromFile(const char path[], int ttcIndex) SK_OVERRIDE;
virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
unsigned styleBits) SK_OVERRIDE;
private:
friend class SkFontStyleSet_DirectWrite;
SkTScopedComPtr<IDWriteFontCollection> fFontCollection;
SkSMallocWCHAR fLocaleName;
SkTypefaceCache fTFCache;
};
class SkFontStyleSet_DirectWrite : public SkFontStyleSet {
public:
SkFontStyleSet_DirectWrite(SkFontMgr_DirectWrite* fontMgr, IDWriteFontFamily* fontFamily)
: fFontMgr(SkRef(fontMgr))
, fFontFamily(SkRefComPtr(fontFamily))
{ }
virtual int count() SK_OVERRIDE;
virtual void getStyle(int index, SkFontStyle* fs, SkString* styleName) SK_OVERRIDE;
virtual SkTypeface* createTypeface(int index) SK_OVERRIDE;
virtual SkTypeface* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE;
private:
SkAutoTUnref<SkFontMgr_DirectWrite> fFontMgr;
SkTScopedComPtr<IDWriteFontFamily> fFontFamily;
};
///////////////////////////////////////////////////////////////////////////////
class DWriteOffscreen {
public:
DWriteOffscreen() : fWidth(0), fHeight(0) {
@ -767,6 +704,20 @@ static bool FindByDWriteFont(SkTypeface* face, SkTypeface::Style requestedStyle,
wcscmp(dwFaceFontNameChar.get(), dwFontNameChar.get()) == 0;
}
SkTypeface* SkCreateTypefaceFromDWriteFont(IDWriteFontFace* fontFace,
IDWriteFont* font,
IDWriteFontFamily* fontFamily,
StreamFontFileLoader* fontFileLoader = NULL,
IDWriteFontCollectionLoader* fontCollectionLoader = NULL) {
SkTypeface* face = SkTypefaceCache::FindByProcAndRef(FindByDWriteFont, font);
if (NULL == face) {
face = DWriteFontTypeface::Create(fontFace, font, fontFamily,
fontFileLoader, fontCollectionLoader);
SkTypefaceCache::Add(face, get_style(font), fontCollectionLoader != NULL);
}
return face;
}
void SkDWriteFontFromTypeface(const SkTypeface* face, IDWriteFont** font) {
if (NULL == face) {
HRVM(get_default_font(font), "Could not get default font.");
@ -1307,9 +1258,9 @@ static SkTypeface* create_from_stream(SkStream* stream, int ttcIndex) {
UINT32 faceIndex = fontFace->GetIndex();
if (faceIndex == ttcIndex) {
return DWriteFontTypeface::Create(fontFace.get(), font.get(), fontFamily.get(),
autoUnregisterFontFileLoader.detatch(),
autoUnregisterFontCollectionLoader.detatch());
return SkCreateTypefaceFromDWriteFont(fontFace.get(), font.get(), fontFamily.get(),
autoUnregisterFontFileLoader.detatch(),
autoUnregisterFontCollectionLoader.detatch());
}
}
}
@ -1645,8 +1596,7 @@ SkAdvancedTypefaceMetrics* DWriteFontTypeface::onGetAdvancedTypefaceMetrics(
static SkTypeface* create_typeface(const SkTypeface* familyFace,
const char familyName[],
unsigned style,
SkFontMgr_DirectWrite* fontMgr) {
unsigned style) {
HRESULT hr;
SkTScopedComPtr<IDWriteFontFamily> fontFamily;
if (familyFace) {
@ -1677,17 +1627,17 @@ static SkTypeface* create_typeface(const SkTypeface* familyFace,
SkTScopedComPtr<IDWriteFontFace> fontFace;
hr = font->CreateFontFace(&fontFace);
return fontMgr->createTypefaceFromDWriteFont(fontFace.get(), font.get(), fontFamily.get());
return SkCreateTypefaceFromDWriteFont(fontFace.get(), font.get(), fontFamily.get());
}
SkTypeface* DWriteFontTypeface::onRefMatchingStyle(Style style) const {
SkFontMgr_DirectWrite* fontMgr = NULL;
// todo: should each typeface have a ref to its fontmgr/cache?
return create_typeface(this, NULL, style, fontMgr);
return create_typeface(this, NULL, style);
}
///////////////////////////////////////////////////////////////////////////////
#include "SkFontMgr.h"
static void get_locale_string(IDWriteLocalizedStrings* names, const WCHAR* preferedLocale,
SkString* skname) {
UINT32 nameIndex = 0;
@ -1710,108 +1660,143 @@ static void get_locale_string(IDWriteLocalizedStrings* names, const WCHAR* prefe
HRV(wchar_to_skstring(name.get(), skname));
}
SkTypeface* SkFontMgr_DirectWrite::createTypefaceFromDWriteFont(
IDWriteFontFace* fontFace,
IDWriteFont* font,
IDWriteFontFamily* fontFamily,
StreamFontFileLoader* fontFileLoader,
IDWriteFontCollectionLoader* fontCollectionLoader) {
SkTypeface* face = fTFCache.findByProcAndRef(FindByDWriteFont, font);
if (NULL == face) {
face = DWriteFontTypeface::Create(fontFace, font, fontFamily,
fontFileLoader, fontCollectionLoader);
if (face) {
fTFCache.add(face, get_style(font), fontCollectionLoader != NULL);
class SkFontMgr_DirectWrite;
class SkFontStyleSet_DirectWrite : public SkFontStyleSet {
public:
SkFontStyleSet_DirectWrite(const SkFontMgr_DirectWrite* fontMgr, IDWriteFontFamily* fontFamily)
: fFontMgr(SkRef(fontMgr))
, fFontFamily(SkRefComPtr(fontFamily))
{ }
virtual int count() SK_OVERRIDE {
return fFontFamily->GetFontCount();
}
virtual void getStyle(int index, SkFontStyle* fs, SkString* styleName);
virtual SkTypeface* createTypeface(int index) SK_OVERRIDE {
SkTScopedComPtr<IDWriteFont> font;
HRNM(fFontFamily->GetFont(index, &font), "Could not get font.");
SkTScopedComPtr<IDWriteFontFace> fontFace;
HRNM(font->CreateFontFace(&fontFace), "Could not create font face.");
return SkCreateTypefaceFromDWriteFont(fontFace.get(), font.get(), fFontFamily.get());
}
virtual SkTypeface* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE {
DWRITE_FONT_STYLE slant;
switch (pattern.slant()) {
case SkFontStyle::kUpright_Slant:
slant = DWRITE_FONT_STYLE_NORMAL;
break;
case SkFontStyle::kItalic_Slant:
slant = DWRITE_FONT_STYLE_ITALIC;
break;
default:
SkASSERT(false);
}
}
return face;
}
int SkFontMgr_DirectWrite::onCountFamilies() {
return fFontCollection->GetFontFamilyCount();
}
DWRITE_FONT_WEIGHT weight = (DWRITE_FONT_WEIGHT)pattern.weight();
DWRITE_FONT_STRETCH width = (DWRITE_FONT_STRETCH)pattern.width();
void SkFontMgr_DirectWrite::onGetFamilyName(int index, SkString* familyName) {
SkTScopedComPtr<IDWriteFontFamily> fontFamily;
HRVM(fFontCollection->GetFontFamily(index, &fontFamily), "Could not get requested family.");
SkTScopedComPtr<IDWriteFont> font;
// TODO: perhaps use GetMatchingFonts and get the least simulated?
HRNM(fFontFamily->GetFirstMatchingFont(weight, width, slant, &font),
"Could not match font in family.");
SkTScopedComPtr<IDWriteLocalizedStrings> familyNames;
HRVM(fontFamily->GetFamilyNames(&familyNames), "Could not get family names.");
SkTScopedComPtr<IDWriteFontFace> fontFace;
HRNM(font->CreateFontFace(&fontFace), "Could not create font face.");
get_locale_string(familyNames.get(), fLocaleName.get(), familyName);
}
SkFontStyleSet* SkFontMgr_DirectWrite::onCreateStyleSet(int index) {
SkTScopedComPtr<IDWriteFontFamily> fontFamily;
HRNM(fFontCollection->GetFontFamily(index, &fontFamily), "Could not get requested family.");
return SkNEW_ARGS(SkFontStyleSet_DirectWrite, (this, fontFamily.get()));
}
SkFontStyleSet* SkFontMgr_DirectWrite::onMatchFamily(const char familyName[]) {
SkSMallocWCHAR dwFamilyName;
HRN(cstring_to_wchar(familyName, &dwFamilyName));
UINT32 index;
BOOL exists;
HRNM(fFontCollection->FindFamilyName(dwFamilyName.get(), &index, &exists),
"Failed while finding family by name.");
if (!exists) {
return NULL;
return SkCreateTypefaceFromDWriteFont(fontFace.get(), font.get(), fFontFamily.get());
}
return this->onCreateStyleSet(index);
}
private:
SkAutoTUnref<const SkFontMgr_DirectWrite> fFontMgr;
SkTScopedComPtr<IDWriteFontFamily> fFontFamily;
};
SkTypeface* SkFontMgr_DirectWrite::onMatchFamilyStyle(const char familyName[],
const SkFontStyle& fontstyle) {
SkAutoTUnref<SkFontStyleSet> sset(this->matchFamily(familyName));
return sset->matchStyle(fontstyle);
}
class SkFontMgr_DirectWrite : public SkFontMgr {
public:
/** localeNameLength must include the null terminator. */
SkFontMgr_DirectWrite(IDWriteFontCollection* fontCollection,
WCHAR* localeName, int localeNameLength)
: fFontCollection(SkRefComPtr(fontCollection))
, fLocaleName(localeNameLength)
{
memcpy(fLocaleName.get(), localeName, localeNameLength * sizeof(WCHAR));
}
SkTypeface* SkFontMgr_DirectWrite::onMatchFaceStyle(const SkTypeface* familyMember,
const SkFontStyle& fontstyle) {
SkString familyName;
SkFontStyleSet_DirectWrite sset(
this, ((DWriteFontTypeface*)familyMember)->fDWriteFontFamily.get()
);
return sset.matchStyle(fontstyle);
}
private:
friend class SkFontStyleSet_DirectWrite;
SkTScopedComPtr<IDWriteFontCollection> fFontCollection;
SkSMallocWCHAR fLocaleName;
SkTypeface* SkFontMgr_DirectWrite::onCreateFromStream(SkStream* stream, int ttcIndex) {
return create_from_stream(stream, ttcIndex);
}
protected:
virtual int onCountFamilies() SK_OVERRIDE {
return fFontCollection->GetFontFamilyCount();
}
virtual void onGetFamilyName(int index, SkString* familyName) SK_OVERRIDE {
SkTScopedComPtr<IDWriteFontFamily> fontFamily;
HRVM(fFontCollection->GetFontFamily(index, &fontFamily), "Could not get requested family.");
SkTypeface* SkFontMgr_DirectWrite::onCreateFromData(SkData* data, int ttcIndex) {
SkAutoTUnref<SkStream> stream(SkNEW_ARGS(SkMemoryStream, (data)));
return this->createFromStream(stream, ttcIndex);
}
SkTScopedComPtr<IDWriteLocalizedStrings> familyNames;
HRVM(fontFamily->GetFamilyNames(&familyNames), "Could not get family names.");
SkTypeface* SkFontMgr_DirectWrite::onCreateFromFile(const char path[], int ttcIndex) {
SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
return this->createFromStream(stream, ttcIndex);
}
get_locale_string(familyNames.get(), fLocaleName.get(), familyName);
}
virtual SkFontStyleSet* onCreateStyleSet(int index) SK_OVERRIDE {
SkTScopedComPtr<IDWriteFontFamily> fontFamily;
HRNM(fFontCollection->GetFontFamily(index, &fontFamily), "Could not get requested family.");
SkTypeface* SkFontMgr_DirectWrite::onLegacyCreateTypeface(const char familyName[],
unsigned styleBits) {
return create_typeface(NULL, familyName, styleBits, this);
}
return SkNEW_ARGS(SkFontStyleSet_DirectWrite, (this, fontFamily.get()));
}
virtual SkFontStyleSet* onMatchFamily(const char familyName[]) SK_OVERRIDE {
SkSMallocWCHAR dwFamilyName;
HRN(cstring_to_wchar(familyName, &dwFamilyName));
///////////////////////////////////////////////////////////////////////////////
UINT32 index;
BOOL exists;
HRNM(fFontCollection->FindFamilyName(dwFamilyName.get(), &index, &exists),
"Failed while finding family by name.");
if (!exists) {
return NULL;
}
int SkFontStyleSet_DirectWrite::count() {
return fFontFamily->GetFontCount();
}
return this->onCreateStyleSet(index);
}
SkTypeface* SkFontStyleSet_DirectWrite::createTypeface(int index) {
SkTScopedComPtr<IDWriteFont> font;
HRNM(fFontFamily->GetFont(index, &font), "Could not get font.");
virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
const SkFontStyle& fontstyle) SK_OVERRIDE {
SkAutoTUnref<SkFontStyleSet> sset(this->matchFamily(familyName));
return sset->matchStyle(fontstyle);
}
virtual SkTypeface* onMatchFaceStyle(const SkTypeface* familyMember,
const SkFontStyle& fontstyle) SK_OVERRIDE {
SkString familyName;
SkFontStyleSet_DirectWrite sset(
this, ((DWriteFontTypeface*)familyMember)->fDWriteFontFamily.get()
);
return sset.matchStyle(fontstyle);
}
virtual SkTypeface* onCreateFromStream(SkStream* stream, int ttcIndex) SK_OVERRIDE {
return create_from_stream(stream, ttcIndex);
}
virtual SkTypeface* onCreateFromData(SkData* data, int ttcIndex) SK_OVERRIDE {
SkAutoTUnref<SkStream> stream(SkNEW_ARGS(SkMemoryStream, (data)));
return this->createFromStream(stream, ttcIndex);
}
virtual SkTypeface* onCreateFromFile(const char path[], int ttcIndex) SK_OVERRIDE {
SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
return this->createFromStream(stream, ttcIndex);
}
SkTScopedComPtr<IDWriteFontFace> fontFace;
HRNM(font->CreateFontFace(&fontFace), "Could not create font face.");
return fFontMgr->createTypefaceFromDWriteFont(fontFace.get(), font.get(), fFontFamily.get());
}
virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
unsigned styleBits) SK_OVERRIDE {
return create_typeface(NULL, familyName, styleBits);
}
};
void SkFontStyleSet_DirectWrite::getStyle(int index, SkFontStyle* fs, SkString* styleName) {
SkTScopedComPtr<IDWriteFont> font;
@ -1841,34 +1826,6 @@ void SkFontStyleSet_DirectWrite::getStyle(int index, SkFontStyle* fs, SkString*
}
}
SkTypeface* SkFontStyleSet_DirectWrite::matchStyle(const SkFontStyle& pattern) {
DWRITE_FONT_STYLE slant;
switch (pattern.slant()) {
case SkFontStyle::kUpright_Slant:
slant = DWRITE_FONT_STYLE_NORMAL;
break;
case SkFontStyle::kItalic_Slant:
slant = DWRITE_FONT_STYLE_ITALIC;
break;
default:
SkASSERT(false);
}
DWRITE_FONT_WEIGHT weight = (DWRITE_FONT_WEIGHT)pattern.weight();
DWRITE_FONT_STRETCH width = (DWRITE_FONT_STRETCH)pattern.width();
SkTScopedComPtr<IDWriteFont> font;
// TODO: perhaps use GetMatchingFonts and get the least simulated?
HRNM(fFontFamily->GetFirstMatchingFont(weight, width, slant, &font),
"Could not match font in family.");
SkTScopedComPtr<IDWriteFontFace> fontFace;
HRNM(font->CreateFontFace(&fontFace), "Could not create font face.");
return fFontMgr->createTypefaceFromDWriteFont(fontFace.get(), font.get(),
fFontFamily.get());
}
///////////////////////////////////////////////////////////////////////////////
#ifndef SK_FONTHOST_USES_FONTMGR
@ -1876,7 +1833,7 @@ SkTypeface* SkFontStyleSet_DirectWrite::matchStyle(const SkFontStyle& pattern) {
SkTypeface* SkFontHost::CreateTypeface(const SkTypeface* familyFace,
const char familyName[],
SkTypeface::Style style) {
return create_typeface(familyFace, familyName, style, NULL);
return create_typeface(familyFace, familyName, style);
}
SkTypeface* SkFontHost::CreateTypefaceFromFile(const char path[]) {
@ -1890,8 +1847,7 @@ SkTypeface* SkFontHost::CreateTypefaceFromStream(SkStream* stream) {
#endif
extern SkFontMgr* SkFontMgr_New_DirectWrite();
SkFontMgr* SkFontMgr_New_DirectWrite() {
SkFontMgr* SkFontMgr::Factory() {
IDWriteFactory* factory;
HRNM(get_dwrite_factory(&factory), "Could not get factory.");

7
src/ports/SkFontMgr_default_dw.cpp
View File

@ -1,7 +0,0 @@
#include "SkFontMgr.h"
extern SkFontMgr* SkFontMgr_New_DirectWrite();
SkFontMgr* SkFontMgr::Factory() {
return SkFontMgr_New_DirectWrite();
}

7
src/ports/SkFontMgr_default_gdi.cpp
View File

@ -1,7 +0,0 @@
#include "SkFontMgr.h"
extern SkFontMgr* SkFontMgr_New_GDI();
SkFontMgr* SkFontMgr::Factory() {
return SkFontMgr_New_GDI();
}