CSSFontFaceSource.cpp [plain text]
#include "config.h"
#include "CSSFontFaceSource.h"
#include "CSSFontFace.h"
#include "CSSFontSelector.h"
#include "CachedFont.h"
#include "Document.h"
#include "Font.h"
#include "FontCache.h"
#include "FontCustomPlatformData.h"
#include "FontDescription.h"
#include "SVGToOTFFontConversion.h"
#include "SharedBuffer.h"
#if ENABLE(SVG_FONTS)
#include "CachedSVGFont.h"
#include "FontCustomPlatformData.h"
#include "SVGFontElement.h"
#include "SVGFontFaceElement.h"
#include "SVGURIReference.h"
#endif
#if USE(DIRECT2D)
#include <dwrite.h>
#endif
namespace WebCore {
inline void CSSFontFaceSource::setStatus(Status newStatus)
{
switch (newStatus) {
case Status::Pending:
ASSERT_NOT_REACHED();
break;
case Status::Loading:
ASSERT(status() == Status::Pending);
break;
case Status::Success:
ASSERT(status() == Status::Loading);
break;
case Status::Failure:
ASSERT(status() == Status::Loading);
break;
}
m_status = newStatus;
}
CSSFontFaceSource::CSSFontFaceSource(CSSFontFace& owner, const String& familyNameOrURI, CachedFont* font, SVGFontFaceElement* fontFace, RefPtr<JSC::ArrayBufferView>&& arrayBufferView)
: m_familyNameOrURI(familyNameOrURI)
, m_font(font)
, m_face(owner)
, m_immediateSource(WTFMove(arrayBufferView))
#if ENABLE(SVG_FONTS)
, m_svgFontFaceElement(fontFace)
#endif
{
#if !ENABLE(SVG_FONTS)
UNUSED_PARAM(fontFace);
#endif
if (m_font)
m_font->addClient(*this);
if (status() == Status::Pending && m_font && m_font->isLoaded()) {
setStatus(Status::Loading);
if (!shouldIgnoreFontLoadCompletions()) {
if (m_font && m_font->errorOccurred())
setStatus(Status::Failure);
else
setStatus(Status::Success);
}
}
}
CSSFontFaceSource::~CSSFontFaceSource()
{
if (m_font)
m_font->removeClient(*this);
}
bool CSSFontFaceSource::shouldIgnoreFontLoadCompletions() const
{
return m_face.shouldIgnoreFontLoadCompletions();
}
void CSSFontFaceSource::opportunisticallyStartFontDataURLLoading(CSSFontSelector& fontSelector)
{
if (status() == Status::Pending && m_font && m_font->url().protocolIsData() && m_familyNameOrURI.length() < MB)
load(&fontSelector);
}
void CSSFontFaceSource::fontLoaded(CachedFont& loadedFont)
{
ASSERT_UNUSED(loadedFont, &loadedFont == m_font.get());
if (shouldIgnoreFontLoadCompletions())
return;
Ref<CSSFontFace> protectedFace(m_face);
if (m_status == Status::Pending)
setStatus(Status::Loading);
else if (m_status == Status::Failure) {
ASSERT(m_font->errorOccurred());
return;
}
if (m_font->errorOccurred() || !m_font->ensureCustomFontData(m_familyNameOrURI))
setStatus(Status::Failure);
else
setStatus(Status::Success);
m_face.fontLoaded(*this);
}
void CSSFontFaceSource::load(CSSFontSelector* fontSelector)
{
setStatus(Status::Loading);
if (m_font) {
ASSERT(fontSelector);
fontSelector->beginLoadingFontSoon(*m_font);
} else {
bool success = false;
#if ENABLE(SVG_FONTS)
if (m_svgFontFaceElement) {
if (is<SVGFontElement>(m_svgFontFaceElement->parentNode())) {
ASSERT(!m_inDocumentCustomPlatformData);
SVGFontElement& fontElement = downcast<SVGFontElement>(*m_svgFontFaceElement->parentNode());
if (auto otfFont = convertSVGToOTFFont(fontElement))
m_generatedOTFBuffer = SharedBuffer::create(WTFMove(otfFont.value()));
if (m_generatedOTFBuffer) {
m_inDocumentCustomPlatformData = createFontCustomPlatformData(*m_generatedOTFBuffer, String());
success = static_cast<bool>(m_inDocumentCustomPlatformData);
}
}
} else
#endif
if (m_immediateSource) {
ASSERT(!m_immediateFontCustomPlatformData);
bool wrapping;
RefPtr<SharedBuffer> buffer = SharedBuffer::create(static_cast<const char*>(m_immediateSource->baseAddress()), m_immediateSource->byteLength());
ASSERT(buffer);
m_immediateFontCustomPlatformData = CachedFont::createCustomFontData(*buffer, String(), wrapping);
success = static_cast<bool>(m_immediateFontCustomPlatformData);
} else {
FontCascadeDescription fontDescription;
fontDescription.setOneFamily(m_familyNameOrURI);
fontDescription.setComputedSize(1);
fontDescription.setShouldAllowUserInstalledFonts(m_face.allowUserInstalledFonts());
success = FontCache::singleton().fontForFamily(fontDescription, m_familyNameOrURI, nullptr, nullptr, FontSelectionSpecifiedCapabilities(), true);
}
setStatus(success ? Status::Success : Status::Failure);
}
}
RefPtr<Font> CSSFontFaceSource::font(const FontDescription& fontDescription, bool syntheticBold, bool syntheticItalic, const FontFeatureSettings& fontFaceFeatures, const FontVariantSettings& fontFaceVariantSettings, FontSelectionSpecifiedCapabilities fontFaceCapabilities)
{
ASSERT(status() == Status::Success);
SVGFontFaceElement* fontFaceElement = nullptr;
#if ENABLE(SVG_FONTS)
fontFaceElement = m_svgFontFaceElement.get();
#endif
if (!m_font && !fontFaceElement) {
if (m_immediateSource) {
if (!m_immediateFontCustomPlatformData)
return nullptr;
return Font::create(CachedFont::platformDataFromCustomData(*m_immediateFontCustomPlatformData, fontDescription, syntheticBold, syntheticItalic, fontFaceFeatures, fontFaceVariantSettings, fontFaceCapabilities), Font::Origin::Remote);
}
return FontCache::singleton().fontForFamily(fontDescription, m_familyNameOrURI, &fontFaceFeatures, &fontFaceVariantSettings, fontFaceCapabilities, true);
}
if (m_font) {
auto success = m_font->ensureCustomFontData(m_familyNameOrURI);
ASSERT_UNUSED(success, success);
ASSERT(status() == Status::Success);
auto result = m_font->createFont(fontDescription, m_familyNameOrURI, syntheticBold, syntheticItalic, fontFaceFeatures, fontFaceVariantSettings, fontFaceCapabilities);
ASSERT(result);
return result;
}
if (!fontFaceElement)
return nullptr;
#if ENABLE(SVG_FONTS)
if (!is<SVGFontElement>(m_svgFontFaceElement->parentNode()))
return nullptr;
if (!m_inDocumentCustomPlatformData)
return nullptr;
#if PLATFORM(COCOA)
return Font::create(m_inDocumentCustomPlatformData->fontPlatformData(fontDescription, syntheticBold, syntheticItalic, fontFaceFeatures, fontFaceVariantSettings, fontFaceCapabilities), Font::Origin::Remote);
#else
return Font::create(m_inDocumentCustomPlatformData->fontPlatformData(fontDescription, syntheticBold, syntheticItalic), Font::Origin::Remote);
#endif
#endif
ASSERT_NOT_REACHED();
return nullptr;
}
#if ENABLE(SVG_FONTS)
bool CSSFontFaceSource::isSVGFontFaceSource() const
{
return m_svgFontFaceElement || is<CachedSVGFont>(m_font.get());
}
#endif
}