Automated import from //branches/master/...@141140,141140
diff --git a/src/ports/SkFontHost_android.cpp b/src/ports/SkFontHost_android.cpp
index 6ee75dc..cb9ccd8 100644
--- a/src/ports/SkFontHost_android.cpp
+++ b/src/ports/SkFontHost_android.cpp
@@ -33,8 +33,7 @@
SkTypeface::Style find_name_and_style(SkStream* stream, SkString* name);
-static void GetFullPathForSysFonts(SkString* full, const char name[])
-{
+static void GetFullPathForSysFonts(SkString* full, const char name[]) {
full->set(getenv("ANDROID_ROOT"));
full->append(SK_FONT_FILE_PREFIX);
full->append(name);
@@ -53,13 +52,12 @@
const char* fName; // we own this
FamilyRec* fFamily; // we don't own this, we just reference it
- void construct(const char name[], FamilyRec* family)
- {
+ void construct(const char name[], FamilyRec* family) {
fName = strdup(name);
fFamily = family; // we don't own this, so just record the referene
}
- void destruct()
- {
+
+ void destruct() {
free((char*)fName);
// we don't own family, so just ignore our reference
}
@@ -86,8 +84,7 @@
};
static SkTypeface* find_best_face(const FamilyRec* family,
- SkTypeface::Style style)
-{
+ SkTypeface::Style style) {
SkTypeface* const* faces = family->fFaces;
if (faces[style] != NULL) { // exact match
@@ -113,8 +110,7 @@
return NULL;
}
-static FamilyRec* find_family(const SkTypeface* member)
-{
+static FamilyRec* find_family(const SkTypeface* member) {
FamilyRec* curr = gFamilyHead;
while (curr != NULL) {
for (int i = 0; i < 4; i++) {
@@ -130,8 +126,7 @@
/* Returns the matching typeface, or NULL. If a typeface is found, its refcnt
is not modified.
*/
-static SkTypeface* find_from_uniqueID(uint32_t uniqueID)
-{
+static SkTypeface* find_from_uniqueID(uint32_t uniqueID) {
FamilyRec* curr = gFamilyHead;
while (curr != NULL) {
for (int i = 0; i < 4; i++) {
@@ -148,8 +143,7 @@
/* Remove reference to this face from its family. If the resulting family
is empty (has no faces), return that family, otherwise return NULL
*/
-static FamilyRec* remove_from_family(const SkTypeface* face)
-{
+static FamilyRec* remove_from_family(const SkTypeface* face) {
FamilyRec* family = find_family(face);
SkASSERT(family->fFaces[face->style()] == face);
family->fFaces[face->style()] = NULL;
@@ -163,8 +157,7 @@
}
// maybe we should make FamilyRec be doubly-linked
-static void detach_and_delete_family(FamilyRec* family)
-{
+static void detach_and_delete_family(FamilyRec* family) {
FamilyRec* curr = gFamilyHead;
FamilyRec* prev = NULL;
@@ -185,8 +178,7 @@
SkASSERT(!"Yikes, couldn't find family in our list to remove/delete");
}
-static SkTypeface* find_typeface(const char name[], SkTypeface::Style style)
-{
+static SkTypeface* find_typeface(const char name[], SkTypeface::Style style) {
NameFamilyPair* list = gNameList.begin();
int count = gNameList.count();
@@ -199,14 +191,12 @@
}
static SkTypeface* find_typeface(const SkTypeface* familyMember,
- SkTypeface::Style style)
-{
+ SkTypeface::Style style) {
const FamilyRec* family = find_family(familyMember);
return family ? find_best_face(family, style) : NULL;
}
-static void add_name(const char name[], FamilyRec* family)
-{
+static void add_name(const char name[], FamilyRec* family) {
SkAutoAsciiToLC tolc(name);
name = tolc.lc();
@@ -246,8 +236,7 @@
class FamilyTypeface : public SkTypeface {
public:
FamilyTypeface(Style style, bool sysFont, SkTypeface* familyMember)
- : SkTypeface(style, sk_atomic_inc(&gUniqueFontID) + 1)
- {
+ : SkTypeface(style, sk_atomic_inc(&gUniqueFontID) + 1) {
fIsSysFont = sysFont;
SkAutoMutexAcquire ac(gFamilyMutex);
@@ -262,8 +251,7 @@
rec->fFaces[style] = this;
}
- virtual ~FamilyTypeface()
- {
+ virtual ~FamilyTypeface() {
SkAutoMutexAcquire ac(gFamilyMutex);
// remove us from our family. If the family is now empty, we return
@@ -292,8 +280,7 @@
public:
StreamTypeface(Style style, bool sysFont, SkTypeface* familyMember,
SkStream* stream)
- : INHERITED(style, sysFont, familyMember)
- {
+ : INHERITED(style, sysFont, familyMember) {
SkASSERT(stream);
stream->ref();
fStream = stream;
@@ -321,8 +308,7 @@
public:
FileTypeface(Style style, bool sysFont, SkTypeface* familyMember,
const char path[])
- : INHERITED(style, sysFont, familyMember)
- {
+ : INHERITED(style, sysFont, familyMember) {
SkString fullpath;
if (sysFont) {
@@ -333,8 +319,7 @@
}
// overrides
- virtual SkStream* openStream()
- {
+ virtual SkStream* openStream() {
SkStream* stream = SkNEW_ARGS(SkMMAPStream, (fPath.c_str()));
// check for failure
@@ -367,8 +352,7 @@
///////////////////////////////////////////////////////////////////////////////
static bool get_name_and_style(const char path[], SkString* name,
- SkTypeface::Style* style)
-{
+ SkTypeface::Style* style) {
SkString fullpath;
GetFullPathForSysFonts(&fullpath, path);
@@ -389,6 +373,7 @@
return false;
}
+// used to record our notion of the pre-existing fonts
struct FontInitRec {
const char* fFileName;
const char* const* fNames; // null-terminated list
@@ -407,6 +392,7 @@
"monospace", "courier", "courier new", "monaco", NULL
};
+// deliberately empty, but we use the address to identify fallback fonts
static const char* gFBNames[] = { NULL };
/* Fonts must be grouped by family, with the first font in a family having the
@@ -421,29 +407,41 @@
{ "DroidSerif-Italic.ttf", NULL },
{ "DroidSerif-BoldItalic.ttf", NULL },
{ "DroidSansMono.ttf", gMonoNames },
-#ifdef NO_FALLBACK_FONT
- { "DroidSans.ttf", gFBNames }
-#else
+ /* These are optional, and can be ignored if not found in the file system.
+ These are appended to gFallbackFonts[] as they are seen, so we list
+ them in the order we want them to be accessed by NextLogicalFont().
+ */
+ { "DroidSansJapanese.ttf", gFBNames },
{ "DroidSansFallback.ttf", gFBNames }
-#endif
};
#define DEFAULT_NAMES gSansNames
// these globals are assigned (once) by load_system_fonts()
-static SkTypeface* gFallBackTypeface;
static FamilyRec* gDefaultFamily;
static SkTypeface* gDefaultNormal;
-static void load_system_fonts()
-{
+/* This is sized conservatively, assuming that it will never be a size issue.
+ It will be initialized in load_system_fonts(), and will be filled with the
+ fontIDs that can be used for fallback consideration, in sorted order (sorted
+ meaning element[0] should be used first, then element[1], etc. When we hit
+ a fontID==0 in the array, the list is done, hence our allocation size is
+ +1 the total number of possible system fonts. Also see NextLogicalFont().
+ */
+static uint32_t gFallbackFonts[SK_ARRAY_COUNT(gSystemFonts)+1];
+
+/* Called once (ensured by the sentinel check at the beginning of our body).
+ Initializes all the globals, and register the system fonts.
+ */
+static void load_system_fonts() {
// check if we've already be called
if (NULL != gDefaultNormal) {
return;
}
-
+
const FontInitRec* rec = gSystemFonts;
SkTypeface* firstInFamily = NULL;
+ int fallbackCount = 0;
for (size_t i = 0; i < SK_ARRAY_COUNT(gSystemFonts); i++) {
// if we're the first in a new family, clear firstInFamily
@@ -455,7 +453,6 @@
SkTypeface::Style style;
if (!get_name_and_style(rec[i].fFileName, &name, &style)) {
- SkDebugf("------ can't load <%s> as a font\n", rec[i].fFileName);
continue;
}
@@ -467,30 +464,34 @@
);
if (rec[i].fNames != NULL) {
+ // see if this is one of our fallback fonts
+ if (rec[i].fNames == gFBNames) {
+ // SkDebugf("---- adding %s as fallback[%d] fontID %d\n",
+ // rec[i].fFileName, fallbackCount, tf->uniqueID());
+ gFallbackFonts[fallbackCount++] = tf->uniqueID();
+ }
+
firstInFamily = tf;
+ FamilyRec* family = find_family(tf);
const char* const* names = rec[i].fNames;
- // record the fallback if this is it
- if (names == gFBNames) {
- gFallBackTypeface = tf;
- }
// record the default family if this is it
if (names == DEFAULT_NAMES) {
- gDefaultFamily = find_family(tf);
+ gDefaultFamily = family;
}
// add the names to map to this family
- FamilyRec* family = find_family(tf);
while (*names) {
add_name(*names, family);
names += 1;
}
}
-
}
// do this after all fonts are loaded. This is our default font, and it
// acts as a sentinel so we only execute load_system_fonts() once
gDefaultNormal = find_best_face(gDefaultFamily, SkTypeface::kNormal);
+ // now terminate our fallback list with the sentinel value
+ gFallbackFonts[fallbackCount] = 0;
}
///////////////////////////////////////////////////////////////////////////////
@@ -542,8 +543,7 @@
SkTypeface* SkFontHost::CreateTypeface(const SkTypeface* familyFace,
const char familyName[],
- SkTypeface::Style style)
-{
+ SkTypeface::Style style) {
load_system_fonts();
SkAutoMutexAcquire ac(gFamilyMutex);
@@ -569,15 +569,13 @@
return tf;
}
-bool SkFontHost::ValidFontID(uint32_t fontID)
-{
+bool SkFontHost::ValidFontID(uint32_t fontID) {
SkAutoMutexAcquire ac(gFamilyMutex);
return find_from_uniqueID(fontID) != NULL;
}
-SkStream* SkFontHost::OpenStream(uint32_t fontID)
-{
+SkStream* SkFontHost::OpenStream(uint32_t fontID) {
SkAutoMutexAcquire ac(gFamilyMutex);
FamilyTypeface* tf = (FamilyTypeface*)find_from_uniqueID(fontID);
@@ -593,17 +591,23 @@
uint32_t SkFontHost::NextLogicalFont(uint32_t fontID) {
load_system_fonts();
- if (gFallBackTypeface->uniqueID() == fontID) {
- // no where to go, just return NULL
- return 0;
+ /* First see if fontID is already one of our fallbacks. If so, return
+ its successor. If fontID is not in our list, then return the first one
+ in our list. Note: list is zero-terminated, and returning zero means
+ we have no more fonts to use for fallbacks.
+ */
+ const uint32_t* list = gFallbackFonts;
+ for (int i = 0; list[i] != 0; i++) {
+ if (list[i] == fontID) {
+ return list[i+1];
+ }
}
- return gFallBackTypeface->uniqueID();
+ return list[0];
}
///////////////////////////////////////////////////////////////////////////////
-SkTypeface* SkFontHost::CreateTypefaceFromStream(SkStream* stream)
-{
+SkTypeface* SkFontHost::CreateTypefaceFromStream(SkStream* stream) {
if (NULL == stream || stream->getLength() <= 0) {
return NULL;
}
@@ -614,8 +618,7 @@
return SkNEW_ARGS(StreamTypeface, (style, false, NULL, stream));
}
-SkTypeface* SkFontHost::CreateTypefaceFromFile(const char path[])
-{
+SkTypeface* SkFontHost::CreateTypefaceFromFile(const char path[]) {
SkStream* stream = SkNEW_ARGS(SkMMAPStream, (path));
SkTypeface* face = SkFontHost::CreateTypefaceFromStream(stream);
// since we created the stream, we let go of our ref() here
@@ -625,8 +628,7 @@
///////////////////////////////////////////////////////////////////////////////
-size_t SkFontHost::ShouldPurgeFontCache(size_t sizeAllocatedSoFar)
-{
+size_t SkFontHost::ShouldPurgeFontCache(size_t sizeAllocatedSoFar) {
if (sizeAllocatedSoFar > FONT_CACHE_MEMORY_BUDGET)
return sizeAllocatedSoFar - FONT_CACHE_MEMORY_BUDGET;
else
