Source/WebCore/css/CSSFontSelector.cpp

   1 /*
   2  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   3  *           (C) 2007, 2008 Nikolas Zimmermann <zimmermann@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 }