diff options
Diffstat (limited to '')
| -rw-r--r-- | gfx/skia/patches/archive/old-android-fonthost.patch | 530 |
1 files changed, 530 insertions, 0 deletions
diff --git a/gfx/skia/patches/archive/old-android-fonthost.patch b/gfx/skia/patches/archive/old-android-fonthost.patch new file mode 100644 index 0000000000..1c64ace7dd --- /dev/null +++ b/gfx/skia/patches/archive/old-android-fonthost.patch @@ -0,0 +1,530 @@ +# HG changeset patch +# Parent 9ee29e4aace683ddf6cf8ddb2893cd34fcfc772c +# User James Willcox <jwillcox@mozilla.com> +diff --git a/gfx/skia/Makefile.in b/gfx/skia/Makefile.in +--- a/gfx/skia/Makefile.in ++++ b/gfx/skia/Makefile.in +@@ -305,21 +305,20 @@ CPPSRCS += \ + SkFontHost_mac_coretext.cpp \ + SkTime_Unix.cpp \ + $(NULL) + endif + + ifeq (android,$(MOZ_WIDGET_TOOLKIT)) + CPPSRCS += \ + SkFontHost_FreeType.cpp \ + SkFontHost_android.cpp \ + SkFontHost_gamma.cpp \ +- FontHostConfiguration_android.cpp \ + SkMMapStream.cpp \ + SkTime_Unix.cpp \ + $(NULL) + + DEFINES += -DSK_BUILD_FOR_ANDROID_NDK + OS_CXXFLAGS += $(CAIRO_FT_CFLAGS) + endif + + ifeq (gtk2,$(MOZ_WIDGET_TOOLKIT)) + CPPSRCS += \ +diff --git a/gfx/skia/src/ports/SkFontHost_android.cpp b/gfx/skia/src/ports/SkFontHost_android.cpp +--- a/gfx/skia/src/ports/SkFontHost_android.cpp ++++ b/gfx/skia/src/ports/SkFontHost_android.cpp +@@ -1,38 +1,31 @@ ++ + /* +-** +-** Copyright 2006, The Android Open Source Project +-** +-** Licensed under the Apache License, Version 2.0 (the "License"); +-** you may not use this file except in compliance with the License. +-** You may obtain a copy of the License at +-** +-** http://www.apache.org/licenses/LICENSE-2.0 +-** +-** Unless required by applicable law or agreed to in writing, software +-** distributed under the License is distributed on an "AS IS" BASIS, +-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +-** See the License for the specific language governing permissions and +-** limitations under the License. +-*/ ++ * Copyright 2006 The Android Open Source Project ++ * ++ * Use of this source code is governed by a BSD-style license that can be ++ * found in the LICENSE file. ++ */ ++ + + #include "SkFontHost.h" + #include "SkDescriptor.h" + #include "SkMMapStream.h" + #include "SkPaint.h" + #include "SkString.h" + #include "SkStream.h" + #include "SkThread.h" + #include "SkTSearch.h" +-#include "FontHostConfiguration_android.h" + #include <stdio.h> + ++#define FONT_CACHE_MEMORY_BUDGET (768 * 1024) ++ + #ifndef SK_FONT_FILE_PREFIX + #define SK_FONT_FILE_PREFIX "/fonts/" + #endif + + SkTypeface::Style find_name_and_attributes(SkStream* stream, SkString* name, + bool* isFixedWidth); + + static void GetFullPathForSysFonts(SkString* full, const char name[]) { + full->set(getenv("ANDROID_ROOT")); + full->append(SK_FONT_FILE_PREFIX); +@@ -99,21 +92,21 @@ static SkTypeface* find_best_face(const + if (faces[SkTypeface::kNormal] != NULL) { + return faces[SkTypeface::kNormal]; + } + // look for anything + for (int i = 0; i < 4; i++) { + if (faces[i] != NULL) { + return faces[i]; + } + } + // should never get here, since the faces list should not be empty +- SkDEBUGFAIL("faces list is empty"); ++ SkASSERT(!"faces list is empty"); + return NULL; + } + + static FamilyRec* find_family(const SkTypeface* member) { + FamilyRec* curr = gFamilyHead; + while (curr != NULL) { + for (int i = 0; i < 4; i++) { + if (curr->fFaces[i] == member) { + return curr; + } +@@ -138,31 +131,27 @@ static SkTypeface* find_from_uniqueID(ui + curr = curr->fNext; + } + return NULL; + } + + /* 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) { + FamilyRec* family = find_family(face); +- if (family) { +- SkASSERT(family->fFaces[face->style()] == face); +- family->fFaces[face->style()] = NULL; ++ SkASSERT(family->fFaces[face->style()] == face); ++ family->fFaces[face->style()] = NULL; + +- for (int i = 0; i < 4; i++) { +- if (family->fFaces[i] != NULL) { // family is non-empty +- return NULL; +- } ++ for (int i = 0; i < 4; i++) { ++ if (family->fFaces[i] != NULL) { // family is non-empty ++ return NULL; + } +- } else { +-// SkDebugf("remove_from_family(%p) face not found", face); + } + return family; // return the empty family + } + + // maybe we should make FamilyRec be doubly-linked + static void detach_and_delete_family(FamilyRec* family) { + FamilyRec* curr = gFamilyHead; + FamilyRec* prev = NULL; + + while (curr != NULL) { +@@ -172,21 +161,21 @@ static void detach_and_delete_family(Fam + gFamilyHead = next; + } else { + prev->fNext = next; + } + SkDELETE(family); + return; + } + prev = curr; + curr = next; + } +- SkDEBUGFAIL("Yikes, couldn't find family in our list to remove/delete"); ++ SkASSERT(!"Yikes, couldn't find family in our list to remove/delete"); + } + + static SkTypeface* find_typeface(const char name[], SkTypeface::Style style) { + NameFamilyPair* list = gNameList.begin(); + int count = gNameList.count(); + + int index = SkStrLCSearch(&list[0].fName, count, name, sizeof(list[0])); + + if (index >= 0) { + return find_best_face(list[index].fFamily, style); +@@ -387,111 +376,90 @@ static bool get_name_and_style(const cha + } + return false; + } + + // used to record our notion of the pre-existing fonts + struct FontInitRec { + const char* fFileName; + const char* const* fNames; // null-terminated list + }; + ++static const char* gSansNames[] = { ++ "sans-serif", "arial", "helvetica", "tahoma", "verdana", NULL ++}; ++ ++static const char* gSerifNames[] = { ++ "serif", "times", "times new roman", "palatino", "georgia", "baskerville", ++ "goudy", "fantasy", "cursive", "ITC Stone Serif", NULL ++}; ++ ++static const char* gMonoNames[] = { ++ "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 ++ list of names (even if that list is empty), and the following members having ++ null for the list. The names list must be NULL-terminated ++*/ ++static const FontInitRec gSystemFonts[] = { ++ { "DroidSans.ttf", gSansNames }, ++ { "DroidSans-Bold.ttf", NULL }, ++ { "DroidSerif-Regular.ttf", gSerifNames }, ++ { "DroidSerif-Bold.ttf", NULL }, ++ { "DroidSerif-Italic.ttf", NULL }, ++ { "DroidSerif-BoldItalic.ttf", NULL }, ++ { "DroidSansMono.ttf", gMonoNames }, ++ /* 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(). ++ */ ++ { "DroidSansArabic.ttf", gFBNames }, ++ { "DroidSansHebrew.ttf", gFBNames }, ++ { "DroidSansThai.ttf", gFBNames }, ++ { "MTLmr3m.ttf", gFBNames }, // Motoya Japanese Font ++ { "MTLc3m.ttf", gFBNames }, // Motoya Japanese Font ++ { "DroidSansJapanese.ttf", gFBNames }, ++ { "DroidSansFallback.ttf", gFBNames } ++}; + +-/* Fonts are grouped by family, with the first font in a family having the +- list of names (even if that list is empty), and the following members having +- null for the list. The names list must be NULL-terminated. +-*/ +-static FontInitRec *gSystemFonts; +-static size_t gNumSystemFonts = 0; +- +-#define SYSTEM_FONTS_FILE "/system/etc/system_fonts.cfg" ++#define DEFAULT_NAMES gSansNames + + // these globals are assigned (once) by load_system_fonts() + static FamilyRec* gDefaultFamily; + static SkTypeface* gDefaultNormal; +-static char** gDefaultNames = NULL; +-static uint32_t *gFallbackFonts; + +-/* Load info from a configuration file that populates the system/fallback font structures +-*/ +-static void load_font_info() { +-// load_font_info_xml("/system/etc/system_fonts.xml"); +- SkTDArray<FontFamily*> fontFamilies; +- getFontFamilies(fontFamilies); +- +- SkTDArray<FontInitRec> fontInfo; +- bool firstInFamily = false; +- for (int i = 0; i < fontFamilies.count(); ++i) { +- FontFamily *family = fontFamilies[i]; +- firstInFamily = true; +- for (int j = 0; j < family->fFileNames.count(); ++j) { +- FontInitRec fontInfoRecord; +- fontInfoRecord.fFileName = family->fFileNames[j]; +- if (j == 0) { +- if (family->fNames.count() == 0) { +- // Fallback font +- fontInfoRecord.fNames = (char **)gFBNames; +- } else { +- SkTDArray<const char*> names = family->fNames; +- const char **nameList = (const char**) +- malloc((names.count() + 1) * sizeof(char*)); +- if (nameList == NULL) { +- // shouldn't get here +- break; +- } +- if (gDefaultNames == NULL) { +- gDefaultNames = (char**) nameList; +- } +- for (int i = 0; i < names.count(); ++i) { +- nameList[i] = names[i]; +- } +- nameList[names.count()] = NULL; +- fontInfoRecord.fNames = nameList; +- } +- } else { +- fontInfoRecord.fNames = NULL; +- } +- *fontInfo.append() = fontInfoRecord; +- } +- } +- gNumSystemFonts = fontInfo.count(); +- gSystemFonts = (FontInitRec*) malloc(gNumSystemFonts * sizeof(FontInitRec)); +- gFallbackFonts = (uint32_t*) malloc((gNumSystemFonts + 1) * sizeof(uint32_t)); +- if (gSystemFonts == NULL) { +- // shouldn't get here +- gNumSystemFonts = 0; +- } +- for (size_t i = 0; i < gNumSystemFonts; ++i) { +- gSystemFonts[i].fFileName = fontInfo[i].fFileName; +- gSystemFonts[i].fNames = fontInfo[i].fNames; +- } +- fontFamilies.deleteAll(); +-} ++/* 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; + } + +- load_font_info(); +- + const FontInitRec* rec = gSystemFonts; + SkTypeface* firstInFamily = NULL; + int fallbackCount = 0; + +- for (size_t i = 0; i < gNumSystemFonts; i++) { ++ for (size_t i = 0; i < SK_ARRAY_COUNT(gSystemFonts); i++) { + // if we're the first in a new family, clear firstInFamily + if (rec[i].fNames != NULL) { + firstInFamily = NULL; + } + + bool isFixedWidth; + SkString name; + SkTypeface::Style style; + + // we expect all the fonts, except the "fallback" fonts +@@ -515,120 +483,75 @@ static void load_system_fonts() { + // 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 default family if this is it +- if (names == gDefaultNames) { ++ if (names == DEFAULT_NAMES) { + gDefaultFamily = family; + } + // add the names to map to this family + 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; + } + + /////////////////////////////////////////////////////////////////////////////// + + void SkFontHost::Serialize(const SkTypeface* face, SkWStream* stream) { +- // lookup and record if the font is custom (i.e. not a system font) +- bool isCustomFont = !((FamilyTypeface*)face)->isSysFont(); +- stream->writeBool(isCustomFont); ++ const char* name = ((FamilyTypeface*)face)->getUniqueString(); + +- if (isCustomFont) { +- SkStream* fontStream = ((FamilyTypeface*)face)->openStream(); ++ stream->write8((uint8_t)face->style()); + +- // store the length of the custom font +- uint32_t len = fontStream->getLength(); +- stream->write32(len); +- +- // store the entire font in the serialized stream +- void* fontData = malloc(len); +- +- fontStream->read(fontData, len); +- stream->write(fontData, len); +- +- fontStream->unref(); +- free(fontData); +-// SkDebugf("--- fonthost custom serialize %d %d\n", face->style(), len); +- ++ if (NULL == name || 0 == *name) { ++ stream->writePackedUInt(0); ++// SkDebugf("--- fonthost serialize null\n"); + } else { +- const char* name = ((FamilyTypeface*)face)->getUniqueString(); +- +- stream->write8((uint8_t)face->style()); +- +- if (NULL == name || 0 == *name) { +- stream->writePackedUInt(0); +-// SkDebugf("--- fonthost serialize null\n"); +- } else { +- uint32_t len = strlen(name); +- stream->writePackedUInt(len); +- stream->write(name, len); +-// SkDebugf("--- fonthost serialize <%s> %d\n", name, face->style()); +- } ++ uint32_t len = strlen(name); ++ stream->writePackedUInt(len); ++ stream->write(name, len); ++// SkDebugf("--- fonthost serialize <%s> %d\n", name, face->style()); + } + } + + SkTypeface* SkFontHost::Deserialize(SkStream* stream) { + load_system_fonts(); + +- // check if the font is a custom or system font +- bool isCustomFont = stream->readBool(); ++ int style = stream->readU8(); + +- if (isCustomFont) { ++ int len = stream->readPackedUInt(); ++ if (len > 0) { ++ SkString str; ++ str.resize(len); ++ stream->read(str.writable_str(), len); + +- // read the length of the custom font from the stream +- uint32_t len = stream->readU32(); +- +- // generate a new stream to store the custom typeface +- SkMemoryStream* fontStream = new SkMemoryStream(len); +- stream->read((void*)fontStream->getMemoryBase(), len); +- +- SkTypeface* face = CreateTypefaceFromStream(fontStream); +- +- fontStream->unref(); +- +-// SkDebugf("--- fonthost custom deserialize %d %d\n", face->style(), len); +- return face; +- +- } else { +- int style = stream->readU8(); +- +- int len = stream->readPackedUInt(); +- if (len > 0) { +- SkString str; +- str.resize(len); +- stream->read(str.writable_str(), len); +- +- const FontInitRec* rec = gSystemFonts; +- for (size_t i = 0; i < gNumSystemFonts; i++) { +- if (strcmp(rec[i].fFileName, str.c_str()) == 0) { +- // backup until we hit the fNames +- for (int j = i; j >= 0; --j) { +- if (rec[j].fNames != NULL) { +- return SkFontHost::CreateTypeface(NULL, +- rec[j].fNames[0], NULL, 0, +- (SkTypeface::Style)style); +- } ++ const FontInitRec* rec = gSystemFonts; ++ for (size_t i = 0; i < SK_ARRAY_COUNT(gSystemFonts); i++) { ++ if (strcmp(rec[i].fFileName, str.c_str()) == 0) { ++ // backup until we hit the fNames ++ for (int j = i; j >= 0; --j) { ++ if (rec[j].fNames != NULL) { ++ return SkFontHost::CreateTypeface(NULL, ++ rec[j].fNames[0], NULL, 0, (SkTypeface::Style)style); + } + } + } + } + } + return NULL; + } + + /////////////////////////////////////////////////////////////////////////////// + +@@ -697,49 +620,32 @@ size_t SkFontHost::GetFileName(SkFontID + } + return size; + } else { + return 0; + } + } + + SkFontID SkFontHost::NextLogicalFont(SkFontID currFontID, SkFontID origFontID) { + load_system_fonts(); + +- const SkTypeface* origTypeface = find_from_uniqueID(origFontID); +- const SkTypeface* currTypeface = find_from_uniqueID(currFontID); +- +- SkASSERT(origTypeface != 0); +- SkASSERT(currTypeface != 0); +- +- // Our fallback list always stores the id of the plain in each fallback +- // family, so we transform currFontID to its plain equivalent. +- currFontID = find_typeface(currTypeface, SkTypeface::kNormal)->uniqueID(); +- + /* 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] == currFontID) { +- if (list[i+1] == 0) +- return 0; +- const SkTypeface* nextTypeface = find_from_uniqueID(list[i+1]); +- return find_typeface(nextTypeface, origTypeface->style())->uniqueID(); ++ return list[i+1]; + } + } +- +- // If we get here, currFontID was not a fallback, so we start at the +- // beginning of our list. +- const SkTypeface* firstTypeface = find_from_uniqueID(list[0]); +- return find_typeface(firstTypeface, origTypeface->style())->uniqueID(); ++ return list[0]; + } + + /////////////////////////////////////////////////////////////////////////////// + + SkTypeface* SkFontHost::CreateTypefaceFromStream(SkStream* stream) { + if (NULL == stream || stream->getLength() <= 0) { + return NULL; + } + + bool isFixedWidth; +@@ -754,10 +660,11 @@ SkTypeface* SkFontHost::CreateTypefaceFr + } + + 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 + stream->unref(); + return face; + } + ++/////////////////////////////////////////////////////////////////////////////// |