⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 201570 in webkit


Ignore:
Timestamp:
Jun 1, 2016, 2:40:16 PM (10 years ago)
Author:
Ryan Haddad
Message:

Unreviewed, rolling out r201551 and r201552.
​https://bugs.webkit.org/show_bug.cgi?id=158275

This change caused 3 API tests to crash on ios-simulator
(Requested by ryanhaddad on #webkit).

Reverted changesets:

"Precache primary font in a secondary thread"
​https://bugs.webkit.org/show_bug.cgi?id=158243
​http://trac.webkit.org/changeset/201551

"Remove accidental fprintf."
​http://trac.webkit.org/changeset/201552

Patch by Commit Queue <​commit-queue@webkit.org> on 2016-06-01

Location:
trunk/Source/WebCore
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r201568 r201570  
     12016-06-01  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r201551 and r201552.
     4        https://bugs.webkit.org/show_bug.cgi?id=158275
     5
     6        This change caused 3 API tests to crash on ios-simulator
     7        (Requested by ryanhaddad on #webkit).
     8
     9        Reverted changesets:
     10
     11        "Precache primary font in a secondary thread"
     12        https://bugs.webkit.org/show_bug.cgi?id=158243
     13        http://trac.webkit.org/changeset/201551
     14
     15        "Remove accidental fprintf."
     16        http://trac.webkit.org/changeset/201552
     17
    1182016-06-01  Chris Fleizach  <cfleizach@apple.com>
    219

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

    r201551 r201570  
    521521}
    522522
    523 Vector<ResolvedFontFamily> CSSFontFace::resolveFamilies() const
    524 {
    525     Vector<ResolvedFontFamily> result;
    526     for (auto& source : m_sources) {
    527         if (source->familyNameOrURI().isEmpty())
    528             continue;
    529         if (source->status() == CSSFontFaceSource::Status::Failure)
    530             continue;
    531         result.append({ source->familyNameOrURI(), source->url() });
    532     }
    533     return result;
    534 }
    535 
    536523#if ENABLE(SVG_FONTS)
    537524bool CSSFontFace::hasSVGFontFaceSource() const

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

    r201551 r201570  
    2828#include "CSSFontFaceRule.h"
    2929#include "FontFeatureSettings.h"
    30 #include "FontSelector.h"
    3130#include "TextFlags.h"
    3231#include <memory>
    … …  
    137136    Ref<FontFace> wrapper();
    138137
    139     Vector<ResolvedFontFamily> resolveFamilies() const;
    140 
    141138#if ENABLE(SVG_FONTS)
    142139    bool hasSVGFontFaceSource() const;

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

    r201551 r201570  
    189189}
    190190
    191 Optional<URL> CSSFontFaceSource::url() const
    192 {
    193     if (!m_font)
    194         return Nullopt;
    195     return m_font->url();
    196 }
    197 
    198191#if ENABLE(SVG_FONTS)
    199192bool CSSFontFaceSource::isSVGFontFaceSource() const

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

    r201551 r201570  
    2929#include "CachedFontClient.h"
    3030#include "CachedResourceHandle.h"
    31 #include "URL.h"
    3231#include <runtime/ArrayBufferView.h>
    3332#include <wtf/text/AtomicString.h>
    … …  
    7372#endif
    7473
    75     Optional<URL> url() const;
    76 
    7774private:
    7875    void fontLoaded(CachedFont&) override;

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

    r201551 r201570  
    335335}
    336336
    337 Vector<ResolvedFontFamily> CSSFontSelector::resolveFamilies(const Vector<AtomicString>& families, const FontDescription& fontDescription, UChar32 character)
    338 {
    339     Vector<ResolvedFontFamily> result;
    340 
    341     for (auto& family : families) {
    342         if (family.isEmpty())
    343             continue;
    344         auto* segmentedFace = m_cssFontFaceSet->getFontFace(fontDescription.traitsMask(), family);
    345         if (!segmentedFace) {
    346             result.append({ resolveGenericFamily(m_document, fontDescription, family), { } });
    347             continue;
    348         }
    349         result.appendVector(segmentedFace->resolveFamilies(character));
    350     }
    351 
    352     return result;
    353 }
    354 
    355 }
     337}

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

    r201551 r201570  
    6565    RefPtr<Font> fallbackFontAt(const FontDescription&, size_t) override;
    6666
    67     Vector<ResolvedFontFamily> resolveFamilies(const Vector<AtomicString>&, const FontDescription&, UChar32) override;
    68 
    6967    void clearDocument();
    7068

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

    r201551 r201570  
    139139}
    140140
    141 Vector<ResolvedFontFamily> CSSSegmentedFontFace::resolveFamilies(UChar32 character) const
    142 {
    143     for (auto& face : m_fontFaces) {
    144         bool inRange = face->ranges().isEmpty();
    145         for (auto& range : face->ranges()) {
    146             if (character >= range.from && character <= range.to) {
    147                 inRange = true;
    148                 break;
    149             }
    150         }
    151         if (inRange)
    152             return face->resolveFamilies();
    153     }
    154     return { };
    155141}
    156 
    157 }

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

    r201551 r201570  
    2929#include "CSSFontFace.h"
    3030#include "FontCache.h"
    31 #include "FontSelector.h"
    3231#include <wtf/HashMap.h>
    3332#include <wtf/RefCounted.h>
    … …  
    5958    void deref() override { RefCounted<CSSSegmentedFontFace>::deref(); }
    6059
    61     Vector<ResolvedFontFamily> resolveFamilies(UChar32 character) const;
    62 
    6360private:
    6461    CSSSegmentedFontFace();

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

    r201552 r201570  
    107107        , m_fontFaceVariantSettings(fontFaceVariantSettings ? *fontFaceVariantSettings : FontVariantSettings())
    108108    { }
    109     FontPlatformDataCacheKey(const FontPlatformDataCacheKey&) = default;
    110109
    111110    explicit FontPlatformDataCacheKey(HashTableDeletedValueType t)
    … …  
    161160}
    162161
    163 #if PLATFORM(COCOA) && ENABLE(PLATFORM_FONT_LOOKUP)
    164 using PrecacheMap = HashMap<FontPlatformDataCacheKey, FontCache::PrecacheTask*, FontPlatformDataCacheKeyHash, WTF::SimpleClassHashTraits<FontPlatformDataCacheKey>>;
    165 
    166 static PrecacheMap& precacheTasksInProgress()
    167 {
    168     static NeverDestroyed<PrecacheMap> map;
    169     return map;
    170 }
    171 #endif
    172 
    173162static AtomicString alternateFamilyName(const AtomicString& familyName)
    174163{
    … …  
    254243
    255244    FontPlatformDataCacheKey key(familyName, fontDescription, fontFaceFeatures, fontFaceVariantSettings);
    256 
    257 #if PLATFORM(COCOA) && ENABLE(PLATFORM_FONT_LOOKUP)
    258     auto* precacheTask = precacheTasksInProgress().get(key);
    259     if (precacheTask)
    260         platformCancelPrecache(*precacheTask);
    261 #endif
    262245
    263246    auto addResult = fontPlatformDataCache().add(key, nullptr);
    … …  
    507490}
    508491
    509 #if PLATFORM(COCOA) && ENABLE(PLATFORM_FONT_LOOKUP)
    510 void FontCache::precache(const Vector<AtomicString>& resolvedFamilies, const FontDescription& fontDescription)
    511 {
    512     if (resolvedFamilies.isEmpty())
    513         return;
    514     auto& family = resolvedFamilies.first();
    515 
    516     FontPlatformDataCacheKey key(family, fontDescription, nullptr, nullptr);
    517 
    518     // Maybe we have it already?
    519     auto it = fontPlatformDataCache().find(key);
    520     if (it != fontPlatformDataCache().end()) {
    521         if (it->value)
    522             return;
    523 
    524         // We already know this font isn't available. Try the next.
    525         Vector<AtomicString> remainingFamilies;
    526         remainingFamilies.appendRange(resolvedFamilies.begin() + 1, resolvedFamilies.end());
    527         precache(remainingFamilies, fontDescription);
    528         return;
    529     }
    530 
    531     auto taskAdd = precacheTasksInProgress().add(key, nullptr);
    532     if (!taskAdd.isNewEntry)
    533         return;
    534 
    535     auto& task = platformPrecache(family, fontDescription, [key, resolvedFamilies, fontDescription] (auto platformData, bool wasCanceled) {
    536         precacheTasksInProgress().remove(key);
    537 
    538         if (wasCanceled)
    539             return;
    540 
    541         if (platformData) {
    542             fontPlatformDataCache().add(key, WTFMove(platformData));
    543             return;
    544         }
    545 
    546         // Didn't find the font. Try the next one.
    547         Vector<AtomicString> remainingFamilies;
    548 
    549         auto alternateName = alternateFamilyName(resolvedFamilies.first());
    550         if (!alternateName.isNull()) {
    551             remainingFamilies = resolvedFamilies;
    552             remainingFamilies.first() = alternateName;
    553         } else {
    554             fontPlatformDataCache().add(key, nullptr);
    555             remainingFamilies.appendRange(resolvedFamilies.begin() + 1, resolvedFamilies.end());
    556         }
    557 
    558         singleton().precache(remainingFamilies, fontDescription);
    559     });
    560 
    561     taskAdd.iterator->value = &task;
    562 }
    563 #else
    564 void FontCache::precache(const Vector<AtomicString>&, const FontDescription&)
    565 {
    566 }
    567 #endif
    568 
    569492#if !PLATFORM(COCOA)
    570493RefPtr<Font> FontCache::similarFont(const FontDescription&, const AtomicString&)

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

    r201551 r201570  
    194194    RefPtr<Font> similarFont(const FontDescription&, const AtomicString& family);
    195195
    196     void precache(const Vector<AtomicString>& resolvedFamilies, const FontDescription&);
    197 
    198196    void addClient(FontSelector&);
    199197    void removeClient(FontSelector&);
    … …  
    215213#endif
    216214
    217     struct PrecacheTask;
    218 
    219215private:
    220216    FontCache();
    … …  
    231227#endif
    232228    std::unique_ptr<FontPlatformData> createFontPlatformData(const FontDescription&, const AtomicString& family, const FontFeatureSettings* fontFaceFeatures, const FontVariantSettings* fontFaceVariantSettings);
    233 
    234 #if PLATFORM(COCOA) && ENABLE(PLATFORM_FONT_LOOKUP)
    235     using PrecacheCompletionHandler = std::function<void (std::unique_ptr<FontPlatformData>, bool wasCanceled)>;
    236     PrecacheTask& platformPrecache(const AtomicString& family, const FontDescription&, PrecacheCompletionHandler&&);
    237     void platformCancelPrecache(PrecacheTask&);
    238 #endif
    239229
    240230    Timer m_purgeTimer;

  • trunk/Source/WebCore/platform/graphics/FontCascade.cpp

    r201551 r201570  
    262262}
    263263
    264 static void precachePrimaryFamily(const FontCascadeDescription& fontDescription, FontSelector& fontSelector)
    265 {
    266     Vector<AtomicString> families;
    267     for (unsigned i = 0; i < fontDescription.familyCount(); ++i)
    268         families.append(fontDescription.familyAt(i));
    269 
    270     // Primary family lookup falls back to the standard family.
    271     families.append(standardFamily);
    272 
    273     auto resolvedPrimaryFamilies = fontSelector.resolveFamilies(families, fontDescription, ' ');
    274 
    275     Vector<AtomicString> resolvedPrimaryFamilyNames;
    276     for (auto& family : resolvedPrimaryFamilies) {
    277         // This doesn't handle web fonts for now.
    278         if (family.url)
    279             break;
    280         resolvedPrimaryFamilyNames.append(family.name);
    281     }
    282 
    283     // Asynchronously find first available font and precache it so it is likely to be available when needed.
    284     FontCache::singleton().precache(resolvedPrimaryFamilyNames, fontDescription);
    285 }
    286 
    287264static Ref<FontCascadeFonts> retrieveOrAddCachedFonts(const FontCascadeDescription& fontDescription, RefPtr<FontSelector>&& fontSelector)
    288265{
    … …  
    293270    if (!addResult.isNewEntry && keysMatch(addResult.iterator->value->key, key))
    294271        return addResult.iterator->value->fonts.get();
    295 
    296     if (fontSelector)
    297         precachePrimaryFamily(fontDescription, *fontSelector);
    298272
    299273    auto& newEntry = addResult.iterator->value;

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

    r201551 r201570  
    2727
    2828#include "FontRanges.h"
    29 #include "URL.h"
    3029#include <wtf/Forward.h>
    3130#include <wtf/PassRefPtr.h>
    … …  
    4645};
    4746
    48 struct ResolvedFontFamily {
    49     AtomicString name;
    50     Optional<URL> url;
    51 };
    52 
    5347class FontSelector : public RefCounted<FontSelector> {
    5448public:
    … …  
    6559    virtual void unregisterForInvalidationCallbacks(FontSelectorClient&) = 0;
    6660
    67     virtual Vector<ResolvedFontFamily> resolveFamilies(const Vector<AtomicString>& families, const FontDescription&, UChar32 character) = 0;
    68 
    6961    virtual unsigned uniqueId() const = 0;
    7062    virtual unsigned version() const = 0;

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

    r201551 r201570  
    3535#include <wtf/MainThread.h>
    3636#include <wtf/NeverDestroyed.h>
    37 #include <wtf/RunLoop.h>
    38 #include <wtf/WorkQueue.h>
    3937
    4038namespace WebCore {
    … …  
    663661}
    664662
    665 static RetainPtr<CTFontRef> fontWithFamily(const String& family, CTFontSymbolicTraits desiredTraits, FontWeight weight, const FontFeatureSettings& featureSettings, const FontVariantSettings& variantSettings, const FontFeatureSettings* fontFaceFeatures, const FontVariantSettings* fontFaceVariantSettings, const TextRenderingMode& textRenderingMode, float size, bool isWhitelisted)
     663#if ENABLE(PLATFORM_FONT_LOOKUP)
     664static RetainPtr<CTFontRef> platformFontLookupWithFamily(const AtomicString& family, CTFontSymbolicTraits requestedTraits, FontWeight weight, float size)
     665{
     666    const auto& whitelist = fontWhitelist();
     667    if (whitelist.size() && !whitelist.contains(family))
     668        return nullptr;
     669
     670    return adoptCF(CTFontCreateForCSS(family.string().createCFString().get(), toCoreTextFontWeight(weight), requestedTraits, size));
     671}
     672#endif
     673
     674static RetainPtr<CTFontRef> fontWithFamily(const AtomicString& family, CTFontSymbolicTraits desiredTraits, FontWeight weight, const FontFeatureSettings& featureSettings, const FontVariantSettings& variantSettings, const FontFeatureSettings* fontFaceFeatures, const FontVariantSettings* fontFaceVariantSettings, const TextRenderingMode& textRenderingMode, float size)
    666675{
    667676    if (family.isEmpty())
    … …  
    671680    if (!foundFont) {
    672681#if ENABLE(PLATFORM_FONT_LOOKUP)
    673         if (!isWhitelisted)
    674             return nullptr;
    675         foundFont = adoptCF(CTFontCreateForCSS(family.createCFString().get(), toCoreTextFontWeight(weight), desiredTraits, size));
     682        foundFont = platformFontLookupWithFamily(family, desiredTraits, weight, size);
    676683#else
    677         UNUSED_PARAM(isWhitelisted);
    678684        foundFont = platformFontWithFamily(family, desiredTraits, weight, textRenderingMode, size);
    679685#endif
    … …  
    714720#endif
    715721
    716 // This is only thread safe with ENABLE(PLATFORM_FONT_LOOKUP) due to fontWithFamily() implementation
    717 static std::unique_ptr<FontPlatformData> createFontPlatformDataThreadSafe(const FontDescription& fontDescription, const String& family, const FontFeatureSettings* fontFaceFeatures, const FontVariantSettings* fontFaceVariantSettings, bool isWhitelisted, bool shouldAutoActivateIfNeeded)
     722std::unique_ptr<FontPlatformData> FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family, const FontFeatureSettings* fontFaceFeatures, const FontVariantSettings* fontFaceVariantSettings)
    718723{
    719724    CTFontSymbolicTraits traits = computeTraits(fontDescription);
    720725    float size = fontDescription.computedPixelSize();
    721726
    722     RetainPtr<CTFontRef> font = fontWithFamily(family, traits, fontDescription.weight(), fontDescription.featureSettings(), fontDescription.variantSettings(), fontFaceFeatures, fontFaceVariantSettings, fontDescription.textRenderingMode(), size, isWhitelisted);
     727    RetainPtr<CTFontRef> font = fontWithFamily(family, traits, fontDescription.weight(), fontDescription.featureSettings(), fontDescription.variantSettings(), fontFaceFeatures, fontFaceVariantSettings, fontDescription.textRenderingMode(), size);
    723728
    724729#if PLATFORM(MAC)
    725     if (!font && shouldAutoActivateIfNeeded) {
     730    if (!font) {
     731        if (!shouldAutoActivateFontIfNeeded(family))
     732            return nullptr;
     733
    726734        // Auto activate the font before looking for it a second time.
    727735        // Ignore the result because we want to use our own algorithm to actually find the font.
    728         autoActivateFont(family, size);
    729 
    730         font = fontWithFamily(family, traits, fontDescription.weight(), fontDescription.featureSettings(), fontDescription.variantSettings(), fontFaceFeatures, fontFaceVariantSettings, fontDescription.textRenderingMode(), size, isWhitelisted);
    731     }
    732 #else
    733     UNUSED_PARAM(shouldAutoActivateIfNeeded);
     736        autoActivateFont(family.string(), size);
     737
     738        font = fontWithFamily(family, traits, fontDescription.weight(), fontDescription.featureSettings(), fontDescription.variantSettings(), fontFaceFeatures, fontFaceVariantSettings, fontDescription.textRenderingMode(), size);
     739    }
    734740#endif
    735741
    … …  
    741747
    742748    return std::make_unique<FontPlatformData>(font.get(), size, syntheticBold, syntheticOblique, fontDescription.orientation(), fontDescription.widthVariant(), fontDescription.textRenderingMode());
    743 }
    744 
    745 std::unique_ptr<FontPlatformData> FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family, const FontFeatureSettings* fontFaceFeatures, const FontVariantSettings* fontFaceVariantSettings)
    746 {
    747     const auto& whitelist = fontWhitelist();
    748     bool isWhitelisted = whitelist.isEmpty() || whitelist.contains(family);
    749 
    750     bool shouldAutoActivateIfNeeded = false;
    751 #if PLATFORM(MAC)
    752     shouldAutoActivateIfNeeded = shouldAutoActivateFontIfNeeded(family);
    753 #endif
    754 
    755     return createFontPlatformDataThreadSafe(fontDescription, family, fontFaceFeatures, fontFaceVariantSettings, isWhitelisted, shouldAutoActivateIfNeeded);
    756749}
    757750
    … …  
    804797}
    805798
    806 #if ENABLE(PLATFORM_FONT_LOOKUP)
    807 struct FontCache::PrecacheTask {
    808     String family;
    809     FontDescription fontDescription;
    810     bool shouldAutoActivateIfNeeded { false };
    811     bool isWhitelisted { true };
    812     PrecacheCompletionHandler completionHandler;
    813 
    814     std::unique_ptr<FontPlatformData> result;
    815     std::atomic_bool isCanceled { false };
    816 };
    817 
    818 FontCache::PrecacheTask& FontCache::platformPrecache(const AtomicString& family, const FontDescription& fontDescription, PrecacheCompletionHandler&& completionHandler)
    819 {
    820     static WorkQueue& queue = WorkQueue::create("org.webkit.font-precache", WorkQueue::Type::Serial, WorkQueue::QOS::UserInitiated).leakRef();
    821 
    822     auto task = std::make_unique<PrecacheTask>();
    823     task->family = family;
    824     task->fontDescription = fontDescription;
    825     const auto& whitelist = fontWhitelist();
    826     task->isWhitelisted = whitelist.isEmpty() || whitelist.contains(family);
    827 #if PLATFORM(MAC)
    828     task->shouldAutoActivateIfNeeded = shouldAutoActivateFontIfNeeded(family);
    829 #endif
    830     task->completionHandler = WTFMove(completionHandler);
    831 
    832     auto& resultTask = *task;
    833 
    834     queue.dispatch([task = task.release()] {
    835         if (!task->isCanceled) {
    836             auto family = task->family.isolatedCopy();
    837             task->result = createFontPlatformDataThreadSafe(task->fontDescription, family, nullptr, nullptr, task->isWhitelisted, task->shouldAutoActivateIfNeeded);
    838         }
    839 
    840         RunLoop::main().dispatch([task] {
    841             std::unique_ptr<PrecacheTask> deleter(task);
    842             task->completionHandler(WTFMove(task->result), task->isCanceled);
    843         });
    844     });
    845 
    846     return resultTask;
    847 }
    848 
    849 void FontCache::platformCancelPrecache(FontCache::PrecacheTask& task)
    850 {
    851     task.isCanceled = true;
    852 }
    853 #endif
    854 
    855 }
     799}
Note: See TracChangeset for help on using the changeset viewer.