Revert of SkFontMgr for Android. (https://codereview.chromium.org/414483002/)
Reason for revert: Reverting to unblock DEPS roll. Original issue's description: > SkFontMgr for Android. > > Committed: https://skia.googlesource.com/skia/+/4f9a01e03ef3bbe7dd8f9bebdcb3555226087e06 R=djsollen@google.com, tomhudson@google.com, bungeman@google.com TBR=bungeman@google.com, djsollen@google.com, tomhudson@google.com NOTREECHECKS=true NOTRY=true Author: robertphillips@google.com Review URL: https://codereview.chromium.org/408143010
This commit is contained in:
robertphillips
Commit bot
parent
ba0055b290
commit
7b82d0f8e6
@ -185,7 +185,6 @@
|
||||
'../src/ports/SkFontConfigInterface_android.cpp',
|
||||
'../src/ports/SkFontConfigParser_android.cpp',
|
||||
'../src/ports/SkFontHost_fontconfig.cpp',
|
||||
'../src/ports/SkFontMgr_android.cpp',
|
||||
],
|
||||
'dependencies': [
|
||||
'android_deps.gyp:expat',
|
||||
|
||||
@ -907,3 +907,8 @@ SkTypeface* SkCreateTypefaceForScript(hb_script_t script, SkTypeface::Style styl
|
||||
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
SkFontMgr* SkFontMgr::Factory() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -7,15 +7,12 @@
|
||||
|
||||
#include "SkFontConfigParser_android.h"
|
||||
#include "SkTDArray.h"
|
||||
#include "SkTSearch.h"
|
||||
#include "SkTypeface.h"
|
||||
|
||||
#include <expat.h>
|
||||
#include <stdio.h>
|
||||
#include <sys/system_properties.h>
|
||||
|
||||
#include <limits>
|
||||
|
||||
#define SYSTEM_FONTS_FILE "/system/etc/system_fonts.xml"
|
||||
#define FALLBACK_FONTS_FILE "/system/etc/fallback_fonts.xml"
|
||||
#define VENDOR_FONTS_FILE "/vendor/etc/fallback_fonts.xml"
|
||||
@ -51,14 +48,13 @@ struct FamilyData {
|
||||
* or file tag. The resulting strings are put into the fNames or FontFileInfo arrays.
|
||||
*/
|
||||
static void textHandler(void *data, const char *s, int len) {
|
||||
SkAutoAsciiToLC tolc(s);
|
||||
FamilyData *familyData = (FamilyData*) data;
|
||||
// Make sure we're in the right state to store this name information
|
||||
if (familyData->currentFamily &&
|
||||
(familyData->currentTag == NAMESET_TAG || familyData->currentTag == FILESET_TAG)) {
|
||||
switch (familyData->currentTag) {
|
||||
case NAMESET_TAG:
|
||||
familyData->currentFamily->fNames.push_back().set(tolc.lc(), len);
|
||||
familyData->currentFamily->fNames.push_back().set(s, len);
|
||||
break;
|
||||
case FILESET_TAG:
|
||||
if (familyData->currentFontInfo) {
|
||||
@ -72,28 +68,6 @@ static void textHandler(void *data, const char *s, int len) {
|
||||
}
|
||||
}
|
||||
|
||||
/** http://www.w3.org/TR/html-markup/datatypes.html#common.data.integer.non-negative-def */
|
||||
template <typename T> static bool parseNonNegativeInteger(const char* s, T* value) {
|
||||
SK_COMPILE_ASSERT(std::numeric_limits<T>::is_integer, T_must_be_integer);
|
||||
const T nMax = std::numeric_limits<T>::max() / 10;
|
||||
const T dMax = std::numeric_limits<T>::max() - (nMax * 10);
|
||||
T n = 0;
|
||||
for (; *s; ++s) {
|
||||
// Check if digit
|
||||
if (*s < '0' || '9' < *s) {
|
||||
return false;
|
||||
}
|
||||
int d = *s - '0';
|
||||
// Check for overflow
|
||||
if (n > nMax || (n == nMax && d > dMax)) {
|
||||
return false;
|
||||
}
|
||||
n = (n * 10) + d;
|
||||
}
|
||||
*value = n;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Handler for font files. This processes the attributes for language and
|
||||
* variants then lets textHandler handle the actual file name
|
||||
@ -116,13 +90,6 @@ static void fontFileElementHandler(FamilyData *familyData, const char **attribut
|
||||
}
|
||||
} else if (strncmp(attributeName, "lang", nameLength) == 0) {
|
||||
newFileInfo.fPaintOptions.setLanguage(attributeValue);
|
||||
} else if (strncmp(attributeName, "index", nameLength) == 0) {
|
||||
int value;
|
||||
if (parseNonNegativeInteger(attributeValue, &value)) {
|
||||
newFileInfo.fIndex = value;
|
||||
} else {
|
||||
SkDebugf("---- SystemFonts index=%s (INVALID)", attributeValue);
|
||||
}
|
||||
}
|
||||
//each element is a pair of attributeName/attributeValue string pairs
|
||||
currentAttributeIndex += 2;
|
||||
|
||||
@ -15,10 +15,7 @@
|
||||
#include "SkTDArray.h"
|
||||
|
||||
struct FontFileInfo {
|
||||
FontFileInfo() : fIndex(0) { }
|
||||
|
||||
SkString fFileName;
|
||||
int fIndex;
|
||||
SkPaintOptionsAndroid fPaintOptions;
|
||||
};
|
||||
|
||||
|
||||
@ -1,409 +0,0 @@
|
||||
/*
|
||||
* Copyright 2014 Google Inc.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license that can be
|
||||
* found in the LICENSE file.
|
||||
*/
|
||||
|
||||
#include "SkFontConfigParser_android.h"
|
||||
#include "SkFontDescriptor.h"
|
||||
#include "SkFontHost_FreeType_common.h"
|
||||
#include "SkFontMgr.h"
|
||||
#include "SkFontStyle.h"
|
||||
#include "SkStream.h"
|
||||
#include "SkTDArray.h"
|
||||
#include "SkTSearch.h"
|
||||
#include "SkTypeface.h"
|
||||
#include "SkTypefaceCache.h"
|
||||
|
||||
#include <limits>
|
||||
#include <stdlib.h>
|
||||
|
||||
#ifndef SK_FONT_FILE_PREFIX
|
||||
# define SK_FONT_FILE_PREFIX "/fonts/"
|
||||
#endif
|
||||
|
||||
#ifndef SK_DEBUG_FONTS
|
||||
#define SK_DEBUG_FONTS 0
|
||||
#endif
|
||||
|
||||
#if SK_DEBUG_FONTS
|
||||
# define DEBUG_FONT(args) SkDebugf args
|
||||
#else
|
||||
# define DEBUG_FONT(args)
|
||||
#endif
|
||||
|
||||
class SkTypeface_Android : public SkTypeface_FreeType {
|
||||
public:
|
||||
SkTypeface_Android(int index,
|
||||
Style style,
|
||||
bool isFixedPitch,
|
||||
const SkString familyName)
|
||||
: INHERITED(style, SkTypefaceCache::NewFontID(), isFixedPitch)
|
||||
, fIndex(index)
|
||||
, fFamilyName(familyName)
|
||||
{ }
|
||||
|
||||
const SkString& name() const { return fFamilyName; }
|
||||
|
||||
protected:
|
||||
int fIndex;
|
||||
SkString fFamilyName;
|
||||
|
||||
private:
|
||||
typedef SkTypeface_FreeType INHERITED;
|
||||
};
|
||||
|
||||
class SkTypeface_AndroidSystem : public SkTypeface_Android {
|
||||
public:
|
||||
SkTypeface_AndroidSystem(const SkString pathName,
|
||||
int index,
|
||||
Style style,
|
||||
bool isFixedPitch,
|
||||
const SkString familyName)
|
||||
: INHERITED(index, style, isFixedPitch, familyName)
|
||||
, fPathName(pathName)
|
||||
{ }
|
||||
|
||||
virtual void onGetFontDescriptor(SkFontDescriptor* desc,
|
||||
bool* serialize) const SK_OVERRIDE
|
||||
{
|
||||
SkASSERT(desc);
|
||||
SkASSERT(serialize);
|
||||
desc->setFamilyName(fFamilyName.c_str());
|
||||
desc->setFontFileName(fPathName.c_str());
|
||||
*serialize = false;
|
||||
}
|
||||
virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
|
||||
*ttcIndex = fIndex;
|
||||
return SkStream::NewFromFile(fPathName.c_str());
|
||||
}
|
||||
|
||||
private:
|
||||
SkString fPathName;
|
||||
|
||||
typedef SkTypeface_Android INHERITED;
|
||||
};
|
||||
|
||||
class SkTypeface_AndroidStream : public SkTypeface_Android {
|
||||
public:
|
||||
SkTypeface_AndroidStream(SkStream* stream,
|
||||
int index,
|
||||
Style style,
|
||||
bool isFixedPitch,
|
||||
const SkString familyName)
|
||||
: INHERITED(index, style, isFixedPitch, familyName)
|
||||
, fStream(stream)
|
||||
{ }
|
||||
|
||||
virtual void onGetFontDescriptor(SkFontDescriptor* desc,
|
||||
bool* serialize) const SK_OVERRIDE {
|
||||
SkASSERT(desc);
|
||||
SkASSERT(serialize);
|
||||
desc->setFamilyName(fFamilyName.c_str());
|
||||
desc->setFontFileName(NULL);
|
||||
*serialize = true;
|
||||
}
|
||||
|
||||
virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
|
||||
*ttcIndex = fIndex;
|
||||
return fStream->duplicate();
|
||||
}
|
||||
|
||||
private:
|
||||
SkAutoTUnref<SkStream> fStream;
|
||||
|
||||
typedef SkTypeface_Android INHERITED;
|
||||
};
|
||||
|
||||
void get_path_for_sys_fonts(SkString* full, const SkString& name) {
|
||||
full->set(getenv("ANDROID_ROOT"));
|
||||
full->append(SK_FONT_FILE_PREFIX);
|
||||
full->append(name);
|
||||
}
|
||||
|
||||
class SkFontStyleSet_Android : public SkFontStyleSet {
|
||||
public:
|
||||
explicit SkFontStyleSet_Android(FontFamily* family) : fFontFamily(family) {
|
||||
// TODO? make this lazy
|
||||
for (int i = 0; i < family->fFontFiles.count(); ++i) {
|
||||
const SkString& fileName = family->fFontFiles[i].fFileName;
|
||||
|
||||
SkString pathName;
|
||||
get_path_for_sys_fonts(&pathName, fileName);
|
||||
|
||||
SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(pathName.c_str()));
|
||||
if (!stream.get()) {
|
||||
DEBUG_FONT(("---- SystemFonts[%d] file=%s (NOT EXIST)", i, filename.c_str()));
|
||||
continue;
|
||||
}
|
||||
|
||||
SkString fontName;
|
||||
SkTypeface::Style style;
|
||||
bool isFixedWidth;
|
||||
if (!SkTypeface_FreeType::ScanFont(stream.get(), family->fFontFiles[i].fIndex,
|
||||
&fontName, &style, &isFixedWidth))
|
||||
{
|
||||
DEBUG_FONT(("---- SystemFonts[%d] file=%s (INVALID)", i, filename.c_str()));
|
||||
continue;
|
||||
}
|
||||
|
||||
fStyles.push_back().reset(SkNEW_ARGS(SkTypeface_AndroidSystem,
|
||||
(pathName, 0,
|
||||
style, isFixedWidth, fontName)));
|
||||
}
|
||||
}
|
||||
|
||||
virtual int count() SK_OVERRIDE {
|
||||
return fStyles.count();
|
||||
}
|
||||
virtual void getStyle(int index, SkFontStyle* style, SkString* name) SK_OVERRIDE {
|
||||
if (index < 0 || fStyles.count() <= index) {
|
||||
return;
|
||||
}
|
||||
if (style) {
|
||||
*style = this->style(index);
|
||||
}
|
||||
if (name) {
|
||||
name->reset();
|
||||
}
|
||||
}
|
||||
virtual SkTypeface* createTypeface(int index) SK_OVERRIDE {
|
||||
if (index < 0 || fStyles.count() <= index) {
|
||||
return NULL;
|
||||
}
|
||||
return SkRef(fStyles[index].get());
|
||||
}
|
||||
|
||||
/** Find the typeface in this style set that most closely matches the given pattern.
|
||||
* TODO: consider replacing with SkStyleSet_Indirect::matchStyle();
|
||||
* this simpler version using match_score() passes all our tests.
|
||||
*/
|
||||
virtual SkTypeface* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE {
|
||||
if (0 == fStyles.count()) {
|
||||
return NULL;
|
||||
}
|
||||
SkTypeface* closest = fStyles[0];
|
||||
int minScore = std::numeric_limits<int>::max();
|
||||
for (int i = 0; i < fStyles.count(); ++i) {
|
||||
SkFontStyle style = this->style(i);
|
||||
int score = match_score(pattern, style);
|
||||
if (score < minScore) {
|
||||
closest = fStyles[i];
|
||||
minScore = score;
|
||||
}
|
||||
}
|
||||
return SkRef(closest);
|
||||
}
|
||||
|
||||
private:
|
||||
SkFontStyle style(int index) {
|
||||
return SkFontStyle(this->weight(index), SkFontStyle::kNormal_Width,
|
||||
this->slant(index));
|
||||
}
|
||||
SkFontStyle::Weight weight(int index) {
|
||||
if (fStyles[index]->isBold()) return SkFontStyle::kBold_Weight;
|
||||
return SkFontStyle::kNormal_Weight;
|
||||
}
|
||||
SkFontStyle::Slant slant(int index) {
|
||||
if (fStyles[index]->isItalic()) return SkFontStyle::kItalic_Slant;
|
||||
return SkFontStyle::kUpright_Slant;
|
||||
}
|
||||
static int match_score(const SkFontStyle& pattern, const SkFontStyle& candidate) {
|
||||
int score = 0;
|
||||
score += abs((pattern.width() - candidate.width()) * 100);
|
||||
score += abs((pattern.isItalic() == candidate.isItalic()) ? 0 : 1000);
|
||||
score += abs(pattern.weight() - candidate.weight());
|
||||
return score;
|
||||
}
|
||||
|
||||
|
||||
FontFamily* fFontFamily;
|
||||
SkTArray<SkAutoTUnref<SkTypeface>, true> fStyles;
|
||||
|
||||
friend struct NameToFamily;
|
||||
friend class SkFontMgr_Android;
|
||||
|
||||
typedef SkFontStyleSet INHERITED;
|
||||
};
|
||||
|
||||
/** On Android a single family can have many names, but our API assumes unique names.
|
||||
* Map names to the back end so that all names for a given family refer to the same
|
||||
* (non-replicated) set of typefaces.
|
||||
* SkTDict<> doesn't let us do index-based lookup, so we write our own mapping.
|
||||
*/
|
||||
struct NameToFamily {
|
||||
SkString name;
|
||||
SkFontStyleSet_Android* styleSet;
|
||||
};
|
||||
|
||||
class SkFontMgr_Android : public SkFontMgr {
|
||||
public:
|
||||
SkFontMgr_Android() {
|
||||
SkTDArray<FontFamily*> fontFamilies;
|
||||
SkFontConfigParser::GetFontFamilies(fontFamilies);
|
||||
this->buildNameToFamilyMap(fontFamilies);
|
||||
this->findDefaultFont();
|
||||
}
|
||||
|
||||
protected:
|
||||
/** Returns not how many families we have, but how many unique names
|
||||
* exist among the families.
|
||||
*/
|
||||
virtual int onCountFamilies() const SK_OVERRIDE {
|
||||
return fNameToFamilyMap.count();
|
||||
}
|
||||
|
||||
virtual void onGetFamilyName(int index, SkString* familyName) const SK_OVERRIDE {
|
||||
if (index < 0 || fNameToFamilyMap.count() <= index) {
|
||||
familyName->reset();
|
||||
return;
|
||||
}
|
||||
familyName->set(fNameToFamilyMap[index].name);
|
||||
}
|
||||
|
||||
virtual SkFontStyleSet* onCreateStyleSet(int index) const SK_OVERRIDE {
|
||||
if (index < 0 || fNameToFamilyMap.count() <= index) {
|
||||
return NULL;
|
||||
}
|
||||
return SkRef(fNameToFamilyMap[index].styleSet);
|
||||
}
|
||||
|
||||
virtual SkFontStyleSet* onMatchFamily(const char familyName[]) const SK_OVERRIDE {
|
||||
if (!familyName) {
|
||||
return NULL;
|
||||
}
|
||||
SkAutoAsciiToLC tolc(familyName);
|
||||
for (int i = 0; i < fNameToFamilyMap.count(); ++i) {
|
||||
if (fNameToFamilyMap[i].name.equals(tolc.lc())) {
|
||||
return SkRef(fNameToFamilyMap[i].styleSet);
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
|
||||
const SkFontStyle& style) const SK_OVERRIDE {
|
||||
SkAutoTUnref<SkFontStyleSet> sset(this->matchFamily(familyName));
|
||||
return sset->matchStyle(style);
|
||||
}
|
||||
|
||||
virtual SkTypeface* onMatchFaceStyle(const SkTypeface* typeface,
|
||||
const SkFontStyle& style) const SK_OVERRIDE {
|
||||
for (int i = 0; i < fFontStyleSets.count(); ++i) {
|
||||
for (int j = 0; j < fFontStyleSets[i]->fStyles.count(); ++j) {
|
||||
if (fFontStyleSets[i]->fStyles[j] == typeface) {
|
||||
return fFontStyleSets[i]->matchStyle(style);
|
||||
}
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
virtual SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const SK_OVERRIDE {
|
||||
SkAutoTUnref<SkStream> stream(new SkMemoryStream(data));
|
||||
return this->createFromStream(stream, ttcIndex);
|
||||
}
|
||||
|
||||
virtual SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE {
|
||||
SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
|
||||
return stream.get() ? this->createFromStream(stream, ttcIndex) : NULL;
|
||||
}
|
||||
|
||||
virtual SkTypeface* onCreateFromStream(SkStream* s, int ttcIndex) const SK_OVERRIDE {
|
||||
SkAutoTUnref<SkStream> stream(s);
|
||||
|
||||
bool isFixedPitch;
|
||||
SkTypeface::Style style;
|
||||
SkString name;
|
||||
if (!SkTypeface_FreeType::ScanFont(stream, ttcIndex, &name, &style, &isFixedPitch)) {
|
||||
return NULL;
|
||||
}
|
||||
return SkNEW_ARGS(SkTypeface_AndroidStream, (stream.detach(), ttcIndex,
|
||||
style, isFixedPitch, name));
|
||||
}
|
||||
|
||||
|
||||
virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
|
||||
unsigned styleBits) const SK_OVERRIDE {
|
||||
SkTypeface::Style oldStyle = (SkTypeface::Style)styleBits;
|
||||
SkFontStyle style = SkFontStyle(oldStyle & SkTypeface::kBold
|
||||
? SkFontStyle::kBold_Weight
|
||||
: SkFontStyle::kNormal_Weight,
|
||||
SkFontStyle::kNormal_Width,
|
||||
oldStyle & SkTypeface::kItalic
|
||||
? SkFontStyle::kItalic_Slant
|
||||
: SkFontStyle::kUpright_Slant);
|
||||
SkTypeface* tf = NULL;
|
||||
|
||||
if (NULL != familyName) {
|
||||
// On Android, we must return NULL when we can't find the requested
|
||||
// named typeface so that the system/app can provide their own recovery
|
||||
// mechanism. On other platforms we'd provide a typeface from the
|
||||
// default family instead.
|
||||
tf = this->onMatchFamilyStyle(familyName, style);
|
||||
} else {
|
||||
tf = fDefaultFamily->matchStyle(style);
|
||||
}
|
||||
|
||||
// TODO: double ref? qv matchStyle()
|
||||
return SkSafeRef(tf);
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
SkTArray<SkAutoTUnref<SkFontStyleSet_Android>, true> fFontStyleSets;
|
||||
SkFontStyleSet* fDefaultFamily;
|
||||
SkTypeface* fDefaultTypeface;
|
||||
|
||||
SkTDArray<NameToFamily> fNameToFamilyMap;
|
||||
|
||||
void buildNameToFamilyMap(SkTDArray<FontFamily*> families) {
|
||||
for (int i = 0; i < families.count(); i++) {
|
||||
fFontStyleSets.push_back().reset(
|
||||
SkNEW_ARGS(SkFontStyleSet_Android, (families[i])));
|
||||
for (int j = 0; j < families[i]->fNames.count(); j++) {
|
||||
NameToFamily* nextEntry = fNameToFamilyMap.append();
|
||||
SkNEW_PLACEMENT_ARGS(&nextEntry->name, SkString, (families[i]->fNames[j]));
|
||||
nextEntry->styleSet = fFontStyleSets.back().get();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void findDefaultFont() {
|
||||
SkASSERT(!fFontStyleSets.empty());
|
||||
|
||||
static const char* gDefaultNames[] = { "sans-serif" };
|
||||
for (size_t i = 0; i < SK_ARRAY_COUNT(gDefaultNames); ++i) {
|
||||
SkFontStyleSet* set = this->onMatchFamily(gDefaultNames[i]);
|
||||
if (NULL == set) {
|
||||
continue;
|
||||
}
|
||||
SkTypeface* tf = set->matchStyle(SkFontStyle());
|
||||
if (NULL == tf) {
|
||||
continue;
|
||||
}
|
||||
fDefaultFamily = set;
|
||||
fDefaultTypeface = tf;
|
||||
break;
|
||||
}
|
||||
if (NULL == fDefaultTypeface) {
|
||||
fDefaultFamily = fFontStyleSets[0];
|
||||
fDefaultTypeface = fDefaultFamily->createTypeface(0);
|
||||
}
|
||||
SkASSERT(fDefaultFamily);
|
||||
SkASSERT(fDefaultTypeface);
|
||||
}
|
||||
|
||||
typedef SkFontMgr INHERITED;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
SkFontMgr* SkFontMgr::Factory() {
|
||||
return SkNEW(SkFontMgr_Android);
|
||||
}
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user