Changeset 188853 in webkit


Ignore:
Timestamp:
Aug 24, 2015 1:06:00 AM (9 years ago)
Author:
mmaxfield@apple.com
Message:

@font-face related cleanup
​https://bugs.webkit.org/show_bug.cgi?id=148355

Reviewed by Darin Adler.

This patch cleans up much of our code related to web fonts. In general, it
migrates to using C++ for-each style loops, uses Ref instead of RefPtr when
things can't be nullptr, migrates to C++ Rvalue-references instead of
PassRefPtr, and refactors CSSFontSelector::addFontFaceRule() to use helper
functions.

No new tests because there is no behavior change.

  • css/CSSFontFace.cpp:

(WebCore::CSSFontFace::fontLoaded): Use a C++ for-each loop.

  • css/CSSFontFace.h:

(WebCore::CSSFontFace::create): Use C++ Rvalue-references instead of
PassRefPtr.
(WebCore::CSSFontFace::CSSFontFace): Ditto.

  • css/CSSFontSelector.cpp:

(WebCore::computeTraitsMask): Migrated a chunk of
CSSFontSelector::addFontFaceRule() into this helper function.
(WebCore::createFontFace): Ditto.
(WebCore::familyNameFromPrimitive): Ditto.
(WebCore::CSSFontSelector::addFontFaceRule): Call the newly-created helper
functions. In addition, migrate to Refs instead of RefPtrs.
(WebCore::compareFontFaces): Migrate to references instead of pointers.
(WebCore::CSSFontSelector::getFontFace): Migrate to Refs instead of
RefPtrs. Also use C++ for-each loops.

  • css/CSSFontSelector.h:
  • css/CSSSegmentedFontFace.cpp:

(WebCore::CSSSegmentedFontFace::~CSSSegmentedFontFace): Use C++ for-each
loops.
(WebCore::CSSSegmentedFontFace::isValid): Ditto.
(WebCore::CSSSegmentedFontFace::appendFontFace): Migrate to Rvalue-
references instead of PassRefPtr.

  • css/CSSSegmentedFontFace.h:
  • platform/graphics/FontCache.h:
  • platform/graphics/cocoa/FontCacheCoreText.cpp:

(WebCore::FontCache::getTraitsInFamily): Return the result instead of being
passed an out parameter.

  • platform/graphics/freetype/FontCacheFreeType.cpp:

(WebCore::FontCache::getTraitsInFamily): Ditto.

  • platform/graphics/win/FontCacheWin.cpp:

(WebCore::traitsInFamilyEnumProc): Ditto.
(WebCore::FontCache::getTraitsInFamily): Ditto.

Location:
trunk/Source/WebCore
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r188851 r188853  
     12015-08-24  Myles C. Maxfield  <mmaxfield@apple.com>
     2
     3        @font-face related cleanup
     4        https://bugs.webkit.org/show_bug.cgi?id=148355
     5
     6        Reviewed by Darin Adler.
     7
     8        This patch cleans up much of our code related to web fonts. In general, it
     9        migrates to using C++ for-each style loops, uses Ref instead of RefPtr when
     10        things can't be nullptr, migrates to C++ Rvalue-references instead of
     11        PassRefPtr, and refactors CSSFontSelector::addFontFaceRule() to use helper
     12        functions.
     13
     14        No new tests because there is no behavior change.
     15
     16        * css/CSSFontFace.cpp:
     17        (WebCore::CSSFontFace::fontLoaded): Use a C++ for-each loop.
     18        * css/CSSFontFace.h:
     19        (WebCore::CSSFontFace::create): Use C++ Rvalue-references instead of
     20        PassRefPtr.
     21        (WebCore::CSSFontFace::CSSFontFace): Ditto.
     22        * css/CSSFontSelector.cpp:
     23        (WebCore::computeTraitsMask): Migrated a chunk of
     24        CSSFontSelector::addFontFaceRule() into this helper function.
     25        (WebCore::createFontFace): Ditto.
     26        (WebCore::familyNameFromPrimitive): Ditto.
     27        (WebCore::CSSFontSelector::addFontFaceRule): Call the newly-created helper
     28        functions. In addition, migrate to Refs instead of RefPtrs.
     29        (WebCore::compareFontFaces): Migrate to references instead of pointers.
     30        (WebCore::CSSFontSelector::getFontFace): Migrate to Refs instead of
     31        RefPtrs. Also use C++ for-each loops.
     32        * css/CSSFontSelector.h:
     33        * css/CSSSegmentedFontFace.cpp:
     34        (WebCore::CSSSegmentedFontFace::~CSSSegmentedFontFace): Use C++ for-each
     35        loops.
     36        (WebCore::CSSSegmentedFontFace::isValid): Ditto.
     37        (WebCore::CSSSegmentedFontFace::appendFontFace): Migrate to Rvalue-
     38        references instead of PassRefPtr.
     39        * css/CSSSegmentedFontFace.h:
     40        * platform/graphics/FontCache.h:
     41        * platform/graphics/cocoa/FontCacheCoreText.cpp:
     42        (WebCore::FontCache::getTraitsInFamily): Return the result instead of being
     43        passed an out parameter.
     44        * platform/graphics/freetype/FontCacheFreeType.cpp:
     45        (WebCore::FontCache::getTraitsInFamily): Ditto.
     46        * platform/graphics/win/FontCacheWin.cpp:
     47        (WebCore::traitsInFamilyEnumProc): Ditto.
     48        (WebCore::FontCache::getTraitsInFamily): Ditto.
     49
    1502015-08-23  Andy Estes  <aestes@apple.com>
    251

  • trunk/Source/WebCore/css/CSSFontFace.cpp

    r178940 r188853  
    9999#endif
    100100
    101     HashSet<CSSSegmentedFontFace*>::iterator end = m_segmentedFontFaces.end();
    102     for (HashSet<CSSSegmentedFontFace*>::iterator it = m_segmentedFontFaces.begin(); it != end; ++it)
    103         (*it)->fontLoaded(this);
     101    for (auto* face : m_segmentedFontFaces)
     102        face->fontLoaded(this);
    104103
    105104#if ENABLE(FONT_LOAD_EVENTS)

  • trunk/Source/WebCore/css/CSSFontFace.h

    r185238 r188853  
    4545class CSSFontFace : public RefCounted<CSSFontFace> {
    4646public:
    47     static Ref<CSSFontFace> create(FontTraitsMask traitsMask, PassRefPtr<CSSFontFaceRule> rule, bool isLocalFallback = false) { return adoptRef(*new CSSFontFace(traitsMask, rule, isLocalFallback)); }
     47    static Ref<CSSFontFace> create(FontTraitsMask traitsMask, RefPtr<CSSFontFaceRule>&& rule, bool isLocalFallback = false) { return adoptRef(*new CSSFontFace(traitsMask, WTF::move(rule), isLocalFallback)); }
    4848
    4949    FontTraitsMask traitsMask() const { return m_traitsMask; }
    … …  
    9393
    9494private:
    95     CSSFontFace(FontTraitsMask traitsMask, PassRefPtr<CSSFontFaceRule> rule, bool isLocalFallback)
     95    CSSFontFace(FontTraitsMask traitsMask, RefPtr<CSSFontFaceRule>&& rule, bool isLocalFallback)
    9696        : m_traitsMask(traitsMask)
    9797        , m_activeSource(0)

  • trunk/Source/WebCore/css/CSSFontSelector.cpp

    r187569 r188853  
    8585}
    8686
    87 void CSSFontSelector::addFontFaceRule(const StyleRuleFontFace* fontFaceRule, bool isInitiatingElementInUserAgentShadowTree)
    88 {
    89     // Obtain the font-family property and the src property.  Both must be defined.
    90     const StyleProperties& style = fontFaceRule->properties();
    91     RefPtr<CSSValue> fontFamily = style.getPropertyCSSValue(CSSPropertyFontFamily);
    92     RefPtr<CSSValue> src = style.getPropertyCSSValue(CSSPropertySrc);
    93     RefPtr<CSSValue> unicodeRange = style.getPropertyCSSValue(CSSPropertyUnicodeRange);
    94     if (!is<CSSValueList>(fontFamily.get()) || !is<CSSValueList>(src.get()) || (unicodeRange && !is<CSSValueList>(*unicodeRange)))
    95         return;
    96 
    97     CSSValueList& familyList = downcast<CSSValueList>(*fontFamily);
    98     if (!familyList.length())
    99         return;
    100 
    101     CSSValueList& srcList = downcast<CSSValueList>(*src);
    102     if (!srcList.length())
    103         return;
    104 
    105     CSSValueList* rangeList = downcast<CSSValueList>(unicodeRange.get());
    106 
     87static Optional<FontTraitsMask> computeTraitsMask(const StyleProperties& style)
     88{
    10789    unsigned traitsMask = 0;
    10890
    10991    if (RefPtr<CSSValue> fontStyle = style.getPropertyCSSValue(CSSPropertyFontStyle)) {
    11092        if (!is<CSSPrimitiveValue>(*fontStyle))
    111             return;
     93            return Nullopt;
    11294
    11395        switch (downcast<CSSPrimitiveValue>(*fontStyle).getValueID()) {
    … …  
    127109    if (RefPtr<CSSValue> fontWeight = style.getPropertyCSSValue(CSSPropertyFontWeight)) {
    128110        if (!is<CSSPrimitiveValue>(*fontWeight))
    129             return;
     111            return Nullopt;
    130112
    131113        switch (downcast<CSSPrimitiveValue>(*fontWeight).getValueID()) {
    … …  
    172154            fontVariant = list.releaseNonNull();
    173155        } else if (!is<CSSValueList>(*fontVariant))
    174             return;
     156            return Nullopt;
    175157
    176158        CSSValueList& variantList = downcast<CSSValueList>(*fontVariant);
    177159        unsigned numVariants = variantList.length();
    178160        if (!numVariants)
    179             return;
     161            return Nullopt;
    180162
    181163        for (unsigned i = 0; i < numVariants; ++i) {
    … …  
    194176        traitsMask |= FontVariantMask;
    195177
    196     // Each item in the src property's list is a single CSSFontFaceSource. Put them all into a CSSFontFace.
    197     RefPtr<CSSFontFace> fontFace;
     178    return static_cast<FontTraitsMask>(traitsMask);
     179}
     180
     181static Ref<CSSFontFace> createFontFace(CSSValueList& srcList, FontTraitsMask traitsMask, Document* document, const StyleRuleFontFace* fontFaceRule, bool isInitiatingElementInUserAgentShadowTree)
     182{
     183    RefPtr<CSSFontFaceRule> rule;
     184#if ENABLE(FONT_LOAD_EVENTS)
     185    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=112116 - This CSSFontFaceRule has no parent.
     186    if (RuntimeEnabledFeatures::sharedFeatures().fontLoadEventsEnabled())
     187        rule = static_pointer_cast<CSSFontFaceRule>(fontFaceRule->createCSSOMWrapper());
     188#else
     189    UNUSED_PARAM(fontFaceRule);
     190#endif
     191    Ref<CSSFontFace> fontFace = CSSFontFace::create(traitsMask, WTF::move(rule));
    198192
    199193    int srcLength = srcList.length();
    … …  
    210204#endif
    211205        if (!item.isLocal()) {
    212             Settings* settings = m_document ? m_document->frame() ? &m_document->frame()->settings() : 0 : 0;
     206            Settings* settings = document ? document->frame() ? &document->frame()->settings() : 0 : 0;
    213207            bool allowDownloading = foundSVGFont || (settings && settings->downloadableBinaryFontsEnabled());
    214             if (allowDownloading && item.isSupportedFormat() && m_document) {
    215                 CachedFont* cachedFont = item.cachedFont(m_document, foundSVGFont, isInitiatingElementInUserAgentShadowTree);
     208            if (allowDownloading && item.isSupportedFormat() && document) {
     209                CachedFont* cachedFont = item.cachedFont(document, foundSVGFont, isInitiatingElementInUserAgentShadowTree);
    216210                if (cachedFont) {
    217211                    source = std::make_unique<CSSFontFaceSource>(item.resource(), cachedFont);
    … …  
    226220        }
    227221
    228         if (!fontFace) {
    229             RefPtr<CSSFontFaceRule> rule;
    230 #if ENABLE(FONT_LOAD_EVENTS)
    231             // FIXME: https://bugs.webkit.org/show_bug.cgi?id=112116 - This CSSFontFaceRule has no parent.
    232             if (RuntimeEnabledFeatures::sharedFeatures().fontLoadEventsEnabled())
    233                 rule = static_pointer_cast<CSSFontFaceRule>(fontFaceRule->createCSSOMWrapper());
    234 #endif
    235             fontFace = CSSFontFace::create(static_cast<FontTraitsMask>(traitsMask), rule);
    236         }
    237 
    238222        if (source) {
    239223#if ENABLE(SVG_FONTS)
    … …  
    244228    }
    245229
    246     ASSERT(fontFace);
    247 
    248     if (fontFace && !fontFace->isValid())
     230    return fontFace;
     231}
     232
     233static String familyNameFromPrimitive(const CSSPrimitiveValue& value)
     234{
     235    if (value.isFontFamily())
     236        return value.fontFamily().familyName;
     237    if (!value.isValueID())
     238        return { };
     239
     240    // We need to use the raw text for all the generic family types, since @font-face is a way of actually
     241    // defining what font to use for those types.
     242    switch (value.getValueID()) {
     243    case CSSValueSerif:
     244        return serifFamily;
     245    case CSSValueSansSerif:
     246        return sansSerifFamily;
     247    case CSSValueCursive:
     248        return cursiveFamily;
     249    case CSSValueFantasy:
     250        return fantasyFamily;
     251    case CSSValueMonospace:
     252        return monospaceFamily;
     253    case CSSValueWebkitPictograph:
     254        return pictographFamily;
     255    default:
     256        return { };
     257    }
     258}
     259
     260static Vector<Ref<CSSFontFace>> constructFamilyFontFaces(const String& familyName, HashMap<String, Vector<Ref<CSSFontFace>>, CaseFoldingHash>& locallyInstalledFontFaces)
     261{
     262    auto result = Vector<Ref<CSSFontFace>>();
     263
     264    ASSERT(!locallyInstalledFontFaces.contains(familyName));
     265
     266    Vector<FontTraitsMask> traitsMasks = FontCache::singleton().getTraitsInFamily(familyName);
     267    if (!traitsMasks.isEmpty()) {
     268        Vector<Ref<CSSFontFace>> faces = { };
     269        for (auto mask : traitsMasks) {
     270            Ref<CSSFontFace> face = CSSFontFace::create(mask, nullptr, true);
     271            face->addSource(std::make_unique<CSSFontFaceSource>(familyName));
     272            ASSERT(face->isValid());
     273            faces.append(WTF::move(face));
     274        }
     275        locallyInstalledFontFaces.add(familyName, WTF::move(faces));
     276    }
     277    return result;
     278}
     279
     280void CSSFontSelector::addFontFaceRule(const StyleRuleFontFace* fontFaceRule, bool isInitiatingElementInUserAgentShadowTree)
     281{
     282    const StyleProperties& style = fontFaceRule->properties();
     283    RefPtr<CSSValue> fontFamily = style.getPropertyCSSValue(CSSPropertyFontFamily);
     284    RefPtr<CSSValue> src = style.getPropertyCSSValue(CSSPropertySrc);
     285    RefPtr<CSSValue> unicodeRange = style.getPropertyCSSValue(CSSPropertyUnicodeRange);
     286    if (!is<CSSValueList>(fontFamily.get()) || !is<CSSValueList>(src.get()) || (unicodeRange && !is<CSSValueList>(*unicodeRange)))
     287        return;
     288
     289    CSSValueList& familyList = downcast<CSSValueList>(*fontFamily);
     290    if (!familyList.length())
     291        return;
     292
     293    CSSValueList& srcList = downcast<CSSValueList>(*src);
     294    if (!srcList.length())
     295        return;
     296
     297    CSSValueList* rangeList = downcast<CSSValueList>(unicodeRange.get());
     298
     299    auto computedTraitsMask = computeTraitsMask(style);
     300    if (!computedTraitsMask)
     301        return;
     302    auto traitsMask = computedTraitsMask.value();
     303
     304    Ref<CSSFontFace> fontFace = createFontFace(srcList, traitsMask, m_document, fontFaceRule, isInitiatingElementInUserAgentShadowTree);
     305    if (!fontFace->isValid())
    249306        return;
    250307
    … …  
    257314    }
    258315
    259     // Hash under every single family name.
    260316    for (auto& item : familyList) {
    261         auto& value = downcast<CSSPrimitiveValue>(item.get());
    262         String familyName;
    263         if (value.isFontFamily()) {
    264             familyName = value.fontFamily().familyName;
    265         } else if (value.isValueID()) {
    266             // We need to use the raw text for all the generic family types, since @font-face is a way of actually
    267             // defining what font to use for those types.
    268             switch (value.getValueID()) {
    269                 case CSSValueSerif:
    270                     familyName = serifFamily;
    271                     break;
    272                 case CSSValueSansSerif:
    273                     familyName = sansSerifFamily;
    274                     break;
    275                 case CSSValueCursive:
    276                     familyName = cursiveFamily;
    277                     break;
    278                 case CSSValueFantasy:
    279                     familyName = fantasyFamily;
    280                     break;
    281                 case CSSValueMonospace:
    282                     familyName = monospaceFamily;
    283                     break;
    284                 case CSSValueWebkitPictograph:
    285                     familyName = pictographFamily;
    286                     break;
    287                 default:
    288                     break;
    289             }
    290         }
    291 
     317        String familyName = familyNameFromPrimitive(downcast<CSSPrimitiveValue>(item.get()));
    292318        if (familyName.isEmpty())
    293319            continue;
    294320
    295         std::unique_ptr<Vector<RefPtr<CSSFontFace>>>& familyFontFaces = m_fontFaces.add(familyName, nullptr).iterator->value;
    296         if (!familyFontFaces) {
    297             familyFontFaces = std::make_unique<Vector<RefPtr<CSSFontFace>>>();
    298 
    299             ASSERT(!m_locallyInstalledFontFaces.contains(familyName));
    300 
    301             Vector<unsigned> locallyInstalledFontsTraitsMasks;
    302             FontCache::singleton().getTraitsInFamily(familyName, locallyInstalledFontsTraitsMasks);
    303             if (unsigned numLocallyInstalledFaces = locallyInstalledFontsTraitsMasks.size()) {
    304                 auto familyLocallyInstalledFaces = std::make_unique<Vector<RefPtr<CSSFontFace>>>();
    305 
    306                 for (unsigned i = 0; i < numLocallyInstalledFaces; ++i) {
    307                     RefPtr<CSSFontFace> locallyInstalledFontFace = CSSFontFace::create(static_cast<FontTraitsMask>(locallyInstalledFontsTraitsMasks[i]), 0, true);
    308                     locallyInstalledFontFace->addSource(std::make_unique<CSSFontFaceSource>(familyName));
    309                     ASSERT(locallyInstalledFontFace->isValid());
    310                     familyLocallyInstalledFaces->append(locallyInstalledFontFace);
    311                 }
    312 
    313                 m_locallyInstalledFontFaces.set(familyName, WTF::move(familyLocallyInstalledFaces));
    314             }
    315         }
    316 
    317         familyFontFaces->append(fontFace);
     321        auto addResult = m_fontFaces.add(familyName, Vector<Ref<CSSFontFace>>());
     322        auto& familyFontFaces = addResult.iterator->value;
     323        if (addResult.isNewEntry)
     324            familyFontFaces = constructFamilyFontFaces(familyName, m_locallyInstalledFontFaces);
     325
     326        familyFontFaces.append(fontFace.copyRef());
    318327       
    319328        ++m_version;
    … …  
    379388static FontTraitsMask desiredTraitsMaskForComparison;
    380389
    381 static inline bool compareFontFaces(CSSFontFace* first, CSSFontFace* second)
    382 {
    383     FontTraitsMask firstTraitsMask = first->traitsMask();
    384     FontTraitsMask secondTraitsMask = second->traitsMask();
     390static inline bool compareFontFaces(const CSSFontFace& first, const CSSFontFace& second)
     391{
     392    FontTraitsMask firstTraitsMask = first.traitsMask();
     393    FontTraitsMask secondTraitsMask = second.traitsMask();
    385394
    386395    bool firstHasDesiredVariant = firstTraitsMask & desiredTraitsMaskForComparison & FontVariantMask;
    … …  
    391400
    392401    // We need to check font-variant css property for CSS2.1 compatibility.
    393     if ((desiredTraitsMaskForComparison & FontVariantSmallCapsMask) && !first->isLocalFallback() && !second->isLocalFallback()) {
     402    if ((desiredTraitsMaskForComparison & FontVariantSmallCapsMask) && !first.isLocalFallback() && !second.isLocalFallback()) {
    394403        // Prefer a font that has indicated that it can only support small-caps to a font that claims to support
    395404        // all variants.  The specialized font is more likely to be true small-caps and not require synthesis.
    … …  
    406415        return firstHasDesiredStyle;
    407416
    408     if ((desiredTraitsMaskForComparison & FontStyleItalicMask) && !first->isLocalFallback() && !second->isLocalFallback()) {
     417    if ((desiredTraitsMaskForComparison & FontStyleItalicMask) && !first.isLocalFallback() && !second.isLocalFallback()) {
    409418        // Prefer a font that has indicated that it can only support italics to a font that claims to support
    410419        // all styles.  The specialized font is more likely to be the one the author wants used.
    … …  
    477486CSSSegmentedFontFace* CSSFontSelector::getFontFace(const FontDescription& fontDescription, const AtomicString& family)
    478487{
    479     Vector<RefPtr<CSSFontFace>>* familyFontFaces = m_fontFaces.get(family);
    480     if (!familyFontFaces || familyFontFaces->isEmpty())
    481         return 0;
    482 
    483     std::unique_ptr<HashMap<unsigned, RefPtr<CSSSegmentedFontFace>>>& segmentedFontFaceCache = m_fonts.add(family, nullptr).iterator->value;
    484     if (!segmentedFontFaceCache)
    485         segmentedFontFaceCache = std::make_unique<HashMap<unsigned, RefPtr<CSSSegmentedFontFace>>>();
     488    auto iterator = m_fontFaces.find(family);
     489    if (iterator == m_fontFaces.end())
     490        return nullptr;
     491    auto& familyFontFaces = iterator->value;
     492
     493    auto& segmentedFontFaceCache = m_fonts.add(family, HashMap<unsigned, RefPtr<CSSSegmentedFontFace>>()).iterator->value;
    486494
    487495    FontTraitsMask traitsMask = fontDescription.traitsMask();
    488496
    489     RefPtr<CSSSegmentedFontFace>& face = segmentedFontFaceCache->add(traitsMask, nullptr).iterator->value;
     497    RefPtr<CSSSegmentedFontFace>& face = segmentedFontFaceCache.add(traitsMask, nullptr).iterator->value;
    490498    if (!face) {
    491499        face = CSSSegmentedFontFace::create(this);
    492500
    493         // Collect all matching faces and sort them in order of preference.
    494         Vector<CSSFontFace*, 32> candidateFontFaces;
    495         for (int i = familyFontFaces->size() - 1; i >= 0; --i) {
    496             CSSFontFace* candidate = familyFontFaces->at(i).get();
    497             unsigned candidateTraitsMask = candidate->traitsMask();
     501        Vector<std::reference_wrapper<CSSFontFace>, 32> candidateFontFaces;
     502        for (int i = familyFontFaces.size() - 1; i >= 0; --i) {
     503            CSSFontFace& candidate = familyFontFaces[i];
     504            unsigned candidateTraitsMask = candidate.traitsMask();
    498505            if ((traitsMask & FontStyleNormalMask) && !(candidateTraitsMask & FontStyleNormalMask))
    499506                continue;
    … …  
    503510            // For SVG Fonts that specify that they only support the "normal" variant, we will assume they are incapable
    504511            // of small-caps synthesis and just ignore the font face as a candidate.
    505             if (candidate->hasSVGFontFaceSource() && (traitsMask & FontVariantSmallCapsMask) && !(candidateTraitsMask & FontVariantSmallCapsMask))
     512            if (candidate.hasSVGFontFaceSource() && (traitsMask & FontVariantSmallCapsMask) && !(candidateTraitsMask & FontVariantSmallCapsMask))
    506513                continue;
    507514#endif
    … …  
    509516        }
    510517
    511         if (Vector<RefPtr<CSSFontFace>>* familyLocallyInstalledFontFaces = m_locallyInstalledFontFaces.get(family)) {
    512             unsigned numLocallyInstalledFontFaces = familyLocallyInstalledFontFaces->size();
    513             for (unsigned i = 0; i < numLocallyInstalledFontFaces; ++i) {
    514                 CSSFontFace* candidate = familyLocallyInstalledFontFaces->at(i).get();
     518        auto iterator = m_locallyInstalledFontFaces.find(family);
     519        if (iterator != m_locallyInstalledFontFaces.end()) {
     520            for (auto& candidate : iterator->value) {
    515521                unsigned candidateTraitsMask = candidate->traitsMask();
    516522                if ((traitsMask & FontStyleNormalMask) && !(candidateTraitsMask & FontStyleNormalMask))
    … …  
    524530        desiredTraitsMaskForComparison = traitsMask;
    525531        std::stable_sort(candidateFontFaces.begin(), candidateFontFaces.end(), compareFontFaces);
    526         unsigned numCandidates = candidateFontFaces.size();
    527         for (unsigned i = 0; i < numCandidates; ++i)
    528             face->appendFontFace(candidateFontFaces[i]);
     532        for (auto& candidate : candidateFontFaces)
     533            face->appendFontFace(candidate.get());
    529534    }
    530535    return face.get();

  • trunk/Source/WebCore/css/CSSFontSelector.h

    r186388 r188853  
    9090
    9191    Document* m_document;
    92     HashMap<String, std::unique_ptr<Vector<RefPtr<CSSFontFace>>>, CaseFoldingHash> m_fontFaces;
    93     HashMap<String, std::unique_ptr<Vector<RefPtr<CSSFontFace>>>, CaseFoldingHash> m_locallyInstalledFontFaces;
    94     HashMap<String, std::unique_ptr<HashMap<unsigned, RefPtr<CSSSegmentedFontFace>>>, CaseFoldingHash> m_fonts;
     92    HashMap<String, Vector<Ref<CSSFontFace>>, CaseFoldingHash> m_fontFaces;
     93    HashMap<String, Vector<Ref<CSSFontFace>>, CaseFoldingHash> m_locallyInstalledFontFaces;
     94    HashMap<String, HashMap<unsigned, RefPtr<CSSSegmentedFontFace>>, CaseFoldingHash> m_fonts;
    9595    HashSet<FontSelectorClient*> m_clients;
    9696

  • trunk/Source/WebCore/css/CSSSegmentedFontFace.cpp

    r188114 r188853  
    4646{
    4747    pruneTable();
    48     unsigned size = m_fontFaces.size();
    49     for (unsigned i = 0; i < size; i++)
    50         m_fontFaces[i]->removedFromSegmentedFontFace(this);
     48    for (auto& face : m_fontFaces)
     49        face->removedFromSegmentedFontFace(this);
    5150}
    5251
    … …  
    5958{
    6059    // Valid if at least one font face is valid.
    61     unsigned size = m_fontFaces.size();
    62     for (unsigned i = 0; i < size; i++) {
    63         if (m_fontFaces[i]->isValid())
     60    for (auto& face : m_fontFaces) {
     61        if (face->isValid())
    6462            return true;
    6563    }
    … …  
    8583}
    8684
    87 void CSSSegmentedFontFace::appendFontFace(PassRefPtr<CSSFontFace> fontFace)
     85void CSSSegmentedFontFace::appendFontFace(Ref<CSSFontFace>&& fontFace)
    8886{
    8987    pruneTable();
    9088    fontFace->addedToSegmentedFontFace(this);
    91     m_fontFaces.append(fontFace);
     89    m_fontFaces.append(WTF::move(fontFace));
    9290}
    9391

  • trunk/Source/WebCore/css/CSSSegmentedFontFace.h

    r188114 r188853  
    4949    void fontLoaded(CSSFontFace*);
    5050
    51     void appendFontFace(PassRefPtr<CSSFontFace>);
     51    void appendFontFace(Ref<CSSFontFace>&&);
    5252
    5353    FontRanges fontRanges(const FontDescription&);
    … …  
    7676    CSSFontSelector* m_fontSelector;
    7777    HashMap<FontDescriptionKey, FontRanges, FontDescriptionKeyHash, WTF::SimpleClassHashTraits<FontDescriptionKey>> m_descriptionToRangesMap;
    78     Vector<RefPtr<CSSFontFace>, 1> m_fontFaces;
     78    Vector<Ref<CSSFontFace>, 1> m_fontFaces;
    7979#if ENABLE(FONT_LOAD_EVENTS)
    8080    Vector<RefPtr<LoadFontCallback>> m_callbacks;

  • trunk/Source/WebCore/css/StyleProperties.cpp

    r188619 r188853  
    584584    int foundPropertyIndex = findPropertyIndex(propertyID);
    585585    if (foundPropertyIndex == -1)
    586         return 0;
     586        return nullptr;
    587587    return propertyAt(foundPropertyIndex).value();
    588588}

  • trunk/Source/WebCore/platform/graphics/FontCache.h

    r188795 r188853  
    167167    // This function exists so CSSFontSelector can have a unified notion of preinstalled fonts and @font-face.
    168168    // It comes into play when you create an @font-face which shares a family name as a preinstalled font.
    169     void getTraitsInFamily(const AtomicString&, Vector<unsigned>&);
     169    Vector<FontTraitsMask> getTraitsInFamily(const AtomicString&);
    170170
    171171    WEBCORE_EXPORT RefPtr<Font> fontForFamily(const FontDescription&, const AtomicString&, bool checkingAlternateName = false);

  • trunk/Source/WebCore/platform/graphics/cocoa/FontCacheCoreText.cpp

    r188795 r188853  
    238238}
    239239
    240 void FontCache::getTraitsInFamily(const AtomicString& familyName, Vector<unsigned>& traitsMasks)
     240Vector<FontTraitsMask> FontCache::getTraitsInFamily(const AtomicString& familyName)
    241241{
    242242    RetainPtr<CFStringRef> familyNameStr = familyName.string().createCFString();
    … …  
    246246    RetainPtr<CFArrayRef> matchedDescriptors = adoptCF(CTFontDescriptorCreateMatchingFontDescriptors(fontDescriptor.get(), nullptr));
    247247    if (!matchedDescriptors)
    248         return;
     248        return { };
    249249
    250250    CFIndex numMatches = CFArrayGetCount(matchedDescriptors.get());
    251251    if (!numMatches)
    252         return;
    253 
     252        return { };
     253
     254    Vector<FontTraitsMask> traitsMasks;
     255    traitsMasks.reserveInitialCapacity(numMatches);
    254256    for (CFIndex i = 0; i < numMatches; ++i) {
    255257        RetainPtr<CFDictionaryRef> traits = adoptCF((CFDictionaryRef)CTFontDescriptorCopyAttribute((CTFontDescriptorRef)CFArrayGetValueAtIndex(matchedDescriptors.get(), i), kCTFontTraitsAttribute));
    … …  
    261263            CGFloat weight = 0;
    262264            CFNumberGetValue(weightRef, kCFNumberCGFloatType, &weight);
    263             traitsMasks.append(toTraitsMask(symbolicTraits, weight));
    264         }
    265     }
    266 }
    267 
    268 }
     265            traitsMasks.uncheckedAppend(toTraitsMask(symbolicTraits, weight));
     266        }
     267    }
     268    return traitsMasks;
     269}
     270
     271}

  • trunk/Source/WebCore/platform/graphics/freetype/FontCacheFreeType.cpp

    r187583 r188853  
    138138}
    139139
    140 void FontCache::getTraitsInFamily(const AtomicString&, Vector<unsigned>&)
    141 {
     140Vector<FontTraitsMask> FontCache::getTraitsInFamily(const AtomicString&)
     141{
     142    return { };
    142143}
    143144

  • trunk/Source/WebCore/platform/graphics/win/FontCacheWin.cpp

    r187249 r188853  
    543543    return 1;
    544544}
    545 void FontCache::getTraitsInFamily(const AtomicString& familyName, Vector<unsigned>& traitsMasks)
     545Vector<FontTraitsMask> FontCache::getTraitsInFamily(const AtomicString& familyName)
    546546{
    547547    HWndDC hdc(0);
    … …  
    556556    TraitsInFamilyProcData procData(familyName);
    557557    EnumFontFamiliesEx(hdc, &logFont, traitsInFamilyEnumProc, reinterpret_cast<LPARAM>(&procData), 0);
    558     copyToVector(procData.m_traitsMasks, traitsMasks);
     558    Vector<FontTraitsMask> result;
     559    result.reserveInitialCapacity(procData.m_traitsMasks.size());
     560    for (unsigned mask : procData.m_traitsMasks)
     561        result.uncheckedAppend(static_cast<FontTraitsMask>(mask));
     562    return result;
    559563}
    560564
Note: See TracChangeset for help on using the changeset viewer.