michael@0: /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: #ifdef MOZ_LOGGING
michael@0: #define FORCE_PR_LOG /* Allow logging in the release build */
michael@0: #include "prlog.h"
michael@0: #endif
michael@0: 
michael@0: #include "mozilla/ArrayUtils.h"
michael@0: 
michael@0: #include "gfxFontUtils.h"
michael@0: 
michael@0: #include "nsServiceManagerUtils.h"
michael@0: 
michael@0: #include "mozilla/dom/EncodingUtils.h"
michael@0: #include "mozilla/Preferences.h"
michael@0: #include "mozilla/Services.h"
michael@0: 
michael@0: #include "nsCOMPtr.h"
michael@0: #include "nsIUUIDGenerator.h"
michael@0: #include "nsIUnicodeDecoder.h"
michael@0: 
michael@0: #include "harfbuzz/hb.h"
michael@0: 
michael@0: #include "plbase64.h"
michael@0: #include "prlog.h"
michael@0: 
michael@0: #ifdef PR_LOGGING
michael@0: 
michael@0: #define LOG(log, args) PR_LOG(gfxPlatform::GetLog(log), \
michael@0:                                PR_LOG_DEBUG, args)
michael@0: 
michael@0: #endif // PR_LOGGING
michael@0: 
michael@0: #define UNICODE_BMP_LIMIT 0x10000
michael@0: 
michael@0: using namespace mozilla;
michael@0: 
michael@0: #pragma pack(1)
michael@0: 
michael@0: typedef struct {
michael@0:     AutoSwap_PRUint16 format;
michael@0:     AutoSwap_PRUint16 reserved;
michael@0:     AutoSwap_PRUint32 length;
michael@0:     AutoSwap_PRUint32 language;
michael@0:     AutoSwap_PRUint32 numGroups;
michael@0: } Format12CmapHeader;
michael@0: 
michael@0: typedef struct {
michael@0:     AutoSwap_PRUint32 startCharCode;
michael@0:     AutoSwap_PRUint32 endCharCode;
michael@0:     AutoSwap_PRUint32 startGlyphId;
michael@0: } Format12Group;
michael@0: 
michael@0: #pragma pack()
michael@0: 
michael@0: #if PR_LOGGING
michael@0: void
michael@0: gfxSparseBitSet::Dump(const char* aPrefix, eGfxLog aWhichLog) const
michael@0: {
michael@0:     NS_ASSERTION(mBlocks.DebugGetHeader(), "mHdr is null, this is bad");
michael@0:     uint32_t b, numBlocks = mBlocks.Length();
michael@0: 
michael@0:     for (b = 0; b < numBlocks; b++) {
michael@0:         Block *block = mBlocks[b];
michael@0:         if (!block) continue;
michael@0:         char outStr[256];
michael@0:         int index = 0;
michael@0:         index += sprintf(&outStr[index], "%s u+%6.6x [", aPrefix, (b << BLOCK_INDEX_SHIFT));
michael@0:         for (int i = 0; i < 32; i += 4) {
michael@0:             for (int j = i; j < i + 4; j++) {
michael@0:                 uint8_t bits = block->mBits[j];
michael@0:                 uint8_t flip1 = ((bits & 0xaa) >> 1) | ((bits & 0x55) << 1);
michael@0:                 uint8_t flip2 = ((flip1 & 0xcc) >> 2) | ((flip1 & 0x33) << 2);
michael@0:                 uint8_t flipped = ((flip2 & 0xf0) >> 4) | ((flip2 & 0x0f) << 4);
michael@0: 
michael@0:                 index += sprintf(&outStr[index], "%2.2x", flipped);
michael@0:             }
michael@0:             if (i + 4 != 32) index += sprintf(&outStr[index], " ");
michael@0:         }
michael@0:         index += sprintf(&outStr[index], "]");
michael@0:         LOG(aWhichLog, ("%s", outStr));
michael@0:     }
michael@0: }
michael@0: #endif
michael@0: 
michael@0: 
michael@0: nsresult
michael@0: gfxFontUtils::ReadCMAPTableFormat12(const uint8_t *aBuf, uint32_t aLength,
michael@0:                                     gfxSparseBitSet& aCharacterMap) 
michael@0: {
michael@0:     // Ensure table is large enough that we can safely read the header
michael@0:     NS_ENSURE_TRUE(aLength >= sizeof(Format12CmapHeader),
michael@0:                     NS_ERROR_GFX_CMAP_MALFORMED);
michael@0: 
michael@0:     // Sanity-check header fields
michael@0:     const Format12CmapHeader *cmap12 =
michael@0:         reinterpret_cast<const Format12CmapHeader*>(aBuf);
michael@0:     NS_ENSURE_TRUE(uint16_t(cmap12->format) == 12, 
michael@0:                    NS_ERROR_GFX_CMAP_MALFORMED);
michael@0:     NS_ENSURE_TRUE(uint16_t(cmap12->reserved) == 0, 
michael@0:                    NS_ERROR_GFX_CMAP_MALFORMED);
michael@0: 
michael@0:     uint32_t tablelen = cmap12->length;
michael@0:     NS_ENSURE_TRUE(tablelen >= sizeof(Format12CmapHeader) &&
michael@0:                    tablelen <= aLength, NS_ERROR_GFX_CMAP_MALFORMED);
michael@0: 
michael@0:     NS_ENSURE_TRUE(cmap12->language == 0, NS_ERROR_GFX_CMAP_MALFORMED);
michael@0: 
michael@0:     // Check that the table is large enough for the group array
michael@0:     const uint32_t numGroups = cmap12->numGroups;
michael@0:     NS_ENSURE_TRUE((tablelen - sizeof(Format12CmapHeader)) /
michael@0:                        sizeof(Format12Group) >= numGroups,
michael@0:                    NS_ERROR_GFX_CMAP_MALFORMED);
michael@0: 
michael@0:     // The array of groups immediately follows the subtable header.
michael@0:     const Format12Group *group =
michael@0:         reinterpret_cast<const Format12Group*>(aBuf + sizeof(Format12CmapHeader));
michael@0: 
michael@0:     // Check that groups are in correct order and do not overlap,
michael@0:     // and record character coverage in aCharacterMap.
michael@0:     uint32_t prevEndCharCode = 0;
michael@0:     for (uint32_t i = 0; i < numGroups; i++, group++) {
michael@0:         uint32_t startCharCode = group->startCharCode;
michael@0:         const uint32_t endCharCode = group->endCharCode;
michael@0:         NS_ENSURE_TRUE((prevEndCharCode < startCharCode || i == 0) &&
michael@0:                        startCharCode <= endCharCode &&
michael@0:                        endCharCode <= CMAP_MAX_CODEPOINT, 
michael@0:                        NS_ERROR_GFX_CMAP_MALFORMED);
michael@0:         // don't include a character that maps to glyph ID 0 (.notdef)
michael@0:         if (group->startGlyphId == 0) {
michael@0:             startCharCode++;
michael@0:         }
michael@0:         if (startCharCode <= endCharCode) {
michael@0:             aCharacterMap.SetRange(startCharCode, endCharCode);
michael@0:         }
michael@0:         prevEndCharCode = endCharCode;
michael@0:     }
michael@0: 
michael@0:     aCharacterMap.Compact();
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult 
michael@0: gfxFontUtils::ReadCMAPTableFormat4(const uint8_t *aBuf, uint32_t aLength,
michael@0:                                    gfxSparseBitSet& aCharacterMap)
michael@0: {
michael@0:     enum {
michael@0:         OffsetFormat = 0,
michael@0:         OffsetLength = 2,
michael@0:         OffsetLanguage = 4,
michael@0:         OffsetSegCountX2 = 6
michael@0:     };
michael@0: 
michael@0:     NS_ENSURE_TRUE(ReadShortAt(aBuf, OffsetFormat) == 4, 
michael@0:                    NS_ERROR_GFX_CMAP_MALFORMED);
michael@0:     uint16_t tablelen = ReadShortAt(aBuf, OffsetLength);
michael@0:     NS_ENSURE_TRUE(tablelen <= aLength, NS_ERROR_GFX_CMAP_MALFORMED);
michael@0:     NS_ENSURE_TRUE(tablelen > 16, NS_ERROR_GFX_CMAP_MALFORMED);
michael@0:     
michael@0:     // This field should normally (except for Mac platform subtables) be zero according to
michael@0:     // the OT spec, but some buggy fonts have lang = 1 (which would be English for MacOS).
michael@0:     // E.g. Arial Narrow Bold, v. 1.1 (Tiger), Arial Unicode MS (see bug 530614).
michael@0:     // So accept either zero or one here; the error should be harmless.
michael@0:     NS_ENSURE_TRUE((ReadShortAt(aBuf, OffsetLanguage) & 0xfffe) == 0, 
michael@0:                    NS_ERROR_GFX_CMAP_MALFORMED);
michael@0: 
michael@0:     uint16_t segCountX2 = ReadShortAt(aBuf, OffsetSegCountX2);
michael@0:     NS_ENSURE_TRUE(tablelen >= 16 + (segCountX2 * 4), 
michael@0:                    NS_ERROR_GFX_CMAP_MALFORMED);
michael@0: 
michael@0:     const uint16_t segCount = segCountX2 / 2;
michael@0: 
michael@0:     const uint16_t *endCounts = reinterpret_cast<const uint16_t*>(aBuf + 14);
michael@0:     const uint16_t *startCounts = endCounts + 1 /* skip one uint16_t for reservedPad */ + segCount;
michael@0:     const uint16_t *idDeltas = startCounts + segCount;
michael@0:     const uint16_t *idRangeOffsets = idDeltas + segCount;
michael@0:     uint16_t prevEndCount = 0;
michael@0:     for (uint16_t i = 0; i < segCount; i++) {
michael@0:         const uint16_t endCount = ReadShortAt16(endCounts, i);
michael@0:         const uint16_t startCount = ReadShortAt16(startCounts, i);
michael@0:         const uint16_t idRangeOffset = ReadShortAt16(idRangeOffsets, i);
michael@0: 
michael@0:         // sanity-check range
michael@0:         // This permits ranges to overlap by 1 character, which is strictly
michael@0:         // incorrect but occurs in Baskerville on OS X 10.7 (see bug 689087),
michael@0:         // and appears to be harmless in practice
michael@0:         NS_ENSURE_TRUE(startCount >= prevEndCount && startCount <= endCount,
michael@0:                        NS_ERROR_GFX_CMAP_MALFORMED);
michael@0:         prevEndCount = endCount;
michael@0: 
michael@0:         if (idRangeOffset == 0) {
michael@0:             // figure out if there's a code in the range that would map to
michael@0:             // glyph ID 0 (.notdef); if so, we need to skip setting that
michael@0:             // character code in the map
michael@0:             const uint16_t skipCode = 65536 - ReadShortAt16(idDeltas, i);
michael@0:             if (startCount < skipCode) {
michael@0:                 aCharacterMap.SetRange(startCount,
michael@0:                                        std::min<uint16_t>(skipCode - 1,
michael@0:                                                           endCount));
michael@0:             }
michael@0:             if (skipCode < endCount) {
michael@0:                 aCharacterMap.SetRange(std::max<uint16_t>(startCount,
michael@0:                                                           skipCode + 1),
michael@0:                                        endCount);
michael@0:             }
michael@0:         } else {
michael@0:             // const uint16_t idDelta = ReadShortAt16(idDeltas, i); // Unused: self-documenting.
michael@0:             for (uint32_t c = startCount; c <= endCount; ++c) {
michael@0:                 if (c == 0xFFFF)
michael@0:                     break;
michael@0: 
michael@0:                 const uint16_t *gdata = (idRangeOffset/2 
michael@0:                                          + (c - startCount)
michael@0:                                          + &idRangeOffsets[i]);
michael@0: 
michael@0:                 NS_ENSURE_TRUE((uint8_t*)gdata > aBuf && 
michael@0:                                (uint8_t*)gdata < aBuf + aLength, 
michael@0:                                NS_ERROR_GFX_CMAP_MALFORMED);
michael@0: 
michael@0:                 // make sure we have a glyph
michael@0:                 if (*gdata != 0) {
michael@0:                     // The glyph index at this point is:
michael@0:                     uint16_t glyph = ReadShortAt16(idDeltas, i) + *gdata;
michael@0:                     if (glyph) {
michael@0:                         aCharacterMap.set(c);
michael@0:                     }
michael@0:                 }
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     aCharacterMap.Compact();
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: gfxFontUtils::ReadCMAPTableFormat14(const uint8_t *aBuf, uint32_t aLength,
michael@0:                                     uint8_t*& aTable)
michael@0: {
michael@0:     enum {
michael@0:         OffsetFormat = 0,
michael@0:         OffsetTableLength = 2,
michael@0:         OffsetNumVarSelectorRecords = 6,
michael@0:         OffsetVarSelectorRecords = 10,
michael@0: 
michael@0:         SizeOfVarSelectorRecord = 11,
michael@0:         VSRecOffsetVarSelector = 0,
michael@0:         VSRecOffsetDefUVSOffset = 3,
michael@0:         VSRecOffsetNonDefUVSOffset = 7,
michael@0: 
michael@0:         SizeOfDefUVSTable = 4,
michael@0:         DefUVSOffsetStartUnicodeValue = 0,
michael@0:         DefUVSOffsetAdditionalCount = 3,
michael@0: 
michael@0:         SizeOfNonDefUVSTable = 5,
michael@0:         NonDefUVSOffsetUnicodeValue = 0,
michael@0:         NonDefUVSOffsetGlyphID = 3
michael@0:     };
michael@0:     NS_ENSURE_TRUE(aLength >= OffsetVarSelectorRecords,
michael@0:                    NS_ERROR_GFX_CMAP_MALFORMED);
michael@0: 
michael@0:     NS_ENSURE_TRUE(ReadShortAt(aBuf, OffsetFormat) == 14, 
michael@0:                    NS_ERROR_GFX_CMAP_MALFORMED);
michael@0: 
michael@0:     uint32_t tablelen = ReadLongAt(aBuf, OffsetTableLength);
michael@0:     NS_ENSURE_TRUE(tablelen <= aLength, NS_ERROR_GFX_CMAP_MALFORMED);
michael@0:     NS_ENSURE_TRUE(tablelen >= OffsetVarSelectorRecords,
michael@0:                    NS_ERROR_GFX_CMAP_MALFORMED);
michael@0: 
michael@0:     const uint32_t numVarSelectorRecords = ReadLongAt(aBuf, OffsetNumVarSelectorRecords);
michael@0:     NS_ENSURE_TRUE((tablelen - OffsetVarSelectorRecords) /
michael@0:                    SizeOfVarSelectorRecord >= numVarSelectorRecords,
michael@0:                    NS_ERROR_GFX_CMAP_MALFORMED);
michael@0: 
michael@0:     const uint8_t *records = aBuf + OffsetVarSelectorRecords;
michael@0:     for (uint32_t i = 0; i < numVarSelectorRecords; 
michael@0:          i++, records += SizeOfVarSelectorRecord) {
michael@0:         const uint32_t varSelector = ReadUint24At(records, VSRecOffsetVarSelector);
michael@0:         const uint32_t defUVSOffset = ReadLongAt(records, VSRecOffsetDefUVSOffset);
michael@0:         const uint32_t nonDefUVSOffset = ReadLongAt(records, VSRecOffsetNonDefUVSOffset);
michael@0:         NS_ENSURE_TRUE(varSelector <= CMAP_MAX_CODEPOINT &&
michael@0:                        defUVSOffset <= tablelen - 4 &&
michael@0:                        nonDefUVSOffset <= tablelen - 4, 
michael@0:                        NS_ERROR_GFX_CMAP_MALFORMED);
michael@0: 
michael@0:         if (defUVSOffset) {
michael@0:             const uint32_t numUnicodeValueRanges = ReadLongAt(aBuf, defUVSOffset);
michael@0:             NS_ENSURE_TRUE((tablelen - defUVSOffset) /
michael@0:                            SizeOfDefUVSTable >= numUnicodeValueRanges,
michael@0:                            NS_ERROR_GFX_CMAP_MALFORMED);
michael@0:             const uint8_t *tables = aBuf + defUVSOffset + 4;
michael@0:             uint32_t prevEndUnicode = 0;
michael@0:             for (uint32_t j = 0; j < numUnicodeValueRanges; j++, tables += SizeOfDefUVSTable) {
michael@0:                 const uint32_t startUnicode = ReadUint24At(tables, DefUVSOffsetStartUnicodeValue);
michael@0:                 const uint32_t endUnicode = startUnicode + tables[DefUVSOffsetAdditionalCount];
michael@0:                 NS_ENSURE_TRUE((prevEndUnicode < startUnicode || j == 0) &&
michael@0:                                endUnicode <= CMAP_MAX_CODEPOINT, 
michael@0:                                NS_ERROR_GFX_CMAP_MALFORMED);
michael@0:                 prevEndUnicode = endUnicode;
michael@0:             }
michael@0:         }
michael@0: 
michael@0:         if (nonDefUVSOffset) {
michael@0:             const uint32_t numUVSMappings = ReadLongAt(aBuf, nonDefUVSOffset);
michael@0:             NS_ENSURE_TRUE((tablelen - nonDefUVSOffset) /
michael@0:                            SizeOfNonDefUVSTable >= numUVSMappings,
michael@0:                            NS_ERROR_GFX_CMAP_MALFORMED);
michael@0:             const uint8_t *tables = aBuf + nonDefUVSOffset + 4;
michael@0:             uint32_t prevUnicode = 0;
michael@0:             for (uint32_t j = 0; j < numUVSMappings; j++, tables += SizeOfNonDefUVSTable) {
michael@0:                 const uint32_t unicodeValue = ReadUint24At(tables, NonDefUVSOffsetUnicodeValue);
michael@0:                 NS_ENSURE_TRUE((prevUnicode < unicodeValue || j == 0) &&
michael@0:                                unicodeValue <= CMAP_MAX_CODEPOINT, 
michael@0:                                NS_ERROR_GFX_CMAP_MALFORMED);
michael@0:                 prevUnicode = unicodeValue;
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     aTable = new uint8_t[tablelen];
michael@0:     memcpy(aTable, aBuf, tablelen);
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: // Windows requires fonts to have a format-4 cmap with a Microsoft ID (3).  On the Mac, fonts either have
michael@0: // a format-4 cmap with Microsoft platform/encoding id or they have one with a platformID == Unicode (0)
michael@0: // For fonts with two format-4 tables, the first one (Unicode platform) is preferred on the Mac.
michael@0: 
michael@0: #if defined(XP_MACOSX)
michael@0:     #define acceptableFormat4(p,e,k) (((p) == PLATFORM_ID_MICROSOFT && (e) == EncodingIDMicrosoft && !(k)) || \
michael@0:                                       ((p) == PLATFORM_ID_UNICODE))
michael@0: 
michael@0:     #define acceptableUCS4Encoding(p, e, k) \
michael@0:         (((p) == PLATFORM_ID_MICROSOFT && (e) == EncodingIDUCS4ForMicrosoftPlatform) && (k) != 12 || \
michael@0:          ((p) == PLATFORM_ID_UNICODE   && \
michael@0:           ((e) == EncodingIDDefaultForUnicodePlatform || (e) >= EncodingIDUCS4ForUnicodePlatform)))
michael@0: #else
michael@0:     #define acceptableFormat4(p,e,k) ((p) == PLATFORM_ID_MICROSOFT && (e) == EncodingIDMicrosoft)
michael@0: 
michael@0:     #define acceptableUCS4Encoding(p, e, k) \
michael@0:         ((p) == PLATFORM_ID_MICROSOFT && (e) == EncodingIDUCS4ForMicrosoftPlatform)
michael@0: #endif
michael@0: 
michael@0: #define acceptablePlatform(p) ((p) == PLATFORM_ID_UNICODE || (p) == PLATFORM_ID_MICROSOFT)
michael@0: #define isSymbol(p,e)         ((p) == PLATFORM_ID_MICROSOFT && (e) == EncodingIDSymbol)
michael@0: #define isUVSEncoding(p, e)   ((p) == PLATFORM_ID_UNICODE && (e) == EncodingIDUVSForUnicodePlatform)
michael@0: 
michael@0: uint32_t
michael@0: gfxFontUtils::FindPreferredSubtable(const uint8_t *aBuf, uint32_t aBufLength,
michael@0:                                     uint32_t *aTableOffset,
michael@0:                                     uint32_t *aUVSTableOffset,
michael@0:                                     bool *aSymbolEncoding)
michael@0: {
michael@0:     enum {
michael@0:         OffsetVersion = 0,
michael@0:         OffsetNumTables = 2,
michael@0:         SizeOfHeader = 4,
michael@0: 
michael@0:         TableOffsetPlatformID = 0,
michael@0:         TableOffsetEncodingID = 2,
michael@0:         TableOffsetOffset = 4,
michael@0:         SizeOfTable = 8,
michael@0: 
michael@0:         SubtableOffsetFormat = 0
michael@0:     };
michael@0:     enum {
michael@0:         EncodingIDSymbol = 0,
michael@0:         EncodingIDMicrosoft = 1,
michael@0:         EncodingIDDefaultForUnicodePlatform = 0,
michael@0:         EncodingIDUCS4ForUnicodePlatform = 3,
michael@0:         EncodingIDUVSForUnicodePlatform = 5,
michael@0:         EncodingIDUCS4ForMicrosoftPlatform = 10
michael@0:     };
michael@0: 
michael@0:     if (aUVSTableOffset) {
michael@0:         *aUVSTableOffset = 0;
michael@0:     }
michael@0: 
michael@0:     if (!aBuf || aBufLength < SizeOfHeader) {
michael@0:         // cmap table is missing, or too small to contain header fields!
michael@0:         return 0;
michael@0:     }
michael@0: 
michael@0:     // uint16_t version = ReadShortAt(aBuf, OffsetVersion); // Unused: self-documenting.
michael@0:     uint16_t numTables = ReadShortAt(aBuf, OffsetNumTables);
michael@0:     if (aBufLength < uint32_t(SizeOfHeader + numTables * SizeOfTable)) {
michael@0:         return 0;
michael@0:     }
michael@0: 
michael@0:     // save the format we want here
michael@0:     uint32_t keepFormat = 0;
michael@0: 
michael@0:     const uint8_t *table = aBuf + SizeOfHeader;
michael@0:     for (uint16_t i = 0; i < numTables; ++i, table += SizeOfTable) {
michael@0:         const uint16_t platformID = ReadShortAt(table, TableOffsetPlatformID);
michael@0:         if (!acceptablePlatform(platformID))
michael@0:             continue;
michael@0: 
michael@0:         const uint16_t encodingID = ReadShortAt(table, TableOffsetEncodingID);
michael@0:         const uint32_t offset = ReadLongAt(table, TableOffsetOffset);
michael@0:         if (aBufLength - 2 < offset) {
michael@0:             // this subtable is not valid - beyond end of buffer
michael@0:             return 0;
michael@0:         }
michael@0: 
michael@0:         const uint8_t *subtable = aBuf + offset;
michael@0:         const uint16_t format = ReadShortAt(subtable, SubtableOffsetFormat);
michael@0: 
michael@0:         if (isSymbol(platformID, encodingID)) {
michael@0:             keepFormat = format;
michael@0:             *aTableOffset = offset;
michael@0:             *aSymbolEncoding = true;
michael@0:             break;
michael@0:         } else if (format == 4 && acceptableFormat4(platformID, encodingID, keepFormat)) {
michael@0:             keepFormat = format;
michael@0:             *aTableOffset = offset;
michael@0:             *aSymbolEncoding = false;
michael@0:         } else if (format == 12 && acceptableUCS4Encoding(platformID, encodingID, keepFormat)) {
michael@0:             keepFormat = format;
michael@0:             *aTableOffset = offset;
michael@0:             *aSymbolEncoding = false;
michael@0:             if (platformID > PLATFORM_ID_UNICODE || !aUVSTableOffset || *aUVSTableOffset) {
michael@0:                 break; // we don't want to try anything else when this format is available.
michael@0:             }
michael@0:         } else if (format == 14 && isUVSEncoding(platformID, encodingID) && aUVSTableOffset) {
michael@0:             *aUVSTableOffset = offset;
michael@0:             if (keepFormat == 12) {
michael@0:                 break;
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     return keepFormat;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: gfxFontUtils::ReadCMAP(const uint8_t *aBuf, uint32_t aBufLength,
michael@0:                        gfxSparseBitSet& aCharacterMap,
michael@0:                        uint32_t& aUVSOffset,
michael@0:                        bool& aUnicodeFont, bool& aSymbolFont)
michael@0: {
michael@0:     uint32_t offset;
michael@0:     bool     symbol;
michael@0:     uint32_t format = FindPreferredSubtable(aBuf, aBufLength,
michael@0:                                             &offset, &aUVSOffset, &symbol);
michael@0: 
michael@0:     if (format == 4) {
michael@0:         if (symbol) {
michael@0:             aUnicodeFont = false;
michael@0:             aSymbolFont = true;
michael@0:         } else {
michael@0:             aUnicodeFont = true;
michael@0:             aSymbolFont = false;
michael@0:         }
michael@0:         return ReadCMAPTableFormat4(aBuf + offset, aBufLength - offset,
michael@0:                                     aCharacterMap);
michael@0:     }
michael@0: 
michael@0:     if (format == 12) {
michael@0:         aUnicodeFont = true;
michael@0:         aSymbolFont = false;
michael@0:         return ReadCMAPTableFormat12(aBuf + offset, aBufLength - offset,
michael@0:                                      aCharacterMap);
michael@0:     }
michael@0: 
michael@0:     return NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0: #pragma pack(1)
michael@0: 
michael@0: typedef struct {
michael@0:     AutoSwap_PRUint16 format;
michael@0:     AutoSwap_PRUint16 length;
michael@0:     AutoSwap_PRUint16 language;
michael@0:     AutoSwap_PRUint16 segCountX2;
michael@0:     AutoSwap_PRUint16 searchRange;
michael@0:     AutoSwap_PRUint16 entrySelector;
michael@0:     AutoSwap_PRUint16 rangeShift;
michael@0: 
michael@0:     AutoSwap_PRUint16 arrays[1];
michael@0: } Format4Cmap;
michael@0: 
michael@0: typedef struct {
michael@0:     AutoSwap_PRUint16 format;
michael@0:     AutoSwap_PRUint32 length;
michael@0:     AutoSwap_PRUint32 numVarSelectorRecords;
michael@0: 
michael@0:     typedef struct {
michael@0:         AutoSwap_PRUint24 varSelector;
michael@0:         AutoSwap_PRUint32 defaultUVSOffset;
michael@0:         AutoSwap_PRUint32 nonDefaultUVSOffset;
michael@0:     } VarSelectorRecord;
michael@0: 
michael@0:     VarSelectorRecord varSelectorRecords[1];
michael@0: } Format14Cmap;
michael@0: 
michael@0: typedef struct {
michael@0:     AutoSwap_PRUint32 numUVSMappings;
michael@0: 
michael@0:     typedef struct {
michael@0:         AutoSwap_PRUint24 unicodeValue;
michael@0:         AutoSwap_PRUint16 glyphID;
michael@0:     } UVSMapping;
michael@0: 
michael@0:     UVSMapping uvsMappings[1];
michael@0: } NonDefUVSTable;
michael@0: 
michael@0: #pragma pack()
michael@0: 
michael@0: uint32_t
michael@0: gfxFontUtils::MapCharToGlyphFormat4(const uint8_t *aBuf, char16_t aCh)
michael@0: {
michael@0:     const Format4Cmap *cmap4 = reinterpret_cast<const Format4Cmap*>(aBuf);
michael@0:     uint16_t segCount;
michael@0:     const AutoSwap_PRUint16 *endCodes;
michael@0:     const AutoSwap_PRUint16 *startCodes;
michael@0:     const AutoSwap_PRUint16 *idDelta;
michael@0:     const AutoSwap_PRUint16 *idRangeOffset;
michael@0:     uint16_t probe;
michael@0:     uint16_t rangeShiftOver2;
michael@0:     uint16_t index;
michael@0: 
michael@0:     segCount = (uint16_t)(cmap4->segCountX2) / 2;
michael@0: 
michael@0:     endCodes = &cmap4->arrays[0];
michael@0:     startCodes = &cmap4->arrays[segCount + 1]; // +1 for reserved word between arrays
michael@0:     idDelta = &startCodes[segCount];
michael@0:     idRangeOffset = &idDelta[segCount];
michael@0: 
michael@0:     probe = 1 << (uint16_t)(cmap4->entrySelector);
michael@0:     rangeShiftOver2 = (uint16_t)(cmap4->rangeShift) / 2;
michael@0: 
michael@0:     if ((uint16_t)(startCodes[rangeShiftOver2]) <= aCh) {
michael@0:         index = rangeShiftOver2;
michael@0:     } else {
michael@0:         index = 0;
michael@0:     }
michael@0: 
michael@0:     while (probe > 1) {
michael@0:         probe >>= 1;
michael@0:         if ((uint16_t)(startCodes[index + probe]) <= aCh) {
michael@0:             index += probe;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     if (aCh >= (uint16_t)(startCodes[index]) && aCh <= (uint16_t)(endCodes[index])) {
michael@0:         uint16_t result;
michael@0:         if ((uint16_t)(idRangeOffset[index]) == 0) {
michael@0:             result = aCh;
michael@0:         } else {
michael@0:             uint16_t offset = aCh - (uint16_t)(startCodes[index]);
michael@0:             const AutoSwap_PRUint16 *glyphIndexTable =
michael@0:                 (const AutoSwap_PRUint16*)((const char*)&idRangeOffset[index] +
michael@0:                                            (uint16_t)(idRangeOffset[index]));
michael@0:             result = glyphIndexTable[offset];
michael@0:         }
michael@0: 
michael@0:         // note that this is unsigned 16-bit arithmetic, and may wrap around
michael@0:         result += (uint16_t)(idDelta[index]);
michael@0:         return result;
michael@0:     }
michael@0: 
michael@0:     return 0;
michael@0: }
michael@0: 
michael@0: uint32_t
michael@0: gfxFontUtils::MapCharToGlyphFormat12(const uint8_t *aBuf, uint32_t aCh)
michael@0: {
michael@0:     const Format12CmapHeader *cmap12 =
michael@0:         reinterpret_cast<const Format12CmapHeader*>(aBuf);
michael@0: 
michael@0:     // We know that numGroups is within range for the subtable size
michael@0:     // because it was checked by ReadCMAPTableFormat12.
michael@0:     uint32_t numGroups = cmap12->numGroups;
michael@0: 
michael@0:     // The array of groups immediately follows the subtable header.
michael@0:     const Format12Group *groups =
michael@0:         reinterpret_cast<const Format12Group*>(aBuf + sizeof(Format12CmapHeader));
michael@0: 
michael@0:     // For most efficient binary search, we want to work on a range that
michael@0:     // is a power of 2 so that we can always halve it by shifting.
michael@0:     // So we find the largest power of 2 that is <= numGroups.
michael@0:     // We will offset this range by rangeOffset so as to reach the end
michael@0:     // of the table, provided that doesn't put us beyond the target
michael@0:     // value from the outset.
michael@0:     uint32_t powerOf2 = mozilla::FindHighestBit(numGroups);
michael@0:     uint32_t rangeOffset = numGroups - powerOf2;
michael@0:     uint32_t range = 0;
michael@0:     uint32_t startCharCode;
michael@0: 
michael@0:     if (groups[rangeOffset].startCharCode <= aCh) {
michael@0:         range = rangeOffset;
michael@0:     }
michael@0: 
michael@0:     // Repeatedly halve the size of the range until we find the target group
michael@0:     while (powerOf2 > 1) {
michael@0:         powerOf2 >>= 1;
michael@0:         if (groups[range + powerOf2].startCharCode <= aCh) {
michael@0:             range += powerOf2;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Check if the character is actually present in the range and return
michael@0:     // the corresponding glyph ID
michael@0:     startCharCode = groups[range].startCharCode;
michael@0:     if (startCharCode <= aCh && groups[range].endCharCode >= aCh) {
michael@0:         return groups[range].startGlyphId + aCh - startCharCode;
michael@0:     }
michael@0: 
michael@0:     // Else it's not present, so return the .notdef glyph
michael@0:     return 0;
michael@0: }
michael@0: 
michael@0: uint16_t
michael@0: gfxFontUtils::MapUVSToGlyphFormat14(const uint8_t *aBuf, uint32_t aCh, uint32_t aVS)
michael@0: {
michael@0:     const Format14Cmap *cmap14 = reinterpret_cast<const Format14Cmap*>(aBuf);
michael@0: 
michael@0:     // binary search in varSelectorRecords
michael@0:     uint32_t min = 0;
michael@0:     uint32_t max = cmap14->numVarSelectorRecords;
michael@0:     uint32_t nonDefUVSOffset = 0;
michael@0:     while (min < max) {
michael@0:         uint32_t index = (min + max) >> 1;
michael@0:         uint32_t varSelector = cmap14->varSelectorRecords[index].varSelector;
michael@0:         if (aVS == varSelector) {
michael@0:             nonDefUVSOffset = cmap14->varSelectorRecords[index].nonDefaultUVSOffset;
michael@0:             break;
michael@0:         }
michael@0:         if (aVS < varSelector) {
michael@0:             max = index;
michael@0:         } else {
michael@0:             min = index + 1;
michael@0:         }
michael@0:     }
michael@0:     if (!nonDefUVSOffset) {
michael@0:         return 0;
michael@0:     }
michael@0: 
michael@0:     const NonDefUVSTable *table = reinterpret_cast<const NonDefUVSTable*>
michael@0:                                       (aBuf + nonDefUVSOffset);
michael@0: 
michael@0:     // binary search in uvsMappings
michael@0:     min = 0;
michael@0:     max = table->numUVSMappings;
michael@0:     while (min < max) {
michael@0:         uint32_t index = (min + max) >> 1;
michael@0:         uint32_t unicodeValue = table->uvsMappings[index].unicodeValue;
michael@0:         if (aCh == unicodeValue) {
michael@0:             return table->uvsMappings[index].glyphID;
michael@0:         }
michael@0:         if (aCh < unicodeValue) {
michael@0:             max = index;
michael@0:         } else {
michael@0:             min = index + 1;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     return 0;
michael@0: }
michael@0: 
michael@0: uint32_t
michael@0: gfxFontUtils::MapCharToGlyph(const uint8_t *aCmapBuf, uint32_t aBufLength,
michael@0:                              uint32_t aUnicode, uint32_t aVarSelector)
michael@0: {
michael@0:     uint32_t offset, uvsOffset;
michael@0:     bool     symbol;
michael@0:     uint32_t format = FindPreferredSubtable(aCmapBuf, aBufLength, &offset,
michael@0:                                             &uvsOffset, &symbol);
michael@0: 
michael@0:     uint32_t gid;
michael@0:     switch (format) {
michael@0:     case 4:
michael@0:         gid = aUnicode < UNICODE_BMP_LIMIT ?
michael@0:             MapCharToGlyphFormat4(aCmapBuf + offset, char16_t(aUnicode)) : 0;
michael@0:         break;
michael@0:     case 12:
michael@0:         gid = MapCharToGlyphFormat12(aCmapBuf + offset, aUnicode);
michael@0:         break;
michael@0:     default:
michael@0:         NS_WARNING("unsupported cmap format, glyphs will be missing");
michael@0:         gid = 0;
michael@0:     }
michael@0: 
michael@0:     if (aVarSelector && uvsOffset && gid) {
michael@0:         uint32_t varGID =
michael@0:             gfxFontUtils::MapUVSToGlyphFormat14(aCmapBuf + uvsOffset,
michael@0:                                                 aUnicode, aVarSelector);
michael@0:         if (!varGID) {
michael@0:             aUnicode = gfxFontUtils::GetUVSFallback(aUnicode, aVarSelector);
michael@0:             if (aUnicode) {
michael@0:                 switch (format) {
michael@0:                 case 4:
michael@0:                     if (aUnicode < UNICODE_BMP_LIMIT) {
michael@0:                         varGID = MapCharToGlyphFormat4(aCmapBuf + offset,
michael@0:                                                        char16_t(aUnicode));
michael@0:                     }
michael@0:                     break;
michael@0:                 case 12:
michael@0:                     varGID = MapCharToGlyphFormat12(aCmapBuf + offset,
michael@0:                                                     aUnicode);
michael@0:                     break;
michael@0:                 }
michael@0:             }
michael@0:         }
michael@0:         if (varGID) {
michael@0:             gid = varGID;
michael@0:         }
michael@0: 
michael@0:         // else the variation sequence was not supported, use default mapping
michael@0:         // of the character code alone
michael@0:     }
michael@0: 
michael@0:     return gid;
michael@0: }
michael@0: 
michael@0: void gfxFontUtils::GetPrefsFontList(const char *aPrefName, nsTArray<nsString>& aFontList)
michael@0: {
michael@0:     const char16_t kComma = char16_t(',');
michael@0:     
michael@0:     aFontList.Clear();
michael@0:     
michael@0:     // get the list of single-face font families
michael@0:     nsAdoptingString fontlistValue = Preferences::GetString(aPrefName);
michael@0:     if (!fontlistValue) {
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     // append each font name to the list
michael@0:     nsAutoString fontname;
michael@0:     const char16_t *p, *p_end;
michael@0:     fontlistValue.BeginReading(p);
michael@0:     fontlistValue.EndReading(p_end);
michael@0: 
michael@0:      while (p < p_end) {
michael@0:         const char16_t *nameStart = p;
michael@0:         while (++p != p_end && *p != kComma)
michael@0:         /* nothing */ ;
michael@0: 
michael@0:         // pull out a single name and clean out leading/trailing whitespace        
michael@0:         fontname = Substring(nameStart, p);
michael@0:         fontname.CompressWhitespace(true, true);
michael@0:         
michael@0:         // append it to the list
michael@0:         aFontList.AppendElement(fontname);
michael@0:         ++p;
michael@0:     }
michael@0: 
michael@0: }
michael@0: 
michael@0: // produce a unique font name that is (1) a valid Postscript name and (2) less
michael@0: // than 31 characters in length.  Using AddFontMemResourceEx on Windows fails 
michael@0: // for names longer than 30 characters in length.
michael@0: 
michael@0: #define MAX_B64_LEN 32
michael@0: 
michael@0: nsresult gfxFontUtils::MakeUniqueUserFontName(nsAString& aName)
michael@0: {
michael@0:     nsCOMPtr<nsIUUIDGenerator> uuidgen =
michael@0:       do_GetService("@mozilla.org/uuid-generator;1");
michael@0:     NS_ENSURE_TRUE(uuidgen, NS_ERROR_OUT_OF_MEMORY);
michael@0: 
michael@0:     nsID guid;
michael@0: 
michael@0:     NS_ASSERTION(sizeof(guid) * 2 <= MAX_B64_LEN, "size of nsID has changed!");
michael@0: 
michael@0:     nsresult rv = uuidgen->GenerateUUIDInPlace(&guid);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     char guidB64[MAX_B64_LEN] = {0};
michael@0: 
michael@0:     if (!PL_Base64Encode(reinterpret_cast<char*>(&guid), sizeof(guid), guidB64))
michael@0:         return NS_ERROR_FAILURE;
michael@0: 
michael@0:     // all b64 characters except for '/' are allowed in Postscript names, so convert / ==> -
michael@0:     char *p;
michael@0:     for (p = guidB64; *p; p++) {
michael@0:         if (*p == '/')
michael@0:             *p = '-';
michael@0:     }
michael@0: 
michael@0:     aName.Assign(NS_LITERAL_STRING("uf"));
michael@0:     aName.AppendASCII(guidB64);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: 
michael@0: // TrueType/OpenType table handling code
michael@0: 
michael@0: // need byte aligned structs
michael@0: #pragma pack(1)
michael@0: 
michael@0: // name table stores set of name record structures, followed by
michael@0: // large block containing all the strings.  name record offset and length
michael@0: // indicates the offset and length within that block.
michael@0: // http://www.microsoft.com/typography/otspec/name.htm
michael@0: struct NameRecordData {
michael@0:     uint32_t  offset;
michael@0:     uint32_t  length;
michael@0: };
michael@0: 
michael@0: #pragma pack()
michael@0: 
michael@0: static bool
michael@0: IsValidSFNTVersion(uint32_t version)
michael@0: {
michael@0:     // normally 0x00010000, CFF-style OT fonts == 'OTTO' and Apple TT fonts = 'true'
michael@0:     // 'typ1' is also possible for old Type 1 fonts in a SFNT container but not supported
michael@0:     return version == 0x10000 ||
michael@0:            version == TRUETYPE_TAG('O','T','T','O') ||
michael@0:            version == TRUETYPE_TAG('t','r','u','e');
michael@0: }
michael@0: 
michael@0: // copy and swap UTF-16 values, assume no surrogate pairs, can be in place
michael@0: static void
michael@0: CopySwapUTF16(const uint16_t *aInBuf, uint16_t *aOutBuf, uint32_t aLen)
michael@0: {
michael@0:     const uint16_t *end = aInBuf + aLen;
michael@0:     while (aInBuf < end) {
michael@0:         uint16_t value = *aInBuf;
michael@0:         *aOutBuf = (value >> 8) | (value & 0xff) << 8;
michael@0:         aOutBuf++;
michael@0:         aInBuf++;
michael@0:     }
michael@0: }
michael@0: 
michael@0: gfxUserFontType
michael@0: gfxFontUtils::DetermineFontDataType(const uint8_t *aFontData, uint32_t aFontDataLength)
michael@0: {
michael@0:     // test for OpenType font data
michael@0:     // problem: EOT-Lite with 0x10000 length will look like TrueType!
michael@0:     if (aFontDataLength >= sizeof(SFNTHeader)) {
michael@0:         const SFNTHeader *sfntHeader = reinterpret_cast<const SFNTHeader*>(aFontData);
michael@0:         uint32_t sfntVersion = sfntHeader->sfntVersion;
michael@0:         if (IsValidSFNTVersion(sfntVersion)) {
michael@0:             return GFX_USERFONT_OPENTYPE;
michael@0:         }
michael@0:     }
michael@0:     
michael@0:     // test for WOFF
michael@0:     if (aFontDataLength >= sizeof(AutoSwap_PRUint32)) {
michael@0:         const AutoSwap_PRUint32 *version = 
michael@0:             reinterpret_cast<const AutoSwap_PRUint32*>(aFontData);
michael@0:         if (uint32_t(*version) == TRUETYPE_TAG('w','O','F','F')) {
michael@0:             return GFX_USERFONT_WOFF;
michael@0:         }
michael@0:     }
michael@0:     
michael@0:     // tests for other formats here
michael@0:     
michael@0:     return GFX_USERFONT_UNKNOWN;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: gfxFontUtils::RenameFont(const nsAString& aName, const uint8_t *aFontData, 
michael@0:                          uint32_t aFontDataLength, FallibleTArray<uint8_t> *aNewFont)
michael@0: {
michael@0:     NS_ASSERTION(aNewFont, "null font data array");
michael@0:     
michael@0:     uint64_t dataLength(aFontDataLength);
michael@0: 
michael@0:     // new name table
michael@0:     static const uint32_t neededNameIDs[] = {NAME_ID_FAMILY, 
michael@0:                                              NAME_ID_STYLE,
michael@0:                                              NAME_ID_UNIQUE,
michael@0:                                              NAME_ID_FULL,
michael@0:                                              NAME_ID_POSTSCRIPT};
michael@0: 
michael@0:     // calculate new name table size
michael@0:     uint16_t nameCount = ArrayLength(neededNameIDs);
michael@0: 
michael@0:     // leave room for null-terminator
michael@0:     uint16_t nameStrLength = (aName.Length() + 1) * sizeof(char16_t); 
michael@0: 
michael@0:     // round name table size up to 4-byte multiple
michael@0:     uint32_t nameTableSize = (sizeof(NameHeader) +
michael@0:                               sizeof(NameRecord) * nameCount +
michael@0:                               nameStrLength +
michael@0:                               3) & ~3;
michael@0:                               
michael@0:     if (dataLength + nameTableSize > UINT32_MAX)
michael@0:         return NS_ERROR_FAILURE;
michael@0:         
michael@0:     // bug 505386 - need to handle unpadded font length
michael@0:     uint32_t paddedFontDataSize = (aFontDataLength + 3) & ~3;
michael@0:     uint32_t adjFontDataSize = paddedFontDataSize + nameTableSize;
michael@0: 
michael@0:     // create new buffer: old font data plus new name table
michael@0:     if (!aNewFont->AppendElements(adjFontDataSize))
michael@0:         return NS_ERROR_OUT_OF_MEMORY;
michael@0: 
michael@0:     // copy the old font data
michael@0:     uint8_t *newFontData = reinterpret_cast<uint8_t*>(aNewFont->Elements());
michael@0:     
michael@0:     // null the last four bytes in case the font length is not a multiple of 4
michael@0:     memset(newFontData + aFontDataLength, 0, paddedFontDataSize - aFontDataLength);
michael@0: 
michael@0:     // copy font data
michael@0:     memcpy(newFontData, aFontData, aFontDataLength);
michael@0:     
michael@0:     // null out the last 4 bytes for checksum calculations
michael@0:     memset(newFontData + adjFontDataSize - 4, 0, 4);
michael@0:     
michael@0:     NameHeader *nameHeader = reinterpret_cast<NameHeader*>(newFontData +
michael@0:                                                             paddedFontDataSize);
michael@0:     
michael@0:     // -- name header
michael@0:     nameHeader->format = 0;
michael@0:     nameHeader->count = nameCount;
michael@0:     nameHeader->stringOffset = sizeof(NameHeader) + nameCount * sizeof(NameRecord);
michael@0:     
michael@0:     // -- name records
michael@0:     uint32_t i;
michael@0:     NameRecord *nameRecord = reinterpret_cast<NameRecord*>(nameHeader + 1);
michael@0:     
michael@0:     for (i = 0; i < nameCount; i++, nameRecord++) {
michael@0:         nameRecord->platformID = PLATFORM_ID_MICROSOFT;
michael@0:         nameRecord->encodingID = ENCODING_ID_MICROSOFT_UNICODEBMP;
michael@0:         nameRecord->languageID = LANG_ID_MICROSOFT_EN_US;
michael@0:         nameRecord->nameID = neededNameIDs[i];
michael@0:         nameRecord->offset = 0;
michael@0:         nameRecord->length = nameStrLength;
michael@0:     }
michael@0:     
michael@0:     // -- string data, located after the name records, stored in big-endian form
michael@0:     char16_t *strData = reinterpret_cast<char16_t*>(nameRecord);
michael@0: 
michael@0:     mozilla::NativeEndian::copyAndSwapToBigEndian(strData,
michael@0:                                                   aName.BeginReading(),
michael@0:                                                   aName.Length());
michael@0:     strData[aName.Length()] = 0; // add null termination
michael@0:     
michael@0:     // adjust name table header to point to the new name table
michael@0:     SFNTHeader *sfntHeader = reinterpret_cast<SFNTHeader*>(newFontData);
michael@0: 
michael@0:     // table directory entries begin immediately following SFNT header
michael@0:     TableDirEntry *dirEntry = 
michael@0:         reinterpret_cast<TableDirEntry*>(newFontData + sizeof(SFNTHeader));
michael@0: 
michael@0:     uint32_t numTables = sfntHeader->numTables;
michael@0:     
michael@0:     for (i = 0; i < numTables; i++, dirEntry++) {
michael@0:         if (dirEntry->tag == TRUETYPE_TAG('n','a','m','e')) {
michael@0:             break;
michael@0:         }
michael@0:     }
michael@0:     
michael@0:     // function only called if font validates, so this should always be true
michael@0:     NS_ASSERTION(i < numTables, "attempt to rename font with no name table");
michael@0: 
michael@0:     // note: dirEntry now points to name record
michael@0:     
michael@0:     // recalculate name table checksum
michael@0:     uint32_t checkSum = 0;
michael@0:     AutoSwap_PRUint32 *nameData = reinterpret_cast<AutoSwap_PRUint32*> (nameHeader);
michael@0:     AutoSwap_PRUint32 *nameDataEnd = nameData + (nameTableSize >> 2);
michael@0:     
michael@0:     while (nameData < nameDataEnd)
michael@0:         checkSum = checkSum + *nameData++;
michael@0:     
michael@0:     // adjust name table entry to point to new name table
michael@0:     dirEntry->offset = paddedFontDataSize;
michael@0:     dirEntry->length = nameTableSize;
michael@0:     dirEntry->checkSum = checkSum;
michael@0:     
michael@0:     // fix up checksums
michael@0:     uint32_t checksum = 0;
michael@0:     
michael@0:     // checksum for font = (checksum of header) + (checksum of tables)
michael@0:     uint32_t headerLen = sizeof(SFNTHeader) + sizeof(TableDirEntry) * numTables;
michael@0:     const AutoSwap_PRUint32 *headerData = 
michael@0:         reinterpret_cast<const AutoSwap_PRUint32*>(newFontData);
michael@0: 
michael@0:     // header length is in bytes, checksum calculated in longwords
michael@0:     for (i = 0; i < (headerLen >> 2); i++, headerData++) {
michael@0:         checksum += *headerData;
michael@0:     }
michael@0:     
michael@0:     uint32_t headOffset = 0;
michael@0:     dirEntry = reinterpret_cast<TableDirEntry*>(newFontData + sizeof(SFNTHeader));
michael@0: 
michael@0:     for (i = 0; i < numTables; i++, dirEntry++) {
michael@0:         if (dirEntry->tag == TRUETYPE_TAG('h','e','a','d')) {
michael@0:             headOffset = dirEntry->offset;
michael@0:         }
michael@0:         checksum += dirEntry->checkSum;
michael@0:     }
michael@0:     
michael@0:     NS_ASSERTION(headOffset != 0, "no head table for font");
michael@0:     
michael@0:     HeadTable *headData = reinterpret_cast<HeadTable*>(newFontData + headOffset);
michael@0: 
michael@0:     headData->checkSumAdjustment = HeadTable::HEAD_CHECKSUM_CALC_CONST - checksum;
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: // This is only called after the basic validity of the downloaded sfnt
michael@0: // data has been checked, so it should never fail to find the name table
michael@0: // (though it might fail to read it, if memory isn't available);
michael@0: // other checks here are just for extra paranoia.
michael@0: nsresult
michael@0: gfxFontUtils::GetFullNameFromSFNT(const uint8_t* aFontData, uint32_t aLength,
michael@0:                                   nsAString& aFullName)
michael@0: {
michael@0:     aFullName.AssignLiteral("(MISSING NAME)"); // should always get replaced
michael@0: 
michael@0:     NS_ENSURE_TRUE(aLength >= sizeof(SFNTHeader), NS_ERROR_UNEXPECTED);
michael@0:     const SFNTHeader *sfntHeader =
michael@0:         reinterpret_cast<const SFNTHeader*>(aFontData);
michael@0:     const TableDirEntry *dirEntry =
michael@0:         reinterpret_cast<const TableDirEntry*>(aFontData + sizeof(SFNTHeader));
michael@0:     uint32_t numTables = sfntHeader->numTables;
michael@0:     NS_ENSURE_TRUE(aLength >=
michael@0:                    sizeof(SFNTHeader) + numTables * sizeof(TableDirEntry),
michael@0:                    NS_ERROR_UNEXPECTED);
michael@0:     bool foundName = false;
michael@0:     for (uint32_t i = 0; i < numTables; i++, dirEntry++) {
michael@0:         if (dirEntry->tag == TRUETYPE_TAG('n','a','m','e')) {
michael@0:             foundName = true;
michael@0:             break;
michael@0:         }
michael@0:     }
michael@0:     
michael@0:     // should never fail, as we're only called after font validation succeeded
michael@0:     NS_ENSURE_TRUE(foundName, NS_ERROR_NOT_AVAILABLE);
michael@0: 
michael@0:     uint32_t len = dirEntry->length;
michael@0:     NS_ENSURE_TRUE(aLength > len && aLength - len >= dirEntry->offset,
michael@0:                    NS_ERROR_UNEXPECTED);
michael@0: 
michael@0:     hb_blob_t *nameBlob =
michael@0:         hb_blob_create((const char*)aFontData + dirEntry->offset, len,
michael@0:                        HB_MEMORY_MODE_READONLY, nullptr, nullptr);
michael@0:     nsresult rv = GetFullNameFromTable(nameBlob, aFullName);
michael@0:     hb_blob_destroy(nameBlob);
michael@0: 
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: gfxFontUtils::GetFullNameFromTable(hb_blob_t *aNameTable,
michael@0:                                    nsAString& aFullName)
michael@0: {
michael@0:     nsAutoString name;
michael@0:     nsresult rv =
michael@0:         gfxFontUtils::ReadCanonicalName(aNameTable,
michael@0:                                         gfxFontUtils::NAME_ID_FULL,
michael@0:                                         name);
michael@0:     if (NS_SUCCEEDED(rv) && !name.IsEmpty()) {
michael@0:         aFullName = name;
michael@0:         return NS_OK;
michael@0:     }
michael@0:     rv = gfxFontUtils::ReadCanonicalName(aNameTable,
michael@0:                                          gfxFontUtils::NAME_ID_FAMILY,
michael@0:                                          name);
michael@0:     if (NS_SUCCEEDED(rv) && !name.IsEmpty()) {
michael@0:         nsAutoString styleName;
michael@0:         rv = gfxFontUtils::ReadCanonicalName(aNameTable,
michael@0:                                              gfxFontUtils::NAME_ID_STYLE,
michael@0:                                              styleName);
michael@0:         if (NS_SUCCEEDED(rv) && !styleName.IsEmpty()) {
michael@0:             name.AppendLiteral(" ");
michael@0:             name.Append(styleName);
michael@0:             aFullName = name;
michael@0:         }
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     return NS_ERROR_NOT_AVAILABLE;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: gfxFontUtils::GetFamilyNameFromTable(hb_blob_t *aNameTable,
michael@0:                                      nsAString& aFullName)
michael@0: {
michael@0:     nsAutoString name;
michael@0:     nsresult rv =
michael@0:         gfxFontUtils::ReadCanonicalName(aNameTable,
michael@0:                                         gfxFontUtils::NAME_ID_FAMILY,
michael@0:                                         name);
michael@0:     if (NS_SUCCEEDED(rv) && !name.IsEmpty()) {
michael@0:         aFullName = name;
michael@0:         return NS_OK;
michael@0:     }
michael@0:     return NS_ERROR_NOT_AVAILABLE;
michael@0: }
michael@0: 
michael@0: enum {
michael@0: #if defined(XP_MACOSX)
michael@0:     CANONICAL_LANG_ID = gfxFontUtils::LANG_ID_MAC_ENGLISH,
michael@0:     PLATFORM_ID       = gfxFontUtils::PLATFORM_ID_MAC
michael@0: #else
michael@0:     CANONICAL_LANG_ID = gfxFontUtils::LANG_ID_MICROSOFT_EN_US,
michael@0:     PLATFORM_ID       = gfxFontUtils::PLATFORM_ID_MICROSOFT
michael@0: #endif
michael@0: };    
michael@0: 
michael@0: nsresult
michael@0: gfxFontUtils::ReadNames(const char *aNameData, uint32_t aDataLen,
michael@0:                         uint32_t aNameID, int32_t aPlatformID,
michael@0:                         nsTArray<nsString>& aNames)
michael@0: {
michael@0:     return ReadNames(aNameData, aDataLen, aNameID, LANG_ALL,
michael@0:                      aPlatformID, aNames);
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: gfxFontUtils::ReadCanonicalName(hb_blob_t *aNameTable, uint32_t aNameID,
michael@0:                                 nsString& aName)
michael@0: {
michael@0:     uint32_t nameTableLen;
michael@0:     const char *nameTable = hb_blob_get_data(aNameTable, &nameTableLen);
michael@0:     return ReadCanonicalName(nameTable, nameTableLen, aNameID, aName);
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: gfxFontUtils::ReadCanonicalName(const char *aNameData, uint32_t aDataLen,
michael@0:                                 uint32_t aNameID, nsString& aName)
michael@0: {
michael@0:     nsresult rv;
michael@0:     
michael@0:     nsTArray<nsString> names;
michael@0:     
michael@0:     // first, look for the English name (this will succeed 99% of the time)
michael@0:     rv = ReadNames(aNameData, aDataLen, aNameID, CANONICAL_LANG_ID, 
michael@0:                    PLATFORM_ID, names);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0:         
michael@0:     // otherwise, grab names for all languages
michael@0:     if (names.Length() == 0) {
michael@0:         rv = ReadNames(aNameData, aDataLen, aNameID, LANG_ALL,
michael@0:                        PLATFORM_ID, names);
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0:     }
michael@0:     
michael@0: #if defined(XP_MACOSX)
michael@0:     // may be dealing with font that only has Microsoft name entries
michael@0:     if (names.Length() == 0) {
michael@0:         rv = ReadNames(aNameData, aDataLen, aNameID, LANG_ID_MICROSOFT_EN_US,
michael@0:                        PLATFORM_ID_MICROSOFT, names);
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0:         
michael@0:         // getting really desperate now, take anything!
michael@0:         if (names.Length() == 0) {
michael@0:             rv = ReadNames(aNameData, aDataLen, aNameID, LANG_ALL,
michael@0:                            PLATFORM_ID_MICROSOFT, names);
michael@0:             NS_ENSURE_SUCCESS(rv, rv);
michael@0:         }
michael@0:     }
michael@0: #endif
michael@0: 
michael@0:     // return the first name (99.9% of the time names will
michael@0:     // contain a single English name)
michael@0:     if (names.Length()) {
michael@0:         aName.Assign(names[0]);
michael@0:         return NS_OK;
michael@0:     }
michael@0:         
michael@0:     return NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0: // Charsets to use for decoding Mac platform font names.
michael@0: // This table is sorted by {encoding, language}, with the wildcard "ANY" being
michael@0: // greater than any defined values for each field; we use a binary search on both
michael@0: // fields, and fall back to matching only encoding if necessary
michael@0: 
michael@0: // Some "redundant" entries for specific combinations are included such as
michael@0: // encoding=roman, lang=english, in order that common entries will be found
michael@0: // on the first search.
michael@0: 
michael@0: #define ANY 0xffff
michael@0: const gfxFontUtils::MacFontNameCharsetMapping gfxFontUtils::gMacFontNameCharsets[] =
michael@0: {
michael@0:     { ENCODING_ID_MAC_ROMAN,        LANG_ID_MAC_ENGLISH,      "macintosh"       },
michael@0:     { ENCODING_ID_MAC_ROMAN,        LANG_ID_MAC_ICELANDIC,    "x-mac-icelandic" },
michael@0:     { ENCODING_ID_MAC_ROMAN,        LANG_ID_MAC_TURKISH,      "x-mac-turkish"   },
michael@0:     { ENCODING_ID_MAC_ROMAN,        LANG_ID_MAC_POLISH,       "x-mac-ce"        },
michael@0:     { ENCODING_ID_MAC_ROMAN,        LANG_ID_MAC_ROMANIAN,     "x-mac-romanian"  },
michael@0:     { ENCODING_ID_MAC_ROMAN,        LANG_ID_MAC_CZECH,        "x-mac-ce"        },
michael@0:     { ENCODING_ID_MAC_ROMAN,        LANG_ID_MAC_SLOVAK,       "x-mac-ce"        },
michael@0:     { ENCODING_ID_MAC_ROMAN,        ANY,                      "macintosh"       },
michael@0:     { ENCODING_ID_MAC_JAPANESE,     LANG_ID_MAC_JAPANESE,     "Shift_JIS"       },
michael@0:     { ENCODING_ID_MAC_JAPANESE,     ANY,                      "Shift_JIS"       },
michael@0:     { ENCODING_ID_MAC_TRAD_CHINESE, LANG_ID_MAC_TRAD_CHINESE, "Big5"            },
michael@0:     { ENCODING_ID_MAC_TRAD_CHINESE, ANY,                      "Big5"            },
michael@0:     { ENCODING_ID_MAC_KOREAN,       LANG_ID_MAC_KOREAN,       "EUC-KR"          },
michael@0:     { ENCODING_ID_MAC_KOREAN,       ANY,                      "EUC-KR"          },
michael@0:     { ENCODING_ID_MAC_ARABIC,       LANG_ID_MAC_ARABIC,       "x-mac-arabic"    },
michael@0:     { ENCODING_ID_MAC_ARABIC,       LANG_ID_MAC_URDU,         "x-mac-farsi"     },
michael@0:     { ENCODING_ID_MAC_ARABIC,       LANG_ID_MAC_FARSI,        "x-mac-farsi"     },
michael@0:     { ENCODING_ID_MAC_ARABIC,       ANY,                      "x-mac-arabic"    },
michael@0:     { ENCODING_ID_MAC_HEBREW,       LANG_ID_MAC_HEBREW,       "x-mac-hebrew"    },
michael@0:     { ENCODING_ID_MAC_HEBREW,       ANY,                      "x-mac-hebrew"    },
michael@0:     { ENCODING_ID_MAC_GREEK,        ANY,                      "x-mac-greek"     },
michael@0:     { ENCODING_ID_MAC_CYRILLIC,     ANY,                      "x-mac-cyrillic"  },
michael@0:     { ENCODING_ID_MAC_DEVANAGARI,   ANY,                      "x-mac-devanagari"},
michael@0:     { ENCODING_ID_MAC_GURMUKHI,     ANY,                      "x-mac-gurmukhi"  },
michael@0:     { ENCODING_ID_MAC_GUJARATI,     ANY,                      "x-mac-gujarati"  },
michael@0:     { ENCODING_ID_MAC_SIMP_CHINESE, LANG_ID_MAC_SIMP_CHINESE, "GB2312"          },
michael@0:     { ENCODING_ID_MAC_SIMP_CHINESE, ANY,                      "GB2312"          }
michael@0: };
michael@0: 
michael@0: const char* gfxFontUtils::gISOFontNameCharsets[] = 
michael@0: {
michael@0:     /* 0 */ "us-ascii"   ,
michael@0:     /* 1 */ nullptr       , /* spec says "ISO 10646" but does not specify encoding form! */
michael@0:     /* 2 */ "ISO-8859-1"
michael@0: };
michael@0: 
michael@0: const char* gfxFontUtils::gMSFontNameCharsets[] =
michael@0: {
michael@0:     /* [0] ENCODING_ID_MICROSOFT_SYMBOL */      ""          ,
michael@0:     /* [1] ENCODING_ID_MICROSOFT_UNICODEBMP */  ""          ,
michael@0:     /* [2] ENCODING_ID_MICROSOFT_SHIFTJIS */    "Shift_JIS" ,
michael@0:     /* [3] ENCODING_ID_MICROSOFT_PRC */         nullptr      ,
michael@0:     /* [4] ENCODING_ID_MICROSOFT_BIG5 */        "Big5"      ,
michael@0:     /* [5] ENCODING_ID_MICROSOFT_WANSUNG */     nullptr      ,
michael@0:     /* [6] ENCODING_ID_MICROSOFT_JOHAB */       "x-johab"   ,
michael@0:     /* [7] reserved */                          nullptr      ,
michael@0:     /* [8] reserved */                          nullptr      ,
michael@0:     /* [9] reserved */                          nullptr      ,
michael@0:     /*[10] ENCODING_ID_MICROSOFT_UNICODEFULL */ ""
michael@0: };
michael@0: 
michael@0: // Return the name of the charset we should use to decode a font name
michael@0: // given the name table attributes.
michael@0: // Special return values:
michael@0: //    ""       charset is UTF16BE, no need for a converter
michael@0: //    nullptr   unknown charset, do not attempt conversion
michael@0: const char*
michael@0: gfxFontUtils::GetCharsetForFontName(uint16_t aPlatform, uint16_t aScript, uint16_t aLanguage)
michael@0: {
michael@0:     switch (aPlatform)
michael@0:     {
michael@0:     case PLATFORM_ID_UNICODE:
michael@0:         return "";
michael@0: 
michael@0:     case PLATFORM_ID_MAC:
michael@0:         {
michael@0:             uint32_t lo = 0, hi = ArrayLength(gMacFontNameCharsets);
michael@0:             MacFontNameCharsetMapping searchValue = { aScript, aLanguage, nullptr };
michael@0:             for (uint32_t i = 0; i < 2; ++i) {
michael@0:                 // binary search; if not found, set language to ANY and try again
michael@0:                 while (lo < hi) {
michael@0:                     uint32_t mid = (lo + hi) / 2;
michael@0:                     const MacFontNameCharsetMapping& entry = gMacFontNameCharsets[mid];
michael@0:                     if (entry < searchValue) {
michael@0:                         lo = mid + 1;
michael@0:                         continue;
michael@0:                     }
michael@0:                     if (searchValue < entry) {
michael@0:                         hi = mid;
michael@0:                         continue;
michael@0:                     }
michael@0:                     // found a match
michael@0:                     return entry.mCharsetName;
michael@0:                 }
michael@0: 
michael@0:                 // no match, so reset high bound for search and re-try
michael@0:                 hi = ArrayLength(gMacFontNameCharsets);
michael@0:                 searchValue.mLanguage = ANY;
michael@0:             }
michael@0:         }
michael@0:         break;
michael@0: 
michael@0:     case PLATFORM_ID_ISO:
michael@0:         if (aScript < ArrayLength(gISOFontNameCharsets)) {
michael@0:             return gISOFontNameCharsets[aScript];
michael@0:         }
michael@0:         break;
michael@0: 
michael@0:     case PLATFORM_ID_MICROSOFT:
michael@0:         if (aScript < ArrayLength(gMSFontNameCharsets)) {
michael@0:             return gMSFontNameCharsets[aScript];
michael@0:         }
michael@0:         break;
michael@0:     }
michael@0: 
michael@0:     return nullptr;
michael@0: }
michael@0: 
michael@0: // convert a raw name from the name table to an nsString, if possible;
michael@0: // return value indicates whether conversion succeeded
michael@0: bool
michael@0: gfxFontUtils::DecodeFontName(const char *aNameData, int32_t aByteLen, 
michael@0:                              uint32_t aPlatformCode, uint32_t aScriptCode,
michael@0:                              uint32_t aLangCode, nsAString& aName)
michael@0: {
michael@0:     if (aByteLen <= 0) {
michael@0:         NS_WARNING("empty font name");
michael@0:         aName.SetLength(0);
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     const char *csName = GetCharsetForFontName(aPlatformCode, aScriptCode, aLangCode);
michael@0: 
michael@0:     if (!csName) {
michael@0:         // nullptr -> unknown charset
michael@0: #ifdef DEBUG
michael@0:         char warnBuf[128];
michael@0:         if (aByteLen > 64)
michael@0:             aByteLen = 64;
michael@0:         sprintf(warnBuf, "skipping font name, unknown charset %d:%d:%d for <%.*s>",
michael@0:                 aPlatformCode, aScriptCode, aLangCode, aByteLen, aNameData);
michael@0:         NS_WARNING(warnBuf);
michael@0: #endif
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     if (csName[0] == 0) {
michael@0:         // empty charset name: data is utf16be, no need to instantiate a converter
michael@0:         uint32_t strLen = aByteLen / 2;
michael@0: #ifdef IS_LITTLE_ENDIAN
michael@0:         aName.SetLength(strLen);
michael@0:         CopySwapUTF16(reinterpret_cast<const uint16_t*>(aNameData),
michael@0:                       reinterpret_cast<uint16_t*>(aName.BeginWriting()), strLen);
michael@0: #else
michael@0:         aName.Assign(reinterpret_cast<const char16_t*>(aNameData), strLen);
michael@0: #endif    
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIUnicodeDecoder> decoder =
michael@0:         mozilla::dom::EncodingUtils::DecoderForEncoding(csName);
michael@0:     if (!decoder) {
michael@0:         NS_WARNING("failed to get the decoder for a font name string");
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     int32_t destLength;
michael@0:     nsresult rv = decoder->GetMaxLength(aNameData, aByteLen, &destLength);
michael@0:     if (NS_FAILED(rv)) {
michael@0:         NS_WARNING("decoder->GetMaxLength failed, invalid font name?");
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     // make space for the converted string
michael@0:     aName.SetLength(destLength);
michael@0:     rv = decoder->Convert(aNameData, &aByteLen,
michael@0:                           aName.BeginWriting(), &destLength);
michael@0:     if (NS_FAILED(rv)) {
michael@0:         NS_WARNING("decoder->Convert failed, invalid font name?");
michael@0:         return false;
michael@0:     }
michael@0:     aName.Truncate(destLength); // set the actual length
michael@0: 
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: gfxFontUtils::ReadNames(const char *aNameData, uint32_t aDataLen,
michael@0:                         uint32_t aNameID,
michael@0:                         int32_t aLangID, int32_t aPlatformID,
michael@0:                         nsTArray<nsString>& aNames)
michael@0: {
michael@0:     NS_ASSERTION(aDataLen != 0, "null name table");
michael@0: 
michael@0:     if (!aDataLen) {
michael@0:         return NS_ERROR_FAILURE;
michael@0:     }
michael@0: 
michael@0:     // -- name table data
michael@0:     const NameHeader *nameHeader = reinterpret_cast<const NameHeader*>(aNameData);
michael@0: 
michael@0:     uint32_t nameCount = nameHeader->count;
michael@0: 
michael@0:     // -- sanity check the number of name records
michael@0:     if (uint64_t(nameCount) * sizeof(NameRecord) > aDataLen) {
michael@0:         NS_WARNING("invalid font (name table data)");
michael@0:         return NS_ERROR_FAILURE;
michael@0:     }
michael@0: 
michael@0:     // -- iterate through name records
michael@0:     const NameRecord *nameRecord
michael@0:         = reinterpret_cast<const NameRecord*>(aNameData + sizeof(NameHeader));
michael@0:     uint64_t nameStringsBase = uint64_t(nameHeader->stringOffset);
michael@0: 
michael@0:     uint32_t i;
michael@0:     for (i = 0; i < nameCount; i++, nameRecord++) {
michael@0:         uint32_t platformID;
michael@0: 
michael@0:         // skip over unwanted nameID's
michael@0:         if (uint32_t(nameRecord->nameID) != aNameID)
michael@0:             continue;
michael@0: 
michael@0:         // skip over unwanted platform data
michael@0:         platformID = nameRecord->platformID;
michael@0:         if (aPlatformID != PLATFORM_ALL
michael@0:             && uint32_t(nameRecord->platformID) != PLATFORM_ID)
michael@0:             continue;
michael@0: 
michael@0:         // skip over unwanted languages
michael@0:         if (aLangID != LANG_ALL
michael@0:               && uint32_t(nameRecord->languageID) != uint32_t(aLangID))
michael@0:             continue;
michael@0: 
michael@0:         // add name to names array
michael@0: 
michael@0:         // -- calculate string location
michael@0:         uint32_t namelen = nameRecord->length;
michael@0:         uint32_t nameoff = nameRecord->offset;  // offset from base of string storage
michael@0: 
michael@0:         if (nameStringsBase + uint64_t(nameoff) + uint64_t(namelen)
michael@0:                 > aDataLen) {
michael@0:             NS_WARNING("invalid font (name table strings)");
michael@0:             return NS_ERROR_FAILURE;
michael@0:         }
michael@0: 
michael@0:         // -- decode if necessary and make nsString
michael@0:         nsAutoString name;
michael@0: 
michael@0:         DecodeFontName(aNameData + nameStringsBase + nameoff, namelen,
michael@0:                        platformID, uint32_t(nameRecord->encodingID),
michael@0:                        uint32_t(nameRecord->languageID), name);
michael@0: 
michael@0:         uint32_t k, numNames;
michael@0:         bool foundName = false;
michael@0: 
michael@0:         numNames = aNames.Length();
michael@0:         for (k = 0; k < numNames; k++) {
michael@0:             if (name.Equals(aNames[k])) {
michael@0:                 foundName = true;
michael@0:                 break;
michael@0:             }
michael@0:         }
michael@0: 
michael@0:         if (!foundName)
michael@0:             aNames.AppendElement(name);
michael@0: 
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: #ifdef XP_WIN
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: gfxFontUtils::IsCffFont(const uint8_t* aFontData)
michael@0: {
michael@0:     // this is only called after aFontData has passed basic validation,
michael@0:     // so we know there is enough data present to allow us to read the version!
michael@0:     const SFNTHeader *sfntHeader = reinterpret_cast<const SFNTHeader*>(aFontData);
michael@0:     return (sfntHeader->sfntVersion == TRUETYPE_TAG('O','T','T','O'));
michael@0: }
michael@0: 
michael@0: #endif
michael@0: