Home | History | Annotate | Download | only in css 
      1 /*
      2  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
      3  *           (C) 2007, 2008 Nikolas Zimmermann <zimmermann (at) kde.org>
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions
      7  * are met:
      8  * 1. Redistributions of source code must retain the above copyright
      9  *    notice, this list of conditions and the following disclaimer.
     10  * 2. Redistributions in binary form must reproduce the above copyright
     11  *    notice, this list of conditions and the following disclaimer in the
     12  *    documentation and/or other materials provided with the distribution.
     13  *
     14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
     15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
     18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     25  */
     26 
     27 #include "config.h"
     28 #include "CSSFontSelector.h"
     29 
     30 #include "CachedFont.h"
     31 #include "CSSFontFace.h"
     32 #include "CSSFontFaceRule.h"
     33 #include "CSSFontFaceSource.h"
     34 #include "CSSFontFaceSrcValue.h"
     35 #include "CSSMutableStyleDeclaration.h"
     36 #include "CSSPrimitiveValue.h"
     37 #include "CSSPropertyNames.h"
     38 #include "CSSSegmentedFontFace.h"
     39 #include "CSSUnicodeRangeValue.h"
     40 #include "CSSValueKeywords.h"
     41 #include "CSSValueList.h"
     42 #include "CachedResourceLoader.h"
     43 #include "Document.h"
     44 #include "FontCache.h"
     45 #include "FontFamilyValue.h"
     46 #include "Frame.h"
     47 #include "RenderObject.h"
     48 #include "Settings.h"
     49 #include "SimpleFontData.h"
     50 #include <wtf/text/AtomicString.h>
     51 
     52 #if ENABLE(SVG)
     53 #include "SVGFontFaceElement.h"
     54 #include "SVGNames.h"
     55 #endif
     56 
     57 namespace WebCore {
     58 
     59 CSSFontSelector::CSSFontSelector(Document* document)
     60     : m_document(document)
     61 {
     62     // FIXME: An old comment used to say there was no need to hold a reference to m_document
     63     // because "we are guaranteed to be destroyed before the document". But there does not
     64     // seem to be any such guarantee.
     65 
     66     ASSERT(m_document);
     67     fontCache()->addClient(this);
     68 }
     69 
     70 CSSFontSelector::~CSSFontSelector()
     71 {
     72     fontCache()->removeClient(this);
     73     deleteAllValues(m_fontFaces);
     74     deleteAllValues(m_locallyInstalledFontFaces);
     75     deleteAllValues(m_fonts);
     76 }
     77 
     78 bool CSSFontSelector::isEmpty() const
     79 {
     80     return m_fonts.isEmpty();
     81 }
     82 
     83 CachedResourceLoader* CSSFontSelector::cachedResourceLoader() const
     84 {
     85     return m_document ? m_document->cachedResourceLoader() : 0;
     86 }
     87 
     88 void CSSFontSelector::addFontFaceRule(const CSSFontFaceRule* fontFaceRule)
     89 {
     90     // Obtain the font-family property and the src property.  Both must be defined.
     91     const CSSMutableStyleDeclaration* style = fontFaceRule->style();
     92     RefPtr<CSSValue> fontFamily = style->getPropertyCSSValue(CSSPropertyFontFamily);
     93     RefPtr<CSSValue> src = style->getPropertyCSSValue(CSSPropertySrc);
     94     RefPtr<CSSValue> unicodeRange = style->getPropertyCSSValue(CSSPropertyUnicodeRange);
     95     if (!fontFamily || !src || !fontFamily->isValueList() || !src->isValueList() || (unicodeRange && !unicodeRange->isValueList()))
     96         return;
     97 
     98     CSSValueList* familyList = static_cast<CSSValueList*>(fontFamily.get());
     99     if (!familyList->length())
    100         return;
    101 
    102     CSSValueList* srcList = static_cast<CSSValueList*>(src.get());
    103     if (!srcList->length())
    104         return;
    105 
    106     CSSValueList* rangeList = static_cast<CSSValueList*>(unicodeRange.get());
    107 
    108     unsigned traitsMask = 0;
    109 
    110     if (RefPtr<CSSValue> fontStyle = style->getPropertyCSSValue(CSSPropertyFontStyle)) {
    111         if (fontStyle->isPrimitiveValue()) {
    112             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
    113             list->append(fontStyle);
    114             fontStyle = list;
    115         } else if (!fontStyle->isValueList())
    116             return;
    117 
    118         CSSValueList* styleList = static_cast<CSSValueList*>(fontStyle.get());
    119         unsigned numStyles = styleList->length();
    120         if (!numStyles)
    121             return;
    122 
    123         for (unsigned i = 0; i < numStyles; ++i) {
    124             switch (static_cast<CSSPrimitiveValue*>(styleList->itemWithoutBoundsCheck(i))->getIdent()) {
    125                 case CSSValueAll:
    126                     traitsMask |= FontStyleMask;
    127                     break;
    128                 case CSSValueNormal:
    129                     traitsMask |= FontStyleNormalMask;
    130                     break;
    131                 case CSSValueItalic:
    132                 case CSSValueOblique:
    133                     traitsMask |= FontStyleItalicMask;
    134                     break;
    135                 default:
    136                     break;
    137             }
    138         }
    139     } else
    140         traitsMask |= FontStyleMask;
    141 
    142     if (RefPtr<CSSValue> fontWeight = style->getPropertyCSSValue(CSSPropertyFontWeight)) {
    143         if (fontWeight->isPrimitiveValue()) {
    144             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
    145             list->append(fontWeight);
    146             fontWeight = list;
    147         } else if (!fontWeight->isValueList())
    148             return;
    149 
    150         CSSValueList* weightList = static_cast<CSSValueList*>(fontWeight.get());
    151         unsigned numWeights = weightList->length();
    152         if (!numWeights)
    153             return;
    154 
    155         for (unsigned i = 0; i < numWeights; ++i) {
    156             switch (static_cast<CSSPrimitiveValue*>(weightList->itemWithoutBoundsCheck(i))->getIdent()) {
    157                 case CSSValueAll:
    158                     traitsMask |= FontWeightMask;
    159                     break;
    160                 case CSSValueBolder:
    161                 case CSSValueBold:
    162                 case CSSValue700:
    163                     traitsMask |= FontWeight700Mask;
    164                     break;
    165                 case CSSValueNormal:
    166                 case CSSValue400:
    167                     traitsMask |= FontWeight400Mask;
    168                     break;
    169                 case CSSValue900:
    170                     traitsMask |= FontWeight900Mask;
    171                     break;
    172                 case CSSValue800:
    173                     traitsMask |= FontWeight800Mask;
    174                     break;
    175                 case CSSValue600:
    176                     traitsMask |= FontWeight600Mask;
    177                     break;
    178                 case CSSValue500:
    179                     traitsMask |= FontWeight500Mask;
    180                     break;
    181                 case CSSValue300:
    182                     traitsMask |= FontWeight300Mask;
    183                     break;
    184                 case CSSValueLighter:
    185                 case CSSValue200:
    186                     traitsMask |= FontWeight200Mask;
    187                     break;
    188                 case CSSValue100:
    189                     traitsMask |= FontWeight100Mask;
    190                     break;
    191                 default:
    192                     break;
    193             }
    194         }
    195     } else
    196         traitsMask |= FontWeightMask;
    197 
    198     if (RefPtr<CSSValue> fontVariant = style->getPropertyCSSValue(CSSPropertyFontVariant)) {
    199         if (fontVariant->isPrimitiveValue()) {
    200             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
    201             list->append(fontVariant);
    202             fontVariant = list;
    203         } else if (!fontVariant->isValueList())
    204             return;
    205 
    206         CSSValueList* variantList = static_cast<CSSValueList*>(fontVariant.get());
    207         unsigned numVariants = variantList->length();
    208         if (!numVariants)
    209             return;
    210 
    211         for (unsigned i = 0; i < numVariants; ++i) {
    212             switch (static_cast<CSSPrimitiveValue*>(variantList->itemWithoutBoundsCheck(i))->getIdent()) {
    213                 case CSSValueAll:
    214                     traitsMask |= FontVariantMask;
    215                     break;
    216                 case CSSValueNormal:
    217                     traitsMask |= FontVariantNormalMask;
    218                     break;
    219                 case CSSValueSmallCaps:
    220                     traitsMask |= FontVariantSmallCapsMask;
    221                     break;
    222                 default:
    223                     break;
    224             }
    225         }
    226     } else
    227         traitsMask |= FontVariantMask;
    228 
    229     // Each item in the src property's list is a single CSSFontFaceSource. Put them all into a CSSFontFace.
    230     RefPtr<CSSFontFace> fontFace;
    231 
    232     int srcLength = srcList->length();
    233 
    234     bool foundSVGFont = false;
    235 
    236     for (int i = 0; i < srcLength; i++) {
    237         // An item in the list either specifies a string (local font name) or a URL (remote font to download).
    238         CSSFontFaceSrcValue* item = static_cast<CSSFontFaceSrcValue*>(srcList->itemWithoutBoundsCheck(i));
    239         CSSFontFaceSource* source = 0;
    240 
    241 #if ENABLE(SVG_FONTS)
    242         foundSVGFont = item->isSVGFontFaceSrc() || item->svgFontFaceElement();
    243 #endif
    244         if (!item->isLocal()) {
    245             Settings* settings = m_document ? m_document->frame() ? m_document->frame()->settings() : 0 : 0;
    246             bool allowDownloading = foundSVGFont || (settings && settings->downloadableBinaryFontsEnabled());
    247             if (allowDownloading && item->isSupportedFormat() && m_document) {
    248                 CachedFont* cachedFont = m_document->cachedResourceLoader()->requestFont(item->resource());
    249                 if (cachedFont) {
    250                     source = new CSSFontFaceSource(item->resource(), cachedFont);
    251 #if ENABLE(SVG_FONTS)
    252                     if (foundSVGFont)
    253                         source->setHasExternalSVGFont(true);
    254 #endif
    255                 }
    256             }
    257         } else {
    258             source = new CSSFontFaceSource(item->resource());
    259         }
    260 
    261         if (!fontFace)
    262             fontFace = CSSFontFace::create(static_cast<FontTraitsMask>(traitsMask));
    263 
    264         if (source) {
    265 #if ENABLE(SVG_FONTS)
    266             source->setSVGFontFaceElement(item->svgFontFaceElement());
    267 #endif
    268             fontFace->addSource(source);
    269         }
    270     }
    271 
    272     ASSERT(fontFace);
    273 
    274     if (fontFace && !fontFace->isValid())
    275         return;
    276 
    277     if (rangeList) {
    278         unsigned numRanges = rangeList->length();
    279         for (unsigned i = 0; i < numRanges; i++) {
    280             CSSUnicodeRangeValue* range = static_cast<CSSUnicodeRangeValue*>(rangeList->itemWithoutBoundsCheck(i));
    281             fontFace->addRange(range->from(), range->to());
    282         }
    283     }
    284 
    285     // Hash under every single family name.
    286     int familyLength = familyList->length();
    287     for (int i = 0; i < familyLength; i++) {
    288         CSSPrimitiveValue* item = static_cast<CSSPrimitiveValue*>(familyList->itemWithoutBoundsCheck(i));
    289         String familyName;
    290         if (item->primitiveType() == CSSPrimitiveValue::CSS_STRING)
    291             familyName = static_cast<FontFamilyValue*>(item)->familyName();
    292         else if (item->primitiveType() == CSSPrimitiveValue::CSS_IDENT) {
    293             // We need to use the raw text for all the generic family types, since @font-face is a way of actually
    294             // defining what font to use for those types.
    295             String familyName;
    296             switch (item->getIdent()) {
    297                 case CSSValueSerif:
    298                     familyName = "-webkit-serif";
    299                     break;
    300                 case CSSValueSansSerif:
    301                     familyName = "-webkit-sans-serif";
    302                     break;
    303                 case CSSValueCursive:
    304                     familyName = "-webkit-cursive";
    305                     break;
    306                 case CSSValueFantasy:
    307                     familyName = "-webkit-fantasy";
    308                     break;
    309                 case CSSValueMonospace:
    310                     familyName = "-webkit-monospace";
    311                     break;
    312                 default:
    313                     break;
    314             }
    315         }
    316 
    317         if (familyName.isEmpty())
    318             continue;
    319 
    320         Vector<RefPtr<CSSFontFace> >* familyFontFaces = m_fontFaces.get(familyName);
    321         if (!familyFontFaces) {
    322             familyFontFaces = new Vector<RefPtr<CSSFontFace> >;
    323             m_fontFaces.set(familyName, familyFontFaces);
    324 
    325             ASSERT(!m_locallyInstalledFontFaces.contains(familyName));
    326             Vector<RefPtr<CSSFontFace> >* familyLocallyInstalledFaces;
    327 
    328             Vector<unsigned> locallyInstalledFontsTraitsMasks;
    329             fontCache()->getTraitsInFamily(familyName, locallyInstalledFontsTraitsMasks);
    330             unsigned numLocallyInstalledFaces = locallyInstalledFontsTraitsMasks.size();
    331             if (numLocallyInstalledFaces) {
    332                 familyLocallyInstalledFaces = new Vector<RefPtr<CSSFontFace> >;
    333                 m_locallyInstalledFontFaces.set(familyName, familyLocallyInstalledFaces);
    334 
    335                 for (unsigned i = 0; i < numLocallyInstalledFaces; ++i) {
    336                     RefPtr<CSSFontFace> locallyInstalledFontFace = CSSFontFace::create(static_cast<FontTraitsMask>(locallyInstalledFontsTraitsMasks[i]), true);
    337                     locallyInstalledFontFace->addSource(new CSSFontFaceSource(familyName));
    338                     ASSERT(locallyInstalledFontFace->isValid());
    339                     familyLocallyInstalledFaces->append(locallyInstalledFontFace);
    340                 }
    341             }
    342         }
    343 
    344         familyFontFaces->append(fontFace);
    345     }
    346 }
    347 
    348 void CSSFontSelector::registerForInvalidationCallbacks(FontSelectorClient* client)
    349 {
    350     m_clients.add(client);
    351 }
    352 
    353 void CSSFontSelector::unregisterForInvalidationCallbacks(FontSelectorClient* client)
    354 {
    355     m_clients.remove(client);
    356 }
    357 
    358 void CSSFontSelector::dispatchInvalidationCallbacks()
    359 {
    360     Vector<FontSelectorClient*> clients;
    361     copyToVector(m_clients, clients);
    362     for (size_t i = 0; i < clients.size(); ++i)
    363         clients[i]->fontsNeedUpdate(this);
    364 
    365     // FIXME: Make Document a FontSelectorClient so that it can simply register for invalidation callbacks.
    366     if (!m_document || m_document->inPageCache() || !m_document->renderer())
    367         return;
    368     m_document->scheduleForcedStyleRecalc();
    369 }
    370 
    371 void CSSFontSelector::fontLoaded()
    372 {
    373     dispatchInvalidationCallbacks();
    374 }
    375 
    376 void CSSFontSelector::fontCacheInvalidated()
    377 {
    378     dispatchInvalidationCallbacks();
    379 }
    380 
    381 static FontData* fontDataForGenericFamily(Document* document, const FontDescription& fontDescription, const AtomicString& familyName)
    382 {
    383     if (!document || !document->frame())
    384         return 0;
    385 
    386     const Settings* settings = document->frame()->settings();
    387     if (!settings)
    388         return 0;
    389 
    390     AtomicString genericFamily;
    391     if (familyName == "-webkit-serif")
    392         genericFamily = settings->serifFontFamily();
    393     else if (familyName == "-webkit-sans-serif")
    394         genericFamily = settings->sansSerifFontFamily();
    395     else if (familyName == "-webkit-cursive")
    396         genericFamily = settings->cursiveFontFamily();
    397     else if (familyName == "-webkit-fantasy")
    398         genericFamily = settings->fantasyFontFamily();
    399     else if (familyName == "-webkit-monospace")
    400         genericFamily = settings->fixedFontFamily();
    401     else if (familyName == "-webkit-standard")
    402         genericFamily = settings->standardFontFamily();
    403 
    404     if (!genericFamily.isEmpty())
    405         return fontCache()->getCachedFontData(fontDescription, genericFamily);
    406 
    407     return 0;
    408 }
    409 
    410 static FontTraitsMask desiredTraitsMaskForComparison;
    411 
    412 static inline bool compareFontFaces(CSSFontFace* first, CSSFontFace* second)
    413 {
    414     FontTraitsMask firstTraitsMask = first->traitsMask();
    415     FontTraitsMask secondTraitsMask = second->traitsMask();
    416 
    417     bool firstHasDesiredVariant = firstTraitsMask & desiredTraitsMaskForComparison & FontVariantMask;
    418     bool secondHasDesiredVariant = secondTraitsMask & desiredTraitsMaskForComparison & FontVariantMask;
    419 
    420     if (firstHasDesiredVariant != secondHasDesiredVariant)
    421         return firstHasDesiredVariant;
    422 
    423     if ((desiredTraitsMaskForComparison & FontVariantSmallCapsMask) && !first->isLocalFallback() && !second->isLocalFallback()) {
    424         // Prefer a font that has indicated that it can only support small-caps to a font that claims to support
    425         // all variants.  The specialized font is more likely to be true small-caps and not require synthesis.
    426         bool firstRequiresSmallCaps = (firstTraitsMask & FontVariantSmallCapsMask) && !(firstTraitsMask & FontVariantNormalMask);
    427         bool secondRequiresSmallCaps = (secondTraitsMask & FontVariantSmallCapsMask) && !(secondTraitsMask & FontVariantNormalMask);
    428         if (firstRequiresSmallCaps != secondRequiresSmallCaps)
    429             return firstRequiresSmallCaps;
    430     }
    431 
    432     bool firstHasDesiredStyle = firstTraitsMask & desiredTraitsMaskForComparison & FontStyleMask;
    433     bool secondHasDesiredStyle = secondTraitsMask & desiredTraitsMaskForComparison & FontStyleMask;
    434 
    435     if (firstHasDesiredStyle != secondHasDesiredStyle)
    436         return firstHasDesiredStyle;
    437 
    438     if ((desiredTraitsMaskForComparison & FontStyleItalicMask) && !first->isLocalFallback() && !second->isLocalFallback()) {
    439         // Prefer a font that has indicated that it can only support italics to a font that claims to support
    440         // all styles.  The specialized font is more likely to be the one the author wants used.
    441         bool firstRequiresItalics = (firstTraitsMask & FontStyleItalicMask) && !(firstTraitsMask & FontStyleNormalMask);
    442         bool secondRequiresItalics = (secondTraitsMask & FontStyleItalicMask) && !(secondTraitsMask & FontStyleNormalMask);
    443         if (firstRequiresItalics != secondRequiresItalics)
    444             return firstRequiresItalics;
    445     }
    446 
    447     if (secondTraitsMask & desiredTraitsMaskForComparison & FontWeightMask)
    448         return false;
    449     if (firstTraitsMask & desiredTraitsMaskForComparison & FontWeightMask)
    450         return true;
    451 
    452     // http://www.w3.org/TR/2002/WD-css3-webfonts-20020802/#q46 says: "If there are fewer then 9 weights in the family, the default algorithm
    453     // for filling the "holes" is as follows. If '500' is unassigned, it will be assigned the same font as '400'. If any of the values '600',
    454     // '700', '800', or '900' remains unassigned, they are assigned to the same face as the next darker assigned keyword, if any, or the next
    455     // lighter one otherwise. If any of '300', '200', or '100' remains unassigned, it is assigned to the next lighter assigned keyword, if any,
    456     // or the next darker otherwise."
    457     // For '400', we made up our own rule (which then '500' follows).
    458 
    459     static const unsigned fallbackRuleSets = 9;
    460     static const unsigned rulesPerSet = 8;
    461     static const FontTraitsMask weightFallbackRuleSets[fallbackRuleSets][rulesPerSet] = {
    462         { FontWeight200Mask, FontWeight300Mask, FontWeight400Mask, FontWeight500Mask, FontWeight600Mask, FontWeight700Mask, FontWeight800Mask, FontWeight900Mask },
    463         { FontWeight100Mask, FontWeight300Mask, FontWeight400Mask, FontWeight500Mask, FontWeight600Mask, FontWeight700Mask, FontWeight800Mask, FontWeight900Mask },
    464         { FontWeight200Mask, FontWeight100Mask, FontWeight400Mask, FontWeight500Mask, FontWeight600Mask, FontWeight700Mask, FontWeight800Mask, FontWeight900Mask },
    465         { FontWeight500Mask, FontWeight300Mask, FontWeight600Mask, FontWeight200Mask, FontWeight700Mask, FontWeight100Mask, FontWeight800Mask, FontWeight900Mask },
    466         { FontWeight400Mask, FontWeight300Mask, FontWeight600Mask, FontWeight200Mask, FontWeight700Mask, FontWeight100Mask, FontWeight800Mask, FontWeight900Mask },
    467         { FontWeight700Mask, FontWeight800Mask, FontWeight900Mask, FontWeight500Mask, FontWeight400Mask, FontWeight300Mask, FontWeight200Mask, FontWeight100Mask },
    468         { FontWeight800Mask, FontWeight900Mask, FontWeight600Mask, FontWeight500Mask, FontWeight400Mask, FontWeight300Mask, FontWeight200Mask, FontWeight100Mask },
    469         { FontWeight900Mask, FontWeight700Mask, FontWeight600Mask, FontWeight500Mask, FontWeight400Mask, FontWeight300Mask, FontWeight200Mask, FontWeight100Mask },
    470         { FontWeight800Mask, FontWeight700Mask, FontWeight600Mask, FontWeight500Mask, FontWeight400Mask, FontWeight300Mask, FontWeight200Mask, FontWeight100Mask }
    471     };
    472 
    473     unsigned ruleSetIndex = 0;
    474     unsigned w = FontWeight100Bit;
    475     while (!(desiredTraitsMaskForComparison & (1 << w))) {
    476         w++;
    477         ruleSetIndex++;
    478     }
    479 
    480     ASSERT(ruleSetIndex < fallbackRuleSets);
    481     const FontTraitsMask* weightFallbackRule = weightFallbackRuleSets[ruleSetIndex];
    482     for (unsigned i = 0; i < rulesPerSet; ++i) {
    483         if (secondTraitsMask & weightFallbackRule[i])
    484             return false;
    485         if (firstTraitsMask & weightFallbackRule[i])
    486             return true;
    487     }
    488 
    489     return false;
    490 }
    491 
    492 FontData* CSSFontSelector::getFontData(const FontDescription& fontDescription, const AtomicString& familyName)
    493 {
    494     if (m_fontFaces.isEmpty()) {
    495         if (familyName.startsWith("-webkit-"))
    496             return fontDataForGenericFamily(m_document, fontDescription, familyName);
    497         return 0;
    498     }
    499 
    500     String family = familyName.string();
    501 
    502     Vector<RefPtr<CSSFontFace> >* familyFontFaces = m_fontFaces.get(family);
    503     // If no face was found, then return 0 and let the OS come up with its best match for the name.
    504     if (!familyFontFaces || familyFontFaces->isEmpty()) {
    505         // If we were handed a generic family, but there was no match, go ahead and return the correct font based off our
    506         // settings.
    507         return fontDataForGenericFamily(m_document, fontDescription, familyName);
    508     }
    509 
    510     HashMap<unsigned, RefPtr<CSSSegmentedFontFace> >* segmentedFontFaceCache = m_fonts.get(family);
    511     if (!segmentedFontFaceCache) {
    512         segmentedFontFaceCache = new HashMap<unsigned, RefPtr<CSSSegmentedFontFace> >;
    513         m_fonts.set(family, segmentedFontFaceCache);
    514     }
    515 
    516     FontTraitsMask traitsMask = fontDescription.traitsMask();
    517 
    518     RefPtr<CSSSegmentedFontFace> face = segmentedFontFaceCache->get(traitsMask);
    519 
    520     if (!face) {
    521         face = CSSSegmentedFontFace::create(this);
    522         segmentedFontFaceCache->set(traitsMask, face);
    523         // Collect all matching faces and sort them in order of preference.
    524         Vector<CSSFontFace*, 32> candidateFontFaces;
    525         for (int i = familyFontFaces->size() - 1; i >= 0; --i) {
    526             CSSFontFace* candidate = familyFontFaces->at(i).get();
    527             unsigned candidateTraitsMask = candidate->traitsMask();
    528             if ((traitsMask & FontStyleNormalMask) && !(candidateTraitsMask & FontStyleNormalMask))
    529                 continue;
    530             if ((traitsMask & FontVariantNormalMask) && !(candidateTraitsMask & FontVariantNormalMask))
    531                 continue;
    532 #if ENABLE(SVG_FONTS)
    533             // For SVG Fonts that specify that they only support the "normal" variant, we will assume they are incapable
    534             // of small-caps synthesis and just ignore the font face as a candidate.
    535             if (candidate->hasSVGFontFaceSource() && (traitsMask & FontVariantSmallCapsMask) && !(candidateTraitsMask & FontVariantSmallCapsMask))
    536                 continue;
    537 #endif
    538             candidateFontFaces.append(candidate);
    539         }
    540 
    541         if (Vector<RefPtr<CSSFontFace> >* familyLocallyInstalledFontFaces = m_locallyInstalledFontFaces.get(family)) {
    542             unsigned numLocallyInstalledFontFaces = familyLocallyInstalledFontFaces->size();
    543             for (unsigned i = 0; i < numLocallyInstalledFontFaces; ++i) {
    544                 CSSFontFace* candidate = familyLocallyInstalledFontFaces->at(i).get();
    545                 unsigned candidateTraitsMask = candidate->traitsMask();
    546                 if ((traitsMask & FontStyleNormalMask) && !(candidateTraitsMask & FontStyleNormalMask))
    547                     continue;
    548                 if ((traitsMask & FontVariantNormalMask) && !(candidateTraitsMask & FontVariantNormalMask))
    549                     continue;
    550                 candidateFontFaces.append(candidate);
    551             }
    552         }
    553 
    554         desiredTraitsMaskForComparison = traitsMask;
    555         std::stable_sort(candidateFontFaces.begin(), candidateFontFaces.end(), compareFontFaces);
    556         unsigned numCandidates = candidateFontFaces.size();
    557         for (unsigned i = 0; i < numCandidates; ++i)
    558             face->appendFontFace(candidateFontFaces[i]);
    559     }
    560 
    561     // We have a face.  Ask it for a font data.  If it cannot produce one, it will fail, and the OS will take over.
    562     return face->getFontData(fontDescription);
    563 }
    564 
    565 }
    566