| /* |
| * Copyright (C) 2007, 2008, 2011 Apple Inc. All rights reserved. |
| * (C) 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org> |
| * |
| * 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. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``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 COMPUTER, INC. OR |
| * 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 "core/css/CSSFontSelector.h" |
| |
| #include "core/css/CSSFontSelectorClient.h" |
| #include "core/css/CSSSegmentedFontFace.h" |
| #include "core/css/CSSValueList.h" |
| #include "core/css/FontFaceSet.h" |
| #include "core/css/resolver/StyleResolver.h" |
| #include "core/dom/Document.h" |
| #include "core/frame/LocalFrame.h" |
| #include "core/frame/Settings.h" |
| #include "core/loader/FrameLoader.h" |
| #include "platform/RuntimeEnabledFeatures.h" |
| #include "platform/fonts/FontCache.h" |
| #include "platform/fonts/SimpleFontData.h" |
| #include "wtf/text/AtomicString.h" |
| |
| namespace blink { |
| |
| CSSFontSelector::CSSFontSelector(Document* document) |
| : m_document(document), |
| m_genericFontFamilySettings( |
| document->frame()->settings()->genericFontFamilySettings()) { |
| // FIXME: An old comment used to say there was no need to hold a reference to |
| // m_document because "we are guaranteed to be destroyed before the document". |
| // But there does not seem to be any such guarantee. |
| ASSERT(m_document); |
| DCHECK(m_document->frame()); |
| FontCache::fontCache()->addClient(this); |
| FontFaceSet::from(*document)->addFontFacesToFontFaceCache(&m_fontFaceCache, |
| this); |
| } |
| |
| CSSFontSelector::~CSSFontSelector() {} |
| |
| void CSSFontSelector::registerForInvalidationCallbacks( |
| CSSFontSelectorClient* client) { |
| m_clients.add(client); |
| } |
| |
| void CSSFontSelector::unregisterForInvalidationCallbacks( |
| CSSFontSelectorClient* client) { |
| m_clients.remove(client); |
| } |
| |
| void CSSFontSelector::dispatchInvalidationCallbacks() { |
| m_fontFaceCache.incrementVersion(); |
| |
| HeapVector<Member<CSSFontSelectorClient>> clients; |
| copyToVector(m_clients, clients); |
| for (auto& client : clients) |
| client->fontsNeedUpdate(this); |
| } |
| |
| void CSSFontSelector::fontFaceInvalidated() { |
| dispatchInvalidationCallbacks(); |
| } |
| |
| void CSSFontSelector::fontCacheInvalidated() { |
| dispatchInvalidationCallbacks(); |
| } |
| |
| static AtomicString familyNameFromSettings( |
| const GenericFontFamilySettings& settings, |
| const FontDescription& fontDescription, |
| const AtomicString& genericFamilyName) { |
| #if OS(ANDROID) |
| if (fontDescription.genericFamily() == FontDescription::StandardFamily) |
| return FontCache::getGenericFamilyNameForScript( |
| FontFamilyNames::webkit_standard, fontDescription); |
| |
| if (genericFamilyName.startsWith("-webkit-")) |
| return FontCache::getGenericFamilyNameForScript(genericFamilyName, |
| fontDescription); |
| #else |
| UScriptCode script = fontDescription.script(); |
| if (fontDescription.genericFamily() == FontDescription::StandardFamily) |
| return settings.standard(script); |
| if (genericFamilyName == FontFamilyNames::webkit_serif) |
| return settings.serif(script); |
| if (genericFamilyName == FontFamilyNames::webkit_sans_serif) |
| return settings.sansSerif(script); |
| if (genericFamilyName == FontFamilyNames::webkit_cursive) |
| return settings.cursive(script); |
| if (genericFamilyName == FontFamilyNames::webkit_fantasy) |
| return settings.fantasy(script); |
| if (genericFamilyName == FontFamilyNames::webkit_monospace) |
| return settings.fixed(script); |
| if (genericFamilyName == FontFamilyNames::webkit_pictograph) |
| return settings.pictograph(script); |
| if (genericFamilyName == FontFamilyNames::webkit_standard) |
| return settings.standard(script); |
| #endif |
| return emptyAtom; |
| } |
| |
| PassRefPtr<FontData> CSSFontSelector::getFontData( |
| const FontDescription& fontDescription, |
| const AtomicString& familyName) { |
| if (CSSSegmentedFontFace* face = |
| m_fontFaceCache.get(fontDescription, familyName)) |
| return face->getFontData(fontDescription); |
| |
| // Try to return the correct font based off our settings, in case we were |
| // handed the generic font family name. |
| AtomicString settingsFamilyName = familyNameFromSettings( |
| m_genericFontFamilySettings, fontDescription, familyName); |
| if (settingsFamilyName.isEmpty()) |
| return nullptr; |
| |
| return FontCache::fontCache()->getFontData(fontDescription, |
| settingsFamilyName); |
| } |
| |
| void CSSFontSelector::willUseFontData(const FontDescription& fontDescription, |
| const AtomicString& family, |
| const String& text) { |
| CSSSegmentedFontFace* face = m_fontFaceCache.get(fontDescription, family); |
| if (face) |
| face->willUseFontData(fontDescription, text); |
| } |
| |
| void CSSFontSelector::willUseRange(const FontDescription& fontDescription, |
| const AtomicString& family, |
| const FontDataForRangeSet& rangeSet) { |
| CSSSegmentedFontFace* face = m_fontFaceCache.get(fontDescription, family); |
| if (face) |
| face->willUseRange(fontDescription, rangeSet); |
| } |
| |
| bool CSSFontSelector::isPlatformFontAvailable( |
| const FontDescription& fontDescription, |
| const AtomicString& passedFamily) { |
| AtomicString family = familyNameFromSettings(m_genericFontFamilySettings, |
| fontDescription, passedFamily); |
| if (family.isEmpty()) |
| family = passedFamily; |
| return FontCache::fontCache()->isPlatformFontAvailable(fontDescription, |
| family); |
| } |
| |
| void CSSFontSelector::updateGenericFontFamilySettings(Document& document) { |
| if (!document.settings()) |
| return; |
| m_genericFontFamilySettings = |
| document.settings()->genericFontFamilySettings(); |
| fontCacheInvalidated(); |
| } |
| |
| DEFINE_TRACE(CSSFontSelector) { |
| visitor->trace(m_document); |
| visitor->trace(m_fontFaceCache); |
| visitor->trace(m_clients); |
| FontSelector::trace(visitor); |
| } |
| |
| } // namespace blink |