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

Revert "[PDF] Fix font embedding restrictions."

Browse Source 
This reverts r12600 and r12601, likely causing crash on Mac.

Review URL: https://codereview.chromium.org/111893002

git-svn-id: http://skia.googlecode.com/svn/trunk@12604 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
vandebo@chromium.org 2013-12-10 17:22:41 +00:00
parent 7ad9368687
commit 5f209e6405
11 changed files with 65 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
gyp/core.gyp
View File

@ -23,7 +23,6 @@
'../include/xml', '../include/xml',
'../src/core', '../src/core',
'../src/opts', '../src/opts',
'../src/sfnt',
'../src/image', '../src/image',
], ],
'sources': [ 'sources': [

16
include/core/SkAdvancedTypefaceMetrics.h
View File

@ -35,21 +35,15 @@ public:
kCFF_Font, kCFF_Font,
kTrueType_Font, kTrueType_Font,
kOther_Font, kOther_Font,
kNotEmbeddable_Font
}; };
// The type of the underlying font program. This field determines which // The type of the underlying font program. This field determines which
// of the following fields are valid. If it is kOther_Font the per glyph // of the following fields are valid. If it is kOther_Font or
// information will never be populated. // kNotEmbeddable_Font, the per glyph information will never be populated.
FontType fType; FontType fType;
enum FontFlags { // fMultiMaster may be true for Type1_Font or CFF_Font.
kEmpty_FontFlag = 0x0, //!<No flags set bool fMultiMaster;
kMultiMaster_FontFlag = 0x1, //!<May be true for Type1 or CFF fonts.
kNotEmbeddable_FontFlag = 0x2, //!<May not be embedded.
kNotSubsettable_FontFlag = 0x4, //!<May not be subset.
};
// Global font flags.
FontFlags fFlags;
uint16_t fLastGlyphID; // The last valid glyph ID in the font. uint16_t fLastGlyphID; // The last valid glyph ID in the font.
uint16_t fEmSize; // The size of the em box (defines font units). uint16_t fEmSize; // The size of the em box (defines font units).

10
include/pdf/SkPDFDocument.h
View File

@ -69,17 +69,9 @@ public:
SK_API bool appendPage(SkPDFDevice* pdfDevice); SK_API bool appendPage(SkPDFDevice* pdfDevice);
/** Get the count of unique font types used in the document. /** Get the count of unique font types used in the document.
* DEPRECATED.
*/ */
SK_API void getCountOfFontTypes( SK_API void getCountOfFontTypes(
int counts[SkAdvancedTypefaceMetrics::kOther_Font + 2]) const; int counts[SkAdvancedTypefaceMetrics::kNotEmbeddable_Font + 1]) const;
/** Get the count of unique font types used in the document.
*/
SK_API void getCountOfFontTypes(
int counts[SkAdvancedTypefaceMetrics::kOther_Font + 1],
int* notSubsettableCount,
int* notEmbedddableCount) const;
private: private:
SkAutoTDelete<SkPDFCatalog> fCatalog; SkAutoTDelete<SkPDFCatalog> fCatalog;

23
src/core/SkTypeface.cpp
View File

@ -6,10 +6,8 @@
*/ */
#include "SkAdvancedTypefaceMetrics.h" #include "SkAdvancedTypefaceMetrics.h"
#include "SkEndian.h"
#include "SkFontDescriptor.h" #include "SkFontDescriptor.h"
#include "SkFontHost.h" #include "SkFontHost.h"
#include "SkOTTable_OS_2.h"
#include "SkStream.h" #include "SkStream.h"
#include "SkTypeface.h" #include "SkTypeface.h"
@ -261,26 +259,7 @@ SkAdvancedTypefaceMetrics* SkTypeface::getAdvancedTypefaceMetrics(
SkAdvancedTypefaceMetrics::PerGlyphInfo info, SkAdvancedTypefaceMetrics::PerGlyphInfo info,
const uint32_t* glyphIDs, const uint32_t* glyphIDs,
uint32_t glyphIDsCount) const { uint32_t glyphIDsCount) const {
SkAdvancedTypefaceMetrics* result = return this->onGetAdvancedTypefaceMetrics(info, glyphIDs, glyphIDsCount);
this->onGetAdvancedTypefaceMetrics(info, glyphIDs, glyphIDsCount);
if (result && result->fType == SkAdvancedTypefaceMetrics::kTrueType_Font) {
struct SkOTTableOS2 os2table;
if (this->getTableData(SkEndian_SwapBE32(SkOTTableOS2::TAG), 0,
sizeof(os2table), &os2table) > 0) {
if (os2table.version.v2.fsType.field.Restricted ||
os2table.version.v2.fsType.field.Bitmap) {
result->fFlags = SkTBitOr<SkAdvancedTypefaceMetrics::FontFlags>(
result->fFlags,
SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag);
}
if (os2table.version.v2.fsType.field.NoSubsetting) {
result->fFlags = SkTBitOr<SkAdvancedTypefaceMetrics::FontFlags>(
result->fFlags,
SkAdvancedTypefaceMetrics::kNotSubsettable_FontFlag);
}
}
}
return result;
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////

46
src/pdf/SkPDFDocument.cpp
View File

@ -258,13 +258,11 @@ bool SkPDFDocument::appendPage(SkPDFDevice* pdfDevice) {
return true; return true;
} }
// Deprecated.
void SkPDFDocument::getCountOfFontTypes( void SkPDFDocument::getCountOfFontTypes(
int counts[SkAdvancedTypefaceMetrics::kOther_Font + 2]) const { int counts[SkAdvancedTypefaceMetrics::kNotEmbeddable_Font + 1]) const {
sk_bzero(counts, sizeof(int) * sk_bzero(counts, sizeof(int) *
(SkAdvancedTypefaceMetrics::kOther_Font + 2)); (SkAdvancedTypefaceMetrics::kNotEmbeddable_Font + 1));
SkTDArray<SkFontID> seenFonts; SkTDArray<SkFontID> seenFonts;
int notEmbeddable = 0;
for (int pageNumber = 0; pageNumber < fPages.count(); pageNumber++) { for (int pageNumber = 0; pageNumber < fPages.count(); pageNumber++) {
const SkTDArray<SkPDFFont*>& fontResources = const SkTDArray<SkPDFFont*>& fontResources =
@ -274,49 +272,9 @@ void SkPDFDocument::getCountOfFontTypes(
if (seenFonts.find(fontID) == -1) { if (seenFonts.find(fontID) == -1) {
counts[fontResources[font]->getType()]++; counts[fontResources[font]->getType()]++;
seenFonts.push(fontID); seenFonts.push(fontID);
if (!fontResources[font]->canEmbed()) {
notEmbeddable++;
}
} }
} }
} }
counts[SkAdvancedTypefaceMetrics::kOther_Font + 1] = notEmbeddable;
}
void SkPDFDocument::getCountOfFontTypes(
int counts[SkAdvancedTypefaceMetrics::kOther_Font + 1],
int* notSubsettableCount,
int* notEmbeddableCount) const {
sk_bzero(counts, sizeof(int) *
(SkAdvancedTypefaceMetrics::kOther_Font + 1));
SkTDArray<SkFontID> seenFonts;
int notSubsettable = 0;
int notEmbeddable = 0;
for (int pageNumber = 0; pageNumber < fPages.count(); pageNumber++) {
const SkTDArray<SkPDFFont*>& fontResources =
fPages[pageNumber]->getFontResources();
for (int font = 0; font < fontResources.count(); font++) {
SkFontID fontID = fontResources[font]->typeface()->uniqueID();
if (seenFonts.find(fontID) == -1) {
counts[fontResources[font]->getType()]++;
seenFonts.push(fontID);
if (!fontResources[font]->canSubset()) {
notSubsettable++;
}
if (!fontResources[font]->canEmbed()) {
notEmbeddable++;
}
}
}
}
if (notSubsettableCount) {
*notSubsettableCount = notSubsettable;
}
if (notEmbeddableCount) {
*notEmbeddableCount = notEmbeddable;
}
} }
void SkPDFDocument::emitHeader(SkWStream* stream) { void SkPDFDocument::emitHeader(SkWStream* stream) {

85
src/pdf/SkPDFFont.cpp
View File

@ -749,24 +749,6 @@ SkAdvancedTypefaceMetrics::FontType SkPDFFont::getType() {
return fFontType; return fFontType;
} }
bool SkPDFFont::canEmbed() const {
if (!fFontInfo.get()) {
SkASSERT(fFontType == SkAdvancedTypefaceMetrics::kOther_Font);
return true;
}
return (fFontInfo->fFlags &
SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag) == 0;
}
bool SkPDFFont::canSubset() const {
if (!fFontInfo.get()) {
SkASSERT(fFontType == SkAdvancedTypefaceMetrics::kOther_Font);
return true;
}
return (fFontInfo->fFlags &
SkAdvancedTypefaceMetrics::kNotSubsettable_FontFlag) == 0;
}
bool SkPDFFont::hasGlyph(uint16_t id) { bool SkPDFFont::hasGlyph(uint16_t id) {
return (id >= fFirstGlyphID && id <= fLastGlyphID) || id == 0; return (id >= fFirstGlyphID && id <= fLastGlyphID) || id == 0;
} }
@ -815,7 +797,7 @@ SkPDFFont* SkPDFFont::GetFontResource(SkTypeface* typeface, uint16_t glyphID) {
// This only is to catch callers who pass invalid glyph ids. // This only is to catch callers who pass invalid glyph ids.
// If glyph id is invalid, then we will create duplicate entries // If glyph id is invalid, then we will create duplicate entries
// for TrueType fonts. // for True Type fonts.
SkAdvancedTypefaceMetrics::FontType fontType = SkAdvancedTypefaceMetrics::FontType fontType =
fontMetrics.get() ? fontMetrics.get()->fType : fontMetrics.get() ? fontMetrics.get()->fType :
SkAdvancedTypefaceMetrics::kOther_Font; SkAdvancedTypefaceMetrics::kOther_Font;
@ -895,8 +877,9 @@ SkPDFFont::SkPDFFont(SkAdvancedTypefaceMetrics* info, SkTypeface* typeface,
fLastGlyphID(info ? info->fLastGlyphID : 0), fLastGlyphID(info ? info->fLastGlyphID : 0),
fFontInfo(SkSafeRef(info)), fFontInfo(SkSafeRef(info)),
fDescriptor(SkSafeRef(relatedFontDescriptor)) { fDescriptor(SkSafeRef(relatedFontDescriptor)) {
if (info == NULL || if (info == NULL) {
info->fFlags & SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag) { fFontType = SkAdvancedTypefaceMetrics::kNotEmbeddable_Font;
} else if (info->fMultiMaster) {
fFontType = SkAdvancedTypefaceMetrics::kOther_Font; fFontType = SkAdvancedTypefaceMetrics::kOther_Font;
} else { } else {
fFontType = info->fType; fFontType = info->fType;
@ -908,10 +891,9 @@ SkPDFFont* SkPDFFont::Create(SkAdvancedTypefaceMetrics* info,
SkTypeface* typeface, uint16_t glyphID, SkTypeface* typeface, uint16_t glyphID,
SkPDFDict* relatedFontDescriptor) { SkPDFDict* relatedFontDescriptor) {
SkAdvancedTypefaceMetrics::FontType type = SkAdvancedTypefaceMetrics::FontType type =
info ? info->fType : SkAdvancedTypefaceMetrics::kOther_Font; info ? info->fType : SkAdvancedTypefaceMetrics::kNotEmbeddable_Font;
if (info && if (info && info->fMultiMaster) {
(info->fFlags & SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag)) {
NOT_IMPLEMENTED(true, true); NOT_IMPLEMENTED(true, true);
return new SkPDFType3Font(info, return new SkPDFType3Font(info,
typeface, typeface,
@ -930,7 +912,8 @@ SkPDFFont* SkPDFFont::Create(SkAdvancedTypefaceMetrics* info,
} }
SkASSERT(type == SkAdvancedTypefaceMetrics::kCFF_Font || SkASSERT(type == SkAdvancedTypefaceMetrics::kCFF_Font ||
type == SkAdvancedTypefaceMetrics::kOther_Font); type == SkAdvancedTypefaceMetrics::kOther_Font ||
type == SkAdvancedTypefaceMetrics::kNotEmbeddable_Font);
return new SkPDFType3Font(info, typeface, glyphID); return new SkPDFType3Font(info, typeface, glyphID);
} }
@ -1057,17 +1040,11 @@ SkPDFType0Font::SkPDFType0Font(SkAdvancedTypefaceMetrics* info,
SkTypeface* typeface) SkTypeface* typeface)
: SkPDFFont(info, typeface, NULL) { : SkPDFFont(info, typeface, NULL) {
SkDEBUGCODE(fPopulated = false); SkDEBUGCODE(fPopulated = false);
if (!canSubset()) {
populate(NULL);
}
} }
SkPDFType0Font::~SkPDFType0Font() {} SkPDFType0Font::~SkPDFType0Font() {}
SkPDFFont* SkPDFType0Font::getFontSubset(const SkPDFGlyphSet* subset) { SkPDFFont* SkPDFType0Font::getFontSubset(const SkPDFGlyphSet* subset) {
if (!canSubset()) {
return NULL;
}
SkPDFType0Font* newSubset = new SkPDFType0Font(fontInfo(), typeface()); SkPDFType0Font* newSubset = new SkPDFType0Font(fontInfo(), typeface());
newSubset->populate(subset); newSubset->populate(subset);
return newSubset; return newSubset;
@ -1116,34 +1093,19 @@ bool SkPDFCIDFont::addFontDescriptor(int16_t defaultWidth,
SkAutoTUnref<SkPDFDict> descriptor(new SkPDFDict("FontDescriptor")); SkAutoTUnref<SkPDFDict> descriptor(new SkPDFDict("FontDescriptor"));
setFontDescriptor(descriptor.get()); setFontDescriptor(descriptor.get());
addResource(descriptor.get()); addResource(descriptor.get());
insert("FontDescriptor", new SkPDFObjRef(descriptor.get()))->unref();
if (!addCommonFontDescriptorEntries(defaultWidth)) {
return false;
}
if (!canEmbed()) {
return true;
}
switch (getType()) { switch (getType()) {
case SkAdvancedTypefaceMetrics::kTrueType_Font: { case SkAdvancedTypefaceMetrics::kTrueType_Font: {
SkAutoTUnref<SkPDFStream> fontStream; SkASSERT(subset);
int fontSize = 0; // Font subsetting
if (canSubset()) { SkPDFStream* rawStream = NULL;
SkPDFStream* rawStream = NULL; int fontSize = get_subset_font_stream(fontInfo()->fFontName.c_str(),
fontSize = get_subset_font_stream(fontInfo()->fFontName.c_str(),
typeface(), typeface(),
*subset, *subset,
&rawStream); &rawStream);
fontStream.reset(rawStream);
} else {
int ttcIndex;
SkAutoTUnref<SkStream> fontData(
typeface()->openStream(&ttcIndex));
fontStream.reset(new SkPDFStream(fontData.get()));
fontSize = fontData->getLength();
}
SkASSERT(fontSize); SkASSERT(fontSize);
SkASSERT(fontStream.get()); SkASSERT(rawStream);
SkAutoTUnref<SkPDFStream> fontStream(rawStream);
addResource(fontStream.get()); addResource(fontStream.get());
fontStream->insertInt("Length1", fontSize); fontStream->insertInt("Length1", fontSize);
@ -1171,7 +1133,9 @@ bool SkPDFCIDFont::addFontDescriptor(int16_t defaultWidth,
default: default:
SkASSERT(false); SkASSERT(false);
} }
return true;
insert("FontDescriptor", new SkPDFObjRef(descriptor.get()))->unref();
return addCommonFontDescriptorEntries(defaultWidth);
} }
bool SkPDFCIDFont::populate(const SkPDFGlyphSet* subset) { bool SkPDFCIDFont::populate(const SkPDFGlyphSet* subset) {
@ -1287,15 +1251,12 @@ bool SkPDFType1Font::addFontDescriptor(int16_t defaultWidth) {
if (fontData == NULL) { if (fontData == NULL) {
return false; return false;
} }
if (canEmbed()) { SkAutoTUnref<SkPDFStream> fontStream(new SkPDFStream(fontData));
SkAutoTUnref<SkPDFStream> fontStream(new SkPDFStream(fontData)); addResource(fontStream.get());
addResource(fontStream.get()); fontStream->insertInt("Length1", header);
fontStream->insertInt("Length1", header); fontStream->insertInt("Length2", data);
fontStream->insertInt("Length2", data); fontStream->insertInt("Length3", trailer);
fontStream->insertInt("Length3", trailer); descriptor->insert("FontFile", new SkPDFObjRef(fontStream.get()))->unref();
descriptor->insert("FontFile",
new SkPDFObjRef(fontStream.get()))->unref();
}
addResource(descriptor.get()); addResource(descriptor.get());
insert("FontDescriptor", new SkPDFObjRef(descriptor.get()))->unref(); insert("FontDescriptor", new SkPDFObjRef(descriptor.get()))->unref();

13
src/pdf/SkPDFFont.h
View File

@ -99,14 +99,6 @@ public:
*/ */
virtual bool multiByteGlyphs() const = 0; virtual bool multiByteGlyphs() const = 0;
/** Returns true if the machine readable licensing bits allow embedding.
*/
bool canEmbed() const;
/** Returns true if the machine readable licensing bits allow subsetting.
*/
bool canSubset() const;
/** Return true if this font has an encoding for the passed glyph id. /** Return true if this font has an encoding for the passed glyph id.
*/ */
bool hasGlyph(uint16_t glyphID); bool hasGlyph(uint16_t glyphID);
@ -129,7 +121,8 @@ public:
* @param typeface The typeface to find. * @param typeface The typeface to find.
* @param glyphID Specify which section of a large font is of interest. * @param glyphID Specify which section of a large font is of interest.
*/ */
static SkPDFFont* GetFontResource(SkTypeface* typeface, uint16_t glyphID); static SkPDFFont* GetFontResource(SkTypeface* typeface,
uint16_t glyphID);
/** Subset the font based on usage set. Returns a SkPDFFont instance with /** Subset the font based on usage set. Returns a SkPDFFont instance with
* subset. * subset.
@ -195,6 +188,8 @@ private:
// this will be a subset if the font has more than 255 glyphs. // this will be a subset if the font has more than 255 glyphs.
uint16_t fFirstGlyphID; uint16_t fFirstGlyphID;
uint16_t fLastGlyphID; uint16_t fLastGlyphID;
// The font info is only kept around after construction for large
// Type1 (non CID) fonts that need multiple "fonts" to access all glyphs.
SkAutoTUnref<SkAdvancedTypefaceMetrics> fFontInfo; SkAutoTUnref<SkAdvancedTypefaceMetrics> fFontInfo;
SkTDArray<SkPDFObject*> fResources; SkTDArray<SkPDFObject*> fResources;
SkAutoTUnref<SkPDFDict> fDescriptor; SkAutoTUnref<SkPDFDict> fDescriptor;

36
src/ports/SkFontHost_FreeType.cpp
View File

@ -411,20 +411,6 @@ static bool canEmbed(FT_Face face) {
#endif #endif
} }
static bool canSubset(FT_Face face) {
#ifdef FT_FSTYPE_NO_SUBSETTING
FT_UShort fsType = FT_Get_FSType_Flags(face);
return (fsType & FT_FSTYPE_NO_SUBSETTING) == 0;
#else
// No subset is 0x100.
TT_OS2* os2_table;
if ((os2_table = (TT_OS2*)FT_Get_Sfnt_Table(face, ft_sfnt_os2)) != NULL) {
return (os2_table->fsType & 0x100) == 0;
}
return false; // We tried, fail safe.
#endif
}
static bool GetLetterCBox(FT_Face face, char letter, FT_BBox* bbox) { static bool GetLetterCBox(FT_Face face, char letter, FT_BBox* bbox) {
const FT_UInt glyph_id = FT_Get_Char_Index(face, letter); const FT_UInt glyph_id = FT_Get_Char_Index(face, letter);
if (!glyph_id) if (!glyph_id)
@ -509,21 +495,7 @@ SkAdvancedTypefaceMetrics* SkTypeface_FreeType::onGetAdvancedTypefaceMetrics(
SkAdvancedTypefaceMetrics* info = new SkAdvancedTypefaceMetrics; SkAdvancedTypefaceMetrics* info = new SkAdvancedTypefaceMetrics;
info->fFontName.set(FT_Get_Postscript_Name(face)); info->fFontName.set(FT_Get_Postscript_Name(face));
info->fFlags = SkAdvancedTypefaceMetrics::kEmpty_FontFlag; info->fMultiMaster = FT_HAS_MULTIPLE_MASTERS(face);
if (FT_HAS_MULTIPLE_MASTERS(face)) {
info->fFlags = SkTBitOr<SkAdvancedTypefaceMetrics::FontFlags>(
info->fFlags, SkAdvancedTypefaceMetrics::kMultiMaster_FontFlag);
}
if (!canEmbed(face)) {
info->fFlags = SkTBitOr<SkAdvancedTypefaceMetrics::FontFlags>(
info->fFlags,
SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag);
}
if (!canSubset(face)) {
info->fFlags = SkTBitOr<SkAdvancedTypefaceMetrics::FontFlags>(
info->fFlags,
SkAdvancedTypefaceMetrics::kNotSubsettable_FontFlag);
}
info->fLastGlyphID = face->num_glyphs - 1; info->fLastGlyphID = face->num_glyphs - 1;
info->fEmSize = 1000; info->fEmSize = 1000;
@ -616,7 +588,8 @@ SkAdvancedTypefaceMetrics* SkTypeface_FreeType::onGetAdvancedTypefaceMetrics(
info->fBBox = SkIRect::MakeLTRB(face->bbox.xMin, face->bbox.yMax, info->fBBox = SkIRect::MakeLTRB(face->bbox.xMin, face->bbox.yMax,
face->bbox.xMax, face->bbox.yMin); face->bbox.xMax, face->bbox.yMin);
if (!FT_IS_SCALABLE(face)) { if (!canEmbed(face) || !FT_IS_SCALABLE(face) ||
info->fType == SkAdvancedTypefaceMetrics::kOther_Font) {
perGlyphInfo = SkAdvancedTypefaceMetrics::kNo_PerGlyphInfo; perGlyphInfo = SkAdvancedTypefaceMetrics::kNo_PerGlyphInfo;
} }
@ -679,6 +652,9 @@ SkAdvancedTypefaceMetrics* SkTypeface_FreeType::onGetAdvancedTypefaceMetrics(
populate_glyph_to_unicode(face, &(info->fGlyphToUnicode)); populate_glyph_to_unicode(face, &(info->fGlyphToUnicode));
} }
if (!canEmbed(face))
info->fType = SkAdvancedTypefaceMetrics::kNotEmbeddable_Font;
return info; return info;
#endif #endif
} }

10
src/ports/SkFontHost_mac.cpp
View File

@ -1539,16 +1539,17 @@ SkAdvancedTypefaceMetrics* SkTypeface_Mac::onGetAdvancedTypefaceMetrics(
CFStringToSkString(fontName, &info->fFontName); CFStringToSkString(fontName, &info->fFontName);
} }
info->fMultiMaster = false;
CFIndex glyphCount = CTFontGetGlyphCount(ctFont); CFIndex glyphCount = CTFontGetGlyphCount(ctFont);
info->fLastGlyphID = SkToU16(glyphCount - 1); info->fLastGlyphID = SkToU16(glyphCount - 1);
info->fEmSize = CTFontGetUnitsPerEm(ctFont); info->fEmSize = CTFontGetUnitsPerEm(ctFont);
info->fFlags = SkAdvancedTypefaceMetrics::kEmpty_FontFlag;
info->fStyle = 0;
if (perGlyphInfo & SkAdvancedTypefaceMetrics::kToUnicode_PerGlyphInfo) { if (perGlyphInfo & SkAdvancedTypefaceMetrics::kToUnicode_PerGlyphInfo) {
populate_glyph_to_unicode(ctFont, glyphCount, &info->fGlyphToUnicode); populate_glyph_to_unicode(ctFont, glyphCount, &info->fGlyphToUnicode);
} }
info->fStyle = 0;
// If it's not a truetype font, mark it as 'other'. Assume that TrueType // If it's not a truetype font, mark it as 'other'. Assume that TrueType
// fonts always have both glyf and loca tables. At the least, this is what // fonts always have both glyf and loca tables. At the least, this is what
// sfntly needs to subset the font. CTFontCopyAttribute() does not always // sfntly needs to subset the font. CTFontCopyAttribute() does not always
@ -1612,7 +1613,10 @@ SkAdvancedTypefaceMetrics* SkTypeface_Mac::onGetAdvancedTypefaceMetrics(
} }
} }
if (perGlyphInfo & SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo) { if (false) { // TODO: haven't figured out how to know if font is embeddable
// (information is in the OS/2 table)
info->fType = SkAdvancedTypefaceMetrics::kNotEmbeddable_Font;
} else if (perGlyphInfo & SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo) {
if (info->fStyle & SkAdvancedTypefaceMetrics::kFixedPitch_Style) { if (info->fStyle & SkAdvancedTypefaceMetrics::kFixedPitch_Style) {
skia_advanced_typeface_metrics_utils::appendRange(&info->fGlyphWidths, 0); skia_advanced_typeface_metrics_utils::appendRange(&info->fGlyphWidths, 0);
info->fGlyphWidths->fAdvance.append(1, &min_width); info->fGlyphWidths->fAdvance.append(1, &min_width);

18
src/ports/SkFontHost_win.cpp
View File

@ -1851,18 +1851,10 @@ SkAdvancedTypefaceMetrics* LogFontTypeface::onGetAdvancedTypefaceMetrics(
info = new SkAdvancedTypefaceMetrics; info = new SkAdvancedTypefaceMetrics;
info->fEmSize = otm.otmEMSquare; info->fEmSize = otm.otmEMSquare;
info->fMultiMaster = false;
info->fLastGlyphID = SkToU16(glyphCount - 1); info->fLastGlyphID = SkToU16(glyphCount - 1);
info->fStyle = 0; info->fStyle = 0;
tchar_to_skstring(lf.lfFaceName, &info->fFontName); tchar_to_skstring(lf.lfFaceName, &info->fFontName);
info->fFlags = SkAdvancedTypefaceMetrics::kEmpty_FontFlag;
// If bit 1 is set, the font may not be embedded in a document.
// If bit 1 is clear, the font can be embedded.
// If bit 2 is set, the embedding is read-only.
if (otm.otmfsType & 0x1) {
info->fFlags = SkTBitOr<SkAdvancedTypefaceMetrics::FontFlags>(
info->fFlags,
SkAdvancedTypefaceMetrics::kNotEmbeddable_FontFlag);
}
if (perGlyphInfo & SkAdvancedTypefaceMetrics::kToUnicode_PerGlyphInfo) { if (perGlyphInfo & SkAdvancedTypefaceMetrics::kToUnicode_PerGlyphInfo) {
populate_glyph_to_unicode(hdc, glyphCount, &(info->fGlyphToUnicode)); populate_glyph_to_unicode(hdc, glyphCount, &(info->fGlyphToUnicode));
@ -1923,7 +1915,13 @@ SkAdvancedTypefaceMetrics* LogFontTypeface::onGetAdvancedTypefaceMetrics(
} }
} }
if (perGlyphInfo & SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo) { // If bit 1 is set, the font may not be embedded in a document.
// If bit 1 is clear, the font can be embedded.
// If bit 2 is set, the embedding is read-only.
if (otm.otmfsType & 0x1) {
info->fType = SkAdvancedTypefaceMetrics::kNotEmbeddable_Font;
} else if (perGlyphInfo &
SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo) {
if (info->fStyle & SkAdvancedTypefaceMetrics::kFixedPitch_Style) { if (info->fStyle & SkAdvancedTypefaceMetrics::kFixedPitch_Style) {
appendRange(&info->fGlyphWidths, 0); appendRange(&info->fGlyphWidths, 0);
info->fGlyphWidths->fAdvance.append(1, &min_width); info->fGlyphWidths->fAdvance.append(1, &min_width);

10
src/ports/SkFontHost_win_dw.cpp
View File

@ -1490,9 +1490,10 @@ SkAdvancedTypefaceMetrics* DWriteFontTypeface::onGetAdvancedTypefaceMetrics(
info = new SkAdvancedTypefaceMetrics; info = new SkAdvancedTypefaceMetrics;
info->fEmSize = dwfm.designUnitsPerEm; info->fEmSize = dwfm.designUnitsPerEm;
info->fMultiMaster = false;
info->fLastGlyphID = SkToU16(glyphCount - 1); info->fLastGlyphID = SkToU16(glyphCount - 1);
info->fStyle = 0; info->fStyle = 0;
info->fFlags = SkAdvancedTypefaceMetrics::kEmpty_FontFlag;
SkTScopedComPtr<IDWriteLocalizedStrings> familyNames; SkTScopedComPtr<IDWriteLocalizedStrings> familyNames;
SkTScopedComPtr<IDWriteLocalizedStrings> faceNames; SkTScopedComPtr<IDWriteLocalizedStrings> faceNames;
@ -1600,7 +1601,12 @@ SkAdvancedTypefaceMetrics* DWriteFontTypeface::onGetAdvancedTypefaceMetrics(
} }
*/ */
if (perGlyphInfo & SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo) { // If Restricted, the font may not be embedded in a document.
// If not Restricted, the font can be embedded.
// If PreviewPrint, the embedding is read-only.
if (os2Table->version.v0.fsType.field.Restricted) {
info->fType = SkAdvancedTypefaceMetrics::kNotEmbeddable_Font;
} else if (perGlyphInfo & SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo) {
if (fixedWidth) { if (fixedWidth) {
appendRange(&info->fGlyphWidths, 0); appendRange(&info->fGlyphWidths, 0);
int16_t advance; int16_t advance;