#include "config.h"
#include "CachedFont.h"
#include "CachedFontClient.h"
#include "CachedResourceClientWalker.h"
#include "CachedResourceLoader.h"
#include "FontCustomPlatformData.h"
#include "FontPlatformData.h"
#include "MemoryCache.h"
#include "ResourceBuffer.h"
#include "SharedBuffer.h"
#include "TextResourceDecoder.h"
#include "TypedElementDescendantIterator.h"
#include "WOFFFileFormat.h"
#include <wtf/Vector.h>
#if ENABLE(SVG_FONTS)
#include "NodeList.h"
#include "SVGDocument.h"
#include "SVGElement.h"
#include "SVGFontElement.h"
#include "SVGGElement.h"
#include "SVGNames.h"
#endif
namespace WebCore {
CachedFont::CachedFont(const ResourceRequest& resourceRequest, SessionID sessionID)
: CachedResource(resourceRequest, FontResource, sessionID)
, m_loadInitiated(false)
, m_hasCreatedFontDataWrappingResource(false)
{
}
CachedFont::~CachedFont()
{
}
void CachedFont::load(CachedResourceLoader*, const ResourceLoaderOptions& options)
{
setLoading(true);
m_options = options;
}
void CachedFont::didAddClient(CachedResourceClient* c)
{
ASSERT(c->resourceClientType() == CachedFontClient::expectedType());
if (!isLoading())
static_cast<CachedFontClient*>(c)->fontLoaded(this);
}
void CachedFont::finishLoading(ResourceBuffer* data)
{
m_data = data;
setEncodedSize(m_data.get() ? m_data->size() : 0);
setLoading(false);
checkNotify();
}
void CachedFont::beginLoadIfNeeded(CachedResourceLoader* dl)
{
if (!m_loadInitiated) {
m_loadInitiated = true;
CachedResource::load(dl, m_options);
}
}
bool CachedFont::ensureCustomFontData()
{
if (!m_fontData && !errorOccurred() && !isLoading() && m_data) {
SharedBuffer* buffer = m_data.get()->sharedBuffer();
ASSERT(buffer);
RefPtr<SharedBuffer> sfntBuffer;
bool fontIsWOFF = isWOFF(buffer);
if (fontIsWOFF) {
Vector<char> sfnt;
if (convertWOFFToSfnt(buffer, sfnt)) {
sfntBuffer = SharedBuffer::adoptVector(sfnt);
buffer = sfntBuffer.get();
} else
buffer = nullptr;
}
m_fontData = buffer ? createFontCustomPlatformData(*buffer) : nullptr;
if (m_fontData)
m_hasCreatedFontDataWrappingResource = !fontIsWOFF;
else
setStatus(DecodeError);
}
return m_fontData.get();
}
FontPlatformData CachedFont::platformDataFromCustomData(float size, bool bold, bool italic, FontOrientation orientation, FontWidthVariant widthVariant, FontRenderingMode renderingMode)
{
#if ENABLE(SVG_FONTS)
if (m_externalSVGDocument)
return FontPlatformData(size, bold, italic);
#endif
ASSERT(m_fontData);
return m_fontData->fontPlatformData(static_cast<int>(size), bold, italic, orientation, widthVariant, renderingMode);
}
#if ENABLE(SVG_FONTS)
bool CachedFont::ensureSVGFontData()
{
if (!m_externalSVGDocument && !errorOccurred() && !isLoading() && m_data) {
m_externalSVGDocument = SVGDocument::create(nullptr, URL());
RefPtr<TextResourceDecoder> decoder = TextResourceDecoder::create("application/xml");
m_externalSVGDocument->setContent(decoder->decodeAndFlush(m_data->data(), m_data->size()));
if (decoder->sawError())
m_externalSVGDocument = nullptr;
}
return m_externalSVGDocument;
}
SVGFontElement* CachedFont::getSVGFontById(const String& fontName) const
{
auto elements = descendantsOfType<SVGFontElement>(*m_externalSVGDocument);
if (fontName.isEmpty())
return elements.first();
for (auto& element : elements) {
if (element.getIdAttribute() == fontName)
return &element;
}
return nullptr;
}
#endif
void CachedFont::allClientsRemoved()
{
m_fontData = nullptr;
}
void CachedFont::checkNotify()
{
if (isLoading())
return;
CachedResourceClientWalker<CachedFontClient> w(m_clients);
while (CachedFontClient* c = w.next())
c->fontLoaded(this);
}
bool CachedFont::mayTryReplaceEncodedData() const
{
return !m_hasCreatedFontDataWrappingResource;
}
}