/*
|
* Copyright 2015 Google Inc.
|
*
|
* Use of this source code is governed by a BSD-style license that can be
|
* found in the LICENSE file.
|
*/
|
|
#include "SkFontDescriptor.h"
|
#include "SkOpts.h"
|
#include "SkStream.h"
|
#include "SkString.h"
|
#include "SkTypeface.h"
|
#include "SkUTF.h"
|
#include "../sfnt/SkOTUtils.h"
|
|
#include "SkWhitelistChecksums.inc"
|
|
#define WHITELIST_DEBUG 0
|
|
extern void WhitelistSerializeTypeface(const SkTypeface*, SkWStream* );
|
sk_sp<SkTypeface> WhitelistDeserializeTypeface(SkStream* );
|
extern bool CheckChecksums();
|
extern bool GenerateChecksums();
|
|
#if WHITELIST_DEBUG
|
static bool timesNewRomanSerializedNameOnly = false;
|
#endif
|
|
#define SUBNAME_PREFIX "sk_"
|
|
static bool font_name_is_local(const char* fontName, SkFontStyle style) {
|
if (!strcmp(fontName, "DejaVu Sans")) {
|
return true;
|
}
|
sk_sp<SkTypeface> defaultFace(SkTypeface::MakeFromName(nullptr, style));
|
sk_sp<SkTypeface> foundFace(SkTypeface::MakeFromName(fontName, style));
|
return defaultFace != foundFace;
|
}
|
|
static int whitelist_name_index(const SkTypeface* tf) {
|
|
SkString fontNameStr;
|
sk_sp<SkTypeface::LocalizedStrings> nameIter =
|
SkOTUtils::LocalizedStrings_NameTable::MakeForFamilyNames(*tf);
|
SkTypeface::LocalizedString familyNameLocalized;
|
while (nameIter->next(&familyNameLocalized)) {
|
fontNameStr = familyNameLocalized.fString;
|
// check against permissible list of names
|
for (int i = 0; i < whitelistCount; ++i) {
|
if (fontNameStr.equals(whitelist[i].fFontName)) {
|
return i;
|
}
|
}
|
}
|
#if WHITELIST_DEBUG
|
sk_sp<SkTypeface::LocalizedStrings> debugIter =
|
SkOTUtils::LocalizedStrings_NameTable::MakeForFamilyNames(*tf);
|
while (debugIter->next(&familyNameLocalized)) {
|
SkDebugf("no match fontName=\"%s\"\n", familyNameLocalized.fString.c_str());
|
}
|
#endif
|
return -1;
|
}
|
|
static uint32_t compute_checksum(const SkTypeface* tf) {
|
std::unique_ptr<SkFontData> fontData = tf->makeFontData();
|
if (!fontData) {
|
return 0;
|
}
|
SkStreamAsset* fontStream = fontData->getStream();
|
if (!fontStream) {
|
return 0;
|
}
|
SkTDArray<char> data;
|
size_t length = fontStream->getLength();
|
if (!length) {
|
return 0;
|
}
|
data.setCount((int) length);
|
if (!fontStream->peek(data.begin(), length)) {
|
return 0;
|
}
|
return SkOpts::hash(data.begin(), length);
|
}
|
|
static void serialize_sub(const char* fontName, SkFontStyle style, SkWStream* wstream) {
|
SkFontDescriptor desc;
|
SkString subName(SUBNAME_PREFIX);
|
subName.append(fontName);
|
const char* familyName = subName.c_str();
|
desc.setFamilyName(familyName);
|
desc.setStyle(style);
|
desc.serialize(wstream);
|
#if WHITELIST_DEBUG
|
for (int i = 0; i < whitelistCount; ++i) {
|
if (!strcmp(fontName, whitelist[i].fFontName)) {
|
if (!whitelist[i].fSerializedSub) {
|
whitelist[i].fSerializedSub = true;
|
SkDebugf("%s %s\n", __FUNCTION__, familyName);
|
}
|
break;
|
}
|
}
|
#endif
|
}
|
|
static bool is_local(const SkTypeface* tf) {
|
bool isLocal = false;
|
SkFontDescriptor desc;
|
tf->getFontDescriptor(&desc, &isLocal);
|
return isLocal;
|
}
|
|
static void serialize_full(const SkTypeface* tf, SkWStream* wstream) {
|
bool isLocal = false;
|
SkFontDescriptor desc;
|
tf->getFontDescriptor(&desc, &isLocal);
|
|
// Embed font data if it's a local font.
|
if (isLocal && !desc.hasFontData()) {
|
desc.setFontData(tf->makeFontData());
|
}
|
desc.serialize(wstream);
|
}
|
|
static void serialize_name_only(const SkTypeface* tf, SkWStream* wstream) {
|
bool isLocal = false;
|
SkFontDescriptor desc;
|
tf->getFontDescriptor(&desc, &isLocal);
|
SkASSERT(!isLocal);
|
#if WHITELIST_DEBUG
|
const char* familyName = desc.getFamilyName();
|
if (familyName) {
|
if (!strcmp(familyName, "Times New Roman")) {
|
if (!timesNewRomanSerializedNameOnly) {
|
timesNewRomanSerializedNameOnly = true;
|
SkDebugf("%s %s\n", __FUNCTION__, familyName);
|
}
|
} else {
|
for (int i = 0; i < whitelistCount; ++i) {
|
if (!strcmp(familyName, whitelist[i].fFontName)) {
|
if (!whitelist[i].fSerializedNameOnly) {
|
whitelist[i].fSerializedNameOnly = true;
|
SkDebugf("%s %s\n", __FUNCTION__, familyName);
|
}
|
break;
|
}
|
}
|
}
|
}
|
#endif
|
desc.serialize(wstream);
|
}
|
|
void WhitelistSerializeTypeface(const SkTypeface* tf, SkWStream* wstream) {
|
if (!is_local(tf)) {
|
serialize_name_only(tf, wstream);
|
return;
|
}
|
int whitelistIndex = whitelist_name_index(tf);
|
if (whitelistIndex < 0) {
|
serialize_full(tf, wstream);
|
return;
|
}
|
const char* fontName = whitelist[whitelistIndex].fFontName;
|
if (!font_name_is_local(fontName, tf->fontStyle())) {
|
#if WHITELIST_DEBUG
|
SkDebugf("name not found locally \"%s\" style=%d\n", fontName, tf->style());
|
#endif
|
serialize_full(tf, wstream);
|
return;
|
}
|
uint32_t checksum = compute_checksum(tf);
|
if (whitelist[whitelistIndex].fChecksum != checksum) {
|
#if WHITELIST_DEBUG
|
if (whitelist[whitelistIndex].fChecksum) {
|
SkDebugf("!!! checksum changed !!!\n");
|
}
|
SkDebugf("checksum updated\n");
|
SkDebugf(" { \"%s\", 0x%08x },\n", fontName, checksum);
|
#endif
|
whitelist[whitelistIndex].fChecksum = checksum;
|
}
|
serialize_sub(fontName, tf->fontStyle(), wstream);
|
}
|
|
sk_sp<SkTypeface> WhitelistDeserializeTypeface(SkStream* stream) {
|
SkFontDescriptor desc;
|
if (!SkFontDescriptor::Deserialize(stream, &desc)) {
|
return nullptr;
|
}
|
|
std::unique_ptr<SkFontData> data = desc.detachFontData();
|
if (data) {
|
sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFontData(std::move(data)));
|
if (typeface) {
|
return typeface;
|
}
|
}
|
const char* familyName = desc.getFamilyName();
|
if (!strncmp(SUBNAME_PREFIX, familyName, sizeof(SUBNAME_PREFIX) - 1)) {
|
familyName += sizeof(SUBNAME_PREFIX) - 1;
|
}
|
return SkTypeface::MakeFromName(familyName, desc.getStyle());
|
}
|
|
bool CheckChecksums() {
|
for (int i = 0; i < whitelistCount; ++i) {
|
const char* fontName = whitelist[i].fFontName;
|
sk_sp<SkTypeface> tf(SkTypeface::MakeFromName(fontName, SkFontStyle()));
|
uint32_t checksum = compute_checksum(tf.get());
|
if (whitelist[i].fChecksum != checksum) {
|
return false;
|
}
|
}
|
return true;
|
}
|
|
const char checksumFileName[] = "SkWhitelistChecksums.inc";
|
|
const char checksumHeader[] =
|
"/*" "\n"
|
" * Copyright 2015 Google Inc." "\n"
|
" *" "\n"
|
" * Use of this source code is governed by a BSD-style license that can be" "\n"
|
" * found in the LICENSE file." "\n"
|
" *" "\n"
|
" * %s() in %s generated %s." "\n"
|
" * Run 'whitelist_typefaces --generate' to create anew." "\n"
|
" */" "\n"
|
"" "\n"
|
"#include \"SkTDArray.h\"" "\n"
|
"" "\n"
|
"struct Whitelist {" "\n"
|
" const char* fFontName;" "\n"
|
" uint32_t fChecksum;" "\n"
|
" bool fSerializedNameOnly;" "\n"
|
" bool fSerializedSub;" "\n"
|
"};" "\n"
|
"" "\n"
|
"static Whitelist whitelist[] = {" "\n";
|
|
const char checksumEntry[] =
|
" { \"%s\", 0x%08x, false, false }," "\n";
|
|
const char checksumTrailer[] =
|
"};" "\n"
|
"" "\n"
|
"static const int whitelistCount = (int) SK_ARRAY_COUNT(whitelist);" "\n";
|
|
|
#include "SkOSFile.h"
|
|
bool GenerateChecksums() {
|
FILE* file = sk_fopen(checksumFileName, kWrite_SkFILE_Flag);
|
if (!file) {
|
SkDebugf("Can't open %s for writing.\n", checksumFileName);
|
return false;
|
}
|
SkString line;
|
line.printf(checksumHeader, __FUNCTION__, __FILE__, checksumFileName);
|
sk_fwrite(line.c_str(), line.size(), file);
|
for (int i = 0; i < whitelistCount; ++i) {
|
const char* fontName = whitelist[i].fFontName;
|
sk_sp<SkTypeface> tf(SkTypeface::MakeFromName(fontName, SkFontStyle()));
|
uint32_t checksum = compute_checksum(tf.get());
|
line.printf(checksumEntry, fontName, checksum);
|
sk_fwrite(line.c_str(), line.size(), file);
|
}
|
sk_fwrite(checksumTrailer, sizeof(checksumTrailer) - 1, file);
|
sk_fclose(file);
|
return true;
|
}
|
