blob: d362ffe2df7c5ee3be330ac68fec4db92596cef3 [file] [log] [blame]
/*
* Copyright (C) 2006, 2013-2015 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of Apple Inc. ("Apple") nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "FontCascadeFonts.h"
#include "FontCache.h"
#include "FontCascade.h"
#include "GlyphPage.h"
namespace WebCore {
class MixedFontGlyphPage {
WTF_MAKE_FAST_ALLOCATED;
public:
MixedFontGlyphPage(const GlyphPage* initialPage)
{
if (initialPage) {
for (unsigned i = 0; i < GlyphPage::size; ++i)
setGlyphDataForIndex(i, initialPage->glyphDataForIndex(i));
}
}
GlyphData glyphDataForCharacter(UChar32 c) const
{
unsigned index = GlyphPage::indexForCodePoint(c);
ASSERT_WITH_SECURITY_IMPLICATION(index < GlyphPage::size);
return { m_glyphs[index], m_fonts[index] };
}
void setGlyphDataForCharacter(UChar32 c, GlyphData glyphData)
{
setGlyphDataForIndex(GlyphPage::indexForCodePoint(c), glyphData);
}
private:
void setGlyphDataForIndex(unsigned index, const GlyphData& glyphData)
{
ASSERT_WITH_SECURITY_IMPLICATION(index < GlyphPage::size);
m_glyphs[index] = glyphData.glyph;
m_fonts[index] = glyphData.font;
}
Glyph m_glyphs[GlyphPage::size] { };
const Font* m_fonts[GlyphPage::size] { };
};
GlyphData FontCascadeFonts::GlyphPageCacheEntry::glyphDataForCharacter(UChar32 character)
{
ASSERT(!(m_singleFont && m_mixedFont));
if (m_singleFont)
return m_singleFont->glyphDataForCharacter(character);
if (m_mixedFont)
return m_mixedFont->glyphDataForCharacter(character);
return 0;
}
void FontCascadeFonts::GlyphPageCacheEntry::setGlyphDataForCharacter(UChar32 character, GlyphData glyphData)
{
ASSERT(!glyphDataForCharacter(character).glyph);
if (!m_mixedFont) {
m_mixedFont = makeUnique<MixedFontGlyphPage>(m_singleFont.get());
m_singleFont = nullptr;
}
m_mixedFont->setGlyphDataForCharacter(character, glyphData);
}
void FontCascadeFonts::GlyphPageCacheEntry::setSingleFontPage(RefPtr<GlyphPage>&& page)
{
ASSERT(isNull());
m_singleFont = page;
}
DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(FontCascadeFonts);
FontCascadeFonts::FontCascadeFonts(RefPtr<FontSelector>&& fontSelector)
: m_cachedPrimaryFont(nullptr)
, m_fontSelector(fontSelector)
, m_fontSelectorVersion(m_fontSelector ? m_fontSelector->version() : 0)
, m_generation(FontCache::forCurrentThread().generation())
{
#if ASSERT_ENABLED
if (!isMainThread())
m_thread = Thread::current();
#endif
}
FontCascadeFonts::FontCascadeFonts(const FontPlatformData& platformData)
: m_cachedPrimaryFont(nullptr)
, m_fontSelectorVersion(0)
, m_generation(FontCache::forCurrentThread().generation())
, m_isForPlatformFont(true)
{
m_realizedFallbackRanges.append(FontRanges(FontCache::forCurrentThread().fontForPlatformData(platformData)));
}
FontCascadeFonts::~FontCascadeFonts() = default;
void FontCascadeFonts::determinePitch(const FontCascadeDescription& description)
{
auto& primaryRanges = realizeFallbackRangesAt(description, 0);
unsigned numRanges = primaryRanges.size();
if (numRanges == 1)
m_pitch = primaryRanges.fontForFirstRange().pitch();
else
m_pitch = VariablePitch;
}
bool FontCascadeFonts::isLoadingCustomFonts() const
{
for (auto& fontRanges : m_realizedFallbackRanges) {
if (fontRanges.isLoading())
return true;
}
return false;
}
static FontRanges realizeNextFallback(const FontCascadeDescription& description, unsigned& index, FontSelector* fontSelector)
{
ASSERT(index < description.effectiveFamilyCount());
auto& fontCache = FontCache::forCurrentThread();
while (index < description.effectiveFamilyCount()) {
auto visitor = WTF::makeVisitor([&](const AtomString& family) -> FontRanges {
if (family.isEmpty())
return FontRanges();
if (fontSelector) {
auto ranges = fontSelector->fontRangesForFamily(description, family);
if (!ranges.isNull())
return ranges;
}
if (auto font = fontCache.fontForFamily(description, family))
return FontRanges(WTFMove(font));
return FontRanges();
}, [&](const FontFamilyPlatformSpecification& fontFamilySpecification) -> FontRanges {
return fontFamilySpecification.fontRanges(description);
});
const auto& currentFamily = description.effectiveFamilyAt(index++);
auto ranges = std::visit(visitor, currentFamily);
if (!ranges.isNull())
return ranges;
}
// We didn't find a font. Try to find a similar font using our own specific knowledge about our platform.
// For example on OS X, we know to map any families containing the words Arabic, Pashto, or Urdu to the
// Geeza Pro font.
for (auto& family : description.families()) {
if (auto font = fontCache.similarFont(description, family))
return FontRanges(WTFMove(font));
}
return { };
}
const FontRanges& FontCascadeFonts::realizeFallbackRangesAt(const FontCascadeDescription& description, unsigned index)
{
if (index < m_realizedFallbackRanges.size())
return m_realizedFallbackRanges[index];
ASSERT(index == m_realizedFallbackRanges.size());
ASSERT(FontCache::forCurrentThread().generation() == m_generation);
m_realizedFallbackRanges.append(FontRanges());
auto& fontRanges = m_realizedFallbackRanges.last();
if (!index) {
fontRanges = realizeNextFallback(description, m_lastRealizedFallbackIndex, m_fontSelector.get());
if (fontRanges.isNull() && m_fontSelector)
fontRanges = m_fontSelector->fontRangesForFamily(description, familyNamesData->at(FamilyNamesIndex::StandardFamily));
if (fontRanges.isNull())
fontRanges = FontRanges(FontCache::forCurrentThread().lastResortFallbackFont(description));
return fontRanges;
}
if (m_lastRealizedFallbackIndex < description.effectiveFamilyCount())
fontRanges = realizeNextFallback(description, m_lastRealizedFallbackIndex, m_fontSelector.get());
if (fontRanges.isNull() && m_fontSelector) {
ASSERT(m_lastRealizedFallbackIndex >= description.effectiveFamilyCount());
unsigned fontSelectorFallbackIndex = m_lastRealizedFallbackIndex - description.effectiveFamilyCount();
if (fontSelectorFallbackIndex == m_fontSelector->fallbackFontCount())
return fontRanges;
++m_lastRealizedFallbackIndex;
fontRanges = FontRanges(m_fontSelector->fallbackFontAt(description, fontSelectorFallbackIndex));
}
return fontRanges;
}
static inline bool isInRange(UChar32 character, UChar32 lowerBound, UChar32 upperBound)
{
return character >= lowerBound && character <= upperBound;
}
static bool shouldIgnoreRotation(UChar32 character)
{
if (character == 0x000A7 || character == 0x000A9 || character == 0x000AE)
return true;
if (character == 0x000B6 || character == 0x000BC || character == 0x000BD || character == 0x000BE)
return true;
if (isInRange(character, 0x002E5, 0x002EB))
return true;
if (isInRange(character, 0x01100, 0x011FF) || isInRange(character, 0x01401, 0x0167F) || isInRange(character, 0x01800, 0x018FF))
return true;
if (character == 0x02016 || character == 0x02020 || character == 0x02021 || character == 0x2030 || character == 0x02031)
return true;
if (isInRange(character, 0x0203B, 0x0203D) || character == 0x02042 || character == 0x02044 || character == 0x02047
|| character == 0x02048 || character == 0x02049 || character == 0x2051)
return true;
if (isInRange(character, 0x02065, 0x02069) || isInRange(character, 0x020DD, 0x020E0)
|| isInRange(character, 0x020E2, 0x020E4) || isInRange(character, 0x02100, 0x02117)
|| isInRange(character, 0x02119, 0x02131) || isInRange(character, 0x02133, 0x0213F))
return true;
if (isInRange(character, 0x02145, 0x0214A) || character == 0x0214C || character == 0x0214D
|| isInRange(character, 0x0214F, 0x0218F))
return true;
if (isInRange(character, 0x02300, 0x02307) || isInRange(character, 0x0230C, 0x0231F)
|| isInRange(character, 0x02322, 0x0232B) || isInRange(character, 0x0237D, 0x0239A)
|| isInRange(character, 0x023B4, 0x023B6) || isInRange(character, 0x023BA, 0x023CF)
|| isInRange(character, 0x023D1, 0x023DB) || isInRange(character, 0x023E2, 0x024FF))
return true;
if (isInRange(character, 0x025A0, 0x02619) || isInRange(character, 0x02620, 0x02767)
|| isInRange(character, 0x02776, 0x02793) || isInRange(character, 0x02B12, 0x02B2F)
|| isInRange(character, 0x02B4D, 0x02BFF) || isInRange(character, 0x02E80, 0x03007))
return true;
if (character == 0x03012 || character == 0x03013 || isInRange(character, 0x03020, 0x0302F)
|| isInRange(character, 0x03031, 0x0309F) || isInRange(character, 0x030A1, 0x030FB)
|| isInRange(character, 0x030FD, 0x0A4CF))
return true;
if (isInRange(character, 0x0A840, 0x0A87F) || isInRange(character, 0x0A960, 0x0A97F)
|| isInRange(character, 0x0AC00, 0x0D7FF) || isInRange(character, 0x0E000, 0x0FAFF))
return true;
if (isInRange(character, 0x0FE10, 0x0FE1F) || isInRange(character, 0x0FE30, 0x0FE48)
|| isInRange(character, 0x0FE50, 0x0FE57) || isInRange(character, 0x0FE5F, 0x0FE62)
|| isInRange(character, 0x0FE67, 0x0FE6F))
return true;
if (isInRange(character, 0x0FF01, 0x0FF07) || isInRange(character, 0x0FF0A, 0x0FF0C)
|| isInRange(character, 0x0FF0E, 0x0FF19) || character == 0x0FF1B || isInRange(character, 0x0FF1F, 0x0FF3A))
return true;
if (character == 0x0FF3C || character == 0x0FF3E)
return true;
if (isInRange(character, 0x0FF40, 0x0FF5A) || isInRange(character, 0x0FFE0, 0x0FFE2)
|| isInRange(character, 0x0FFE4, 0x0FFE7) || isInRange(character, 0x0FFF0, 0x0FFF8)
|| character == 0x0FFFD)
return true;
if (isInRange(character, 0x13000, 0x1342F) || isInRange(character, 0x1B000, 0x1B0FF)
|| isInRange(character, 0x1D000, 0x1D1FF) || isInRange(character, 0x1D300, 0x1D37F)
|| isInRange(character, 0x1F000, 0x1F64F) || isInRange(character, 0x1F680, 0x1F77F))
return true;
if (isInRange(character, 0x20000, 0x2FFFD) || isInRange(character, 0x30000, 0x3FFFD))
return true;
return false;
}
static GlyphData glyphDataForNonCJKCharacterWithGlyphOrientation(UChar32 character, NonCJKGlyphOrientation orientation, const GlyphData& data)
{
bool syntheticOblique = data.font->platformData().syntheticOblique();
if (orientation == NonCJKGlyphOrientation::Upright || shouldIgnoreRotation(character)) {
GlyphData uprightData = data.font->uprightOrientationFont().glyphDataForCharacter(character);
// If the glyphs are the same, then we know we can just use the horizontal glyph rotated vertically
// to be upright. For synthetic oblique, however, we will always return the uprightData to ensure
// that non-CJK and CJK runs are broken up. This guarantees that vertical
// fonts without isTextOrientationFallback() set contain CJK characters only and thus we can get
// the oblique slant correct.
if (data.glyph == uprightData.glyph && !syntheticOblique)
return data;
// The glyphs are distinct, meaning that the font has a vertical-right glyph baked into it. We can't use that
// glyph, so we fall back to the upright data and use the horizontal glyph.
if (uprightData.font)
return uprightData;
} else if (orientation == NonCJKGlyphOrientation::Mixed) {
GlyphData verticalRightData = data.font->verticalRightOrientationFont().glyphDataForCharacter(character);
// If there is a baked-in rotated glyph, we will use it unless syntheticOblique is set. If
// synthetic oblique is set, we fall back to the horizontal glyph. This guarantees that vertical
// fonts without isTextOrientationFallback() set contain CJK characters only and thus we can get
// the oblique slant correct.
if (data.glyph != verticalRightData.glyph && !syntheticOblique)
return data;
// The glyphs are identical, meaning that we should just use the horizontal glyph.
if (verticalRightData.font)
return verticalRightData;
}
return data;
}
static const Font* findBestFallbackFont(FontCascadeFonts& fontCascadeFonts, const FontCascadeDescription& description, UChar32 character)
{
for (unsigned fallbackIndex = 0; ; ++fallbackIndex) {
auto& fontRanges = fontCascadeFonts.realizeFallbackRangesAt(description, fallbackIndex);
if (fontRanges.isNull())
break;
auto* currentFont = fontRanges.glyphDataForCharacter(character, ExternalResourceDownloadPolicy::Forbid).font;
if (!currentFont)
currentFont = &fontRanges.fontForFirstRange();
if (!currentFont->isInterstitial())
return currentFont;
}
return nullptr;
}
GlyphData FontCascadeFonts::glyphDataForSystemFallback(UChar32 character, const FontCascadeDescription& description, FontVariant variant, bool systemFallbackShouldBeInvisible)
{
const Font* font = findBestFallbackFont(*this, description, character);
if (!font)
font = &realizeFallbackRangesAt(description, 0).fontForFirstRange();
auto systemFallbackFont = font->systemFallbackFontForCharacter(character, description, m_isForPlatformFont ? IsForPlatformFont::Yes : IsForPlatformFont::No);
if (!systemFallbackFont)
return GlyphData();
if (systemFallbackShouldBeInvisible)
systemFallbackFont = const_cast<Font*>(&systemFallbackFont->invisibleFont());
if (systemFallbackFont->platformData().orientation() == FontOrientation::Vertical && !systemFallbackFont->hasVerticalGlyphs() && FontCascade::isCJKIdeographOrSymbol(character))
variant = BrokenIdeographVariant;
GlyphData fallbackGlyphData;
if (variant == NormalVariant)
fallbackGlyphData = systemFallbackFont->glyphDataForCharacter(character);
else
fallbackGlyphData = systemFallbackFont->variantFont(description, variant)->glyphDataForCharacter(character);
if (fallbackGlyphData.font && fallbackGlyphData.font->platformData().orientation() == FontOrientation::Vertical && !fallbackGlyphData.font->isTextOrientationFallback()) {
if (variant == NormalVariant && !FontCascade::isCJKIdeographOrSymbol(character))
fallbackGlyphData = glyphDataForNonCJKCharacterWithGlyphOrientation(character, description.nonCJKGlyphOrientation(), fallbackGlyphData);
}
// Keep the system fallback fonts we use alive.
if (fallbackGlyphData.glyph)
m_systemFallbackFontSet.add(WTFMove(systemFallbackFont));
return fallbackGlyphData;
}
enum class FallbackVisibility {
Immaterial,
Visible,
Invisible
};
static void opportunisticallyStartFontDataURLLoading(const FontCascadeDescription& description, FontSelector* fontSelector)
{
// It is a somewhat common practice for a font foundry to break up a single font into two fonts, each having a random half of
// the alphabet, and then encoding the two fonts as data: urls (with different font-family names).
// Therefore, if these two fonts don't get loaded at (nearly) the same time, there will be a flash of unintelligible text where
// only a random half of the letters are visible.
// This code attempts to pre-warm these data urls to make them load at closer to the same time. However, font loading is
// asynchronous, and this code doesn't actually fix the race - it just makes it more likely for the two fonts to tie in the race.
if (!fontSelector)
return;
for (unsigned i = 0; i < description.familyCount(); ++i)
fontSelector->opportunisticallyStartFontDataURLLoading(description, description.familyAt(i));
}
GlyphData FontCascadeFonts::glyphDataForVariant(UChar32 character, const FontCascadeDescription& description, FontVariant variant, unsigned fallbackIndex)
{
FallbackVisibility fallbackVisibility = FallbackVisibility::Immaterial;
ExternalResourceDownloadPolicy policy = ExternalResourceDownloadPolicy::Allow;
GlyphData loadingResult;
opportunisticallyStartFontDataURLLoading(description, m_fontSelector.get());
for (; ; ++fallbackIndex) {
auto& fontRanges = realizeFallbackRangesAt(description, fallbackIndex);
if (fontRanges.isNull())
break;
GlyphData data = fontRanges.glyphDataForCharacter(character, policy);
if (!data.font)
continue;
if (data.font->isInterstitial()) {
policy = ExternalResourceDownloadPolicy::Forbid;
if (fallbackVisibility == FallbackVisibility::Immaterial)
fallbackVisibility = data.font->visibility() == Font::Visibility::Visible ? FallbackVisibility::Visible : FallbackVisibility::Invisible;
if (!loadingResult.font && data.glyph)
loadingResult = data;
continue;
}
if (fallbackVisibility == FallbackVisibility::Invisible && data.font->visibility() == Font::Visibility::Visible)
data.font = &data.font->invisibleFont();
if (variant == NormalVariant) {
if (data.font->platformData().orientation() == FontOrientation::Vertical && !data.font->isTextOrientationFallback()) {
if (!FontCascade::isCJKIdeographOrSymbol(character))
return glyphDataForNonCJKCharacterWithGlyphOrientation(character, description.nonCJKGlyphOrientation(), data);
if (!data.font->hasVerticalGlyphs()) {
// Use the broken ideograph font data. The broken ideograph font will use the horizontal width of glyphs
// to make sure you get a square (even for broken glyphs like symbols used for punctuation).
return glyphDataForVariant(character, description, BrokenIdeographVariant, fallbackIndex);
}
}
} else {
// The variantFont function should not normally return 0.
// But if it does, we will just render the capital letter big.
if (const Font* variantFont = data.font->variantFont(description, variant))
return variantFont->glyphDataForCharacter(character);
}
return data;
}
if (loadingResult.font)
return loadingResult;
return glyphDataForSystemFallback(character, description, variant, fallbackVisibility == FallbackVisibility::Invisible);
}
static RefPtr<GlyphPage> glyphPageFromFontRanges(unsigned pageNumber, const FontRanges& fontRanges)
{
const Font* font = nullptr;
UChar32 pageRangeFrom = pageNumber * GlyphPage::size;
UChar32 pageRangeTo = pageRangeFrom + GlyphPage::size - 1;
auto policy = ExternalResourceDownloadPolicy::Allow;
FallbackVisibility desiredVisibility = FallbackVisibility::Immaterial;
for (unsigned i = 0; i < fontRanges.size(); ++i) {
auto& range = fontRanges.rangeAt(i);
if (range.from() <= pageRangeFrom && pageRangeTo <= range.to()) {
font = range.font(policy);
if (!font)
continue;
if (font->isInterstitial()) {
if (desiredVisibility == FallbackVisibility::Immaterial) {
auto fontVisibility = font->visibility();
if (fontVisibility == Font::Visibility::Visible)
desiredVisibility = FallbackVisibility::Visible;
else {
ASSERT(fontVisibility == Font::Visibility::Invisible);
desiredVisibility = FallbackVisibility::Invisible;
}
}
font = nullptr;
policy = ExternalResourceDownloadPolicy::Forbid;
continue;
}
}
break;
}
if (!font || font->platformData().orientation() == FontOrientation::Vertical)
return nullptr;
if (desiredVisibility == FallbackVisibility::Invisible && font->visibility() == Font::Visibility::Visible)
return const_cast<GlyphPage*>(font->invisibleFont().glyphPage(pageNumber));
return const_cast<GlyphPage*>(font->glyphPage(pageNumber));
}
GlyphData FontCascadeFonts::glyphDataForCharacter(UChar32 c, const FontCascadeDescription& description, FontVariant variant)
{
ASSERT(m_thread ? m_thread->ptr() == &Thread::current() : isMainThread());
ASSERT(variant != AutoVariant);
if (variant != NormalVariant)
return glyphDataForVariant(c, description, variant);
const unsigned pageNumber = GlyphPage::pageNumberForCodePoint(c);
auto& cacheEntry = pageNumber ? m_cachedPages.add(pageNumber, GlyphPageCacheEntry()).iterator->value : m_cachedPageZero;
// Initialize cache with a full page of glyph mappings from a single font.
if (cacheEntry.isNull())
cacheEntry.setSingleFontPage(glyphPageFromFontRanges(pageNumber, realizeFallbackRangesAt(description, 0)));
GlyphData glyphData = cacheEntry.glyphDataForCharacter(c);
if (!glyphData.glyph) {
// No glyph, resolve per-character.
ASSERT(variant == NormalVariant);
glyphData = glyphDataForVariant(c, description, variant);
// Cache the results.
cacheEntry.setGlyphDataForCharacter(c, glyphData);
}
return glyphData;
}
void FontCascadeFonts::pruneSystemFallbacks()
{
if (m_systemFallbackFontSet.isEmpty())
return;
// Mutable glyph pages may reference fallback fonts.
if (m_cachedPageZero.isMixedFont())
m_cachedPageZero = { };
m_cachedPages.removeIf([](auto& keyAndValue) {
return keyAndValue.value.isMixedFont();
});
m_systemFallbackFontSet.clear();
}
}