Changeset 178940 – WebKit

trunk/Source/WebCore/CMakeLists.txt

-              r178715
+              r178940
     platform/graphics/FloatRoundedRect.cpp
     platform/graphics/FloatSize.cpp
+    platform/graphics/Font.cpp
     platform/graphics/FontCache.cpp
     platform/graphics/FontCascade.cpp
 …
     platform/graphics/SVGGlyph.cpp
     platform/graphics/ShadowBlur.cpp
-    platform/graphics/SimpleFontData.cpp
     platform/graphics/StringTruncator.cpp
     platform/graphics/SurrogatePairAwareTextIterator.cpp

trunk/Source/WebCore/ChangeLog

-              r178939
+              r178940
+-01-21  Antti Koivisto  <antti@apple.com>
+        Rename SimpleFontData to Font
+        https://bugs.webkit.org/show_bug.cgi?id=140496
+        Reviewed by Zalan Bujtas.
+        The fallback supporting Font type was renamed FontCascade.
+        We can now rename SimpleFontData to Font matching the usual definition.
 -01-22  Zalan Bujtas  <zalan@apple.com>

trunk/Source/WebCore/WebCore.exp.in

-              r178820
+              r178940
 __ZN7WebCore14SecurityPolicy29addOriginAccessWhitelistEntryERKNS_14SecurityOriginERKN3WTF6StringES7_b
 __ZN7WebCore14SecurityPolicy32removeOriginAccessWhitelistEntryERKNS_14SecurityOriginERKN3WTF6StringES7_b
-__ZN7WebCore14SimpleFontDataD1Ev
 __ZN7WebCore14SubframeLoader12allowPluginsENS_28ReasonForCallingAllowPluginsE
 __ZN7WebCore14TileController14setTilesOpaqueEb
 …
 __ZN7WebCore42URLByTruncatingOneCharacterBeforeComponentEP5NSURL18CFURLComponentType
 __ZN7WebCore47attributedStringByStrippingAttachmentCharactersEP18NSAttributedString
+__ZN7WebCore4FontD1Ev
 __ZN7WebCore4Icon18createIconForFilesERKN3WTF6VectorINS1_6StringELm0ENS1_15CrashOnOverflowEEE
 __ZN7WebCore4IconD1Ev
 …
 __ZN7WebCore9FloatSizeC1ERKNS_7IntSizeE
 __ZN7WebCore9FontCache10invalidateEv
-__ZN7WebCore9FontCache13fontDataCountEv
 __ZN7WebCore9FontCache13fontForFamilyERKNS_15FontDescriptionERKN3WTF12AtomicStringEb
 __ZN7WebCore9FontCache21inactiveFontDataCountEv
+__ZN7WebCore9FontCache17inactiveFontCountEv
 __ZN7WebCore9FontCache21purgeInactiveFontDataEi
 __ZN7WebCore9FontCache29purgeInactiveFontDataIfNeededEv
+__ZN7WebCore9FontCache9fontCountEv
 __ZN7WebCore9FrameTree11appendChildEN3WTF10PassRefPtrINS_5FrameEEE
 __ZN7WebCore9FrameTree7setNameERKN3WTF12AtomicStringE
 …
 __ZNK7WebCore10Credential7isEmptyEv
 __ZNK7WebCore10FloatPointcv7CGPointEv
 __ZNK7WebCore10FontRanges20fontDataForCharacterEi
 __ZNK7WebCore10FontRanges21fontDataForFirstRangeEv
+__ZNK7WebCore10FontRanges16fontForCharacterEi
+__ZNK7WebCore10FontRanges17fontForFirstRangeEv
 __ZNK7WebCore10LayoutRect8containsERKS0_
 __ZNK7WebCore10PluginData16supportsMimeTypeERKN3WTF6StringENS0_18AllowedPluginTypesE
 …
 __ZNK7WebCore10TimeRanges5startEjRi
 __ZNK7WebCore10TimeRanges6lengthEv
 __ZNK7WebCore11FontCascade5widthERKNS_7TextRunEPN3WTF7HashSetIPKNS_14SimpleFontDataENS4_7PtrHashIS8_EENS4_10HashTraitsIS8_EEEEPNS_13GlyphOverflowE
+__ZNK7WebCore11FontCascade5widthERKNS_7TextRunEPN3WTF7HashSetIPKNS_4FontENS4_7PtrHashIS8_EENS4_10HashTraitsIS8_EEEEPNS_13GlyphOverflowE
 __ZNK7WebCore11FontCascade8drawTextEPNS_15GraphicsContextERKNS_7TextRunERKNS_10FloatPointEiiNS0_24CustomFontNotReadyActionE
 __ZNK7WebCore11FontCascadeeqERKS0_

trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj

-              r178761
+              r178940
     <ClCompile Include="..\platform\graphics\FloatRoundedRect.cpp" />
     <ClCompile Include="..\platform\graphics\FloatSize.cpp" />
+    <ClCompile Include="..\platform\graphics\Font.cpp" />
     <ClCompile Include="..\platform\graphics\FontCache.cpp" />
     <ClCompile Include="..\platform\graphics\FontCascade.cpp" />
 …
     <ClCompile Include="..\platform\graphics\RoundedRect.cpp" />
     <ClCompile Include="..\platform\graphics\ShadowBlur.cpp" />
-    <ClCompile Include="..\platform\graphics\SimpleFontData.cpp" />
     <ClCompile Include="..\platform\graphics\TextRun.cpp" />
     <ClCompile Include="..\platform\graphics\TextTrackRepresentation.cpp" />
 …
     <ClInclude Include="..\platform\graphics\FloatSize.h" />
     <ClInclude Include="..\platform\graphics\FloatSizeHash.h" />
+    <ClInclude Include="..\platform\graphics\Font.h" />
     <ClInclude Include="..\platform\graphics\FontCache.h" />
     <ClInclude Include="..\platform\graphics\FontCascade.h" />
 …
     <ClInclude Include="..\platform\graphics\RoundedRect.h" />
     <ClInclude Include="..\platform\graphics\ShadowBlur.h" />
-    <ClInclude Include="..\platform\graphics\SimpleFontData.h" />
     <ClInclude Include="..\platform\graphics\TextRun.h" />
     <ClInclude Include="..\platform\graphics\TextTrackRepresentation.h" />

trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

-              r178927
+              r178940
                 B2C3DA620D006CD600EF6F26 /* FontCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B2C3DA510D006CD600EF6F26 /* FontCache.cpp */; };
                 B2C3DA630D006CD600EF6F26 /* FontCache.h in Headers */ = {isa = PBXBuildFile; fileRef = B2C3DA520D006CD600EF6F26 /* FontCache.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 B2C3DA640D006CD600EF6F26 /* SimpleFontData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B2C3DA530D006CD600EF6F26 /* SimpleFontData.cpp */; };
                 B2C3DA650D006CD600EF6F26 /* SimpleFontData.h in Headers */ = {isa = PBXBuildFile; fileRef = B2C3DA540D006CD600EF6F26 /* SimpleFontData.h */; settings = {ATTRIBUTES = (Private, ); }; };
+                B2C3DA640D006CD600EF6F26 /* Font.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B2C3DA530D006CD600EF6F26 /* Font.cpp */; };
+                B2C3DA650D006CD600EF6F26 /* Font.h in Headers */ = {isa = PBXBuildFile; fileRef = B2C3DA540D006CD600EF6F26 /* Font.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 B2C3DA660D006CD600EF6F26 /* FontDescription.h in Headers */ = {isa = PBXBuildFile; fileRef = B2C3DA550D006CD600EF6F26 /* FontDescription.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 B2C3DA670D006CD600EF6F26 /* FontGlyphs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B2C3DA560D006CD600EF6F26 /* FontGlyphs.cpp */; };
 …
                 B2C3DA510D006CD600EF6F26 /* FontCache.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = FontCache.cpp; sourceTree = "<group>"; };
                 B2C3DA520D006CD600EF6F26 /* FontCache.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = FontCache.h; sourceTree = "<group>"; };
                 B2C3DA530D006CD600EF6F26 /* SimpleFontData.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SimpleFontData.cpp; sourceTree = "<group>"; };
                 B2C3DA540D006CD600EF6F26 /* SimpleFontData.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SimpleFontData.h; sourceTree = "<group>"; };
+                B2C3DA530D006CD600EF6F26 /* Font.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = Font.cpp; sourceTree = "<group>"; };
+                B2C3DA540D006CD600EF6F26 /* Font.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = Font.h; sourceTree = "<group>"; };
                 B2C3DA550D006CD600EF6F26 /* FontDescription.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = FontDescription.h; sourceTree = "<group>"; };
                 B2C3DA560D006CD600EF6F26 /* FontGlyphs.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = FontGlyphs.cpp; sourceTree = "<group>"; };
 …
 F3DD44D12F5EA1B000D9190 /* ShadowBlur.cpp */,
 F3DD44E12F5EA1B000D9190 /* ShadowBlur.h */,
                                 B2C3DA530D006CD600EF6F26 /* SimpleFontData.cpp */,
                                 B2C3DA540D006CD600EF6F26 /* SimpleFontData.h */,
+                                B2C3DA530D006CD600EF6F26 /* Font.cpp */,
+                                B2C3DA540D006CD600EF6F26 /* Font.h */,
                                 CD641EB21818F5ED00EE4C41 /* SourceBufferPrivate.h */,
                                 CDC8B5AC1804AE5D0016E685 /* SourceBufferPrivateClient.h */,
 …
 B1F02F13B025D200F5103F /* SharedBufferChunkReader.h in Headers */,
 EA3099EB78C0056E581 /* SharedTimer.h in Headers */,
                                 B2C3DA650D006CD600EF6F26 /* SimpleFontData.h in Headers */,
+                                B2C3DA650D006CD600EF6F26 /* Font.h in Headers */,
                                 E48944A3180B57D800F165D8 /* SimpleLineLayout.h in Headers */,
                                 E4E9B11D1814569C003ACCDF /* SimpleLineLayoutFunctions.h in Headers */,
 …
                                 E45390460EAFD637003695C8 /* SharedTimerIOS.mm in Sources */,
 EA2099EB78C0056E581 /* SharedTimerMac.mm in Sources */,
                                 B2C3DA640D006CD600EF6F26 /* SimpleFontData.cpp in Sources */,
+                                B2C3DA640D006CD600EF6F26 /* Font.cpp in Sources */,
 E88F7118A39D200ED9231 /* SimpleFontDataCoreText.cpp in Sources */,
 E65950163B10C200EB4574 /* SimpleFontDataIOS.mm in Sources */,

trunk/Source/WebCore/accessibility/ios/WebAccessibilityObjectWrapperIOS.mm

r178510	r178940
1759	1759
1760	1760	// set basic font info
1761		AXAttributeStringSetFont(attrString, style.fontCascade().primaryFont~~Data~~().getCTFont(), range);
	1761	AXAttributeStringSetFont(attrString, style.fontCascade().primaryFont().getCTFont(), range);
1762	1762
1763	1763	int decor = style.textDecorationsInEffect();

trunk/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperBase.mm

-              r178510
+              r178940
 #import "ColorMac.h"
 #import "ContextMenuController.h"
+#import "Font.h"
 #import "FontCascade.h"
 #import "Frame.h"
 …
 #import "RenderWidget.h"
 #import "ScrollView.h"
-#import "SimpleFontData.h"
 #import "TextCheckerClient.h"
 #import "TextCheckingHelper.h"

trunk/Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm

-              r178510
+              r178940
 #import "ContextMenuController.h"
 #import "Editor.h"
+#import "Font.h"
 #import "FontCascade.h"
 #import "FrameLoaderClient.h"
 …
 #import "RenderWidget.h"
 #import "ScrollView.h"
-#import "SimpleFontData.h"
 #import "TextCheckerClient.h"
 #import "TextCheckingHelper.h"
 …
     // set basic font info
     AXAttributeStringSetFont(attrString, NSAccessibilityFontTextAttribute, style.fontCascade().primaryFontData().getNSFont(), range);
+    AXAttributeStringSetFont(attrString, NSAccessibilityFontTextAttribute, style.fontCascade().primaryFont().getNSFont(), range);
     // set basic colors

trunk/Source/WebCore/bindings/objc/DOM.mm

-              r178510
+              r178940
     if (!renderer)
         return nil;
     return renderer->style().fontCascade().primaryFontData().getNSFont();
+    return renderer->style().fontCascade().primaryFont().getNSFont();
+}
 #else
 …
     if (!renderer)
         return nil;
     return renderer->style().fontCascade().primaryFontData().getCTFont();
+    return renderer->style().fontCascade().primaryFont().getCTFont();
+}
 #endif

trunk/Source/WebCore/css/CSSFontFace.cpp

-              r171886
+              r178940
 #include "CSSSegmentedFontFace.h"
 #include "Document.h"
+#include "Font.h"
 #include "FontDescription.h"
 #include "FontLoader.h"
 #include "RuntimeEnabledFeatures.h"
-#include "SimpleFontData.h"
 namespace WebCore {
 …
+}
 PassRefPtr<SimpleFontData> CSSFontFace::getFontData(const FontDescription& fontDescription, bool syntheticBold, bool syntheticItalic)
+RefPtr<Font> CSSFontFace::font(const FontDescription& fontDescription, bool syntheticBold, bool syntheticItalic)
+{
     m_activeSource = 0;
 …
     size_t size = m_sources.size();
     for (size_t i = 0; i < size; ++i) {
         if (RefPtr<SimpleFontData> result = m_sources[i]->getFontData(fontDescription, syntheticBold, syntheticItalic, fontSelector)) {
+        if (RefPtr<Font> result = m_sources[i]->font(fontDescription, syntheticBold, syntheticItalic, fontSelector)) {
             m_activeSource = m_sources[i].get();
 #if ENABLE(FONT_LOAD_EVENTS)

trunk/Source/WebCore/css/CSSFontFace.h

-              r165676
+              r178940
 class CSSSegmentedFontFace;
 class FontDescription;
 class SimpleFontData;
+class Font;
 class CSSFontFace : public RefCounted<CSSFontFace> {
 …
     void fontLoaded(CSSFontFaceSource*);
     PassRefPtr<SimpleFontData> getFontData(const FontDescription&, bool syntheticBold, bool syntheticItalic);
+    RefPtr<Font> font(const FontDescription&, bool syntheticBold, bool syntheticItalic);
     struct UnicodeRange {

trunk/Source/WebCore/css/CSSFontFaceSource.cpp

-              r178292
+              r178940
 #include "Document.h"
 #include "ElementIterator.h"
+#include "Font.h"
 #include "FontCache.h"
 #include "FontDescription.h"
-#include "SimpleFontData.h"
 #if ENABLE(SVG_OTF_CONVERTER)
 …
 void CSSFontFaceSource::pruneTable()
+{
     if (m_fontDataTable.isEmpty())
+    if (m_fontTable.isEmpty())
         return;
     m_fontDataTable.clear();
+    m_fontTable.clear();
+}
 …
+}
 PassRefPtr<SimpleFontData> CSSFontFaceSource::getFontData(const FontDescription& fontDescription, bool syntheticBold, bool syntheticItalic, CSSFontSelector* fontSelector)
+RefPtr<Font> CSSFontFaceSource::font(const FontDescription& fontDescription, bool syntheticBold, bool syntheticItalic, CSSFontSelector* fontSelector)
+{
     // If the font hasn't loaded or an error occurred, then we've got nothing.
 …
 #endif
     ) {
         // We're local. Just return a SimpleFontData from the normal cache.
+        // We're local. Just return a Font from the normal cache.
         // We don't want to check alternate font family names here, so pass true as the checkingAlternateName parameter.
         return fontCache().fontForFamily(fontDescription, m_string, true);
+    }
-    // See if we have a mapping in our FontData cache.
     unsigned hashKey = (fontDescription.computedPixelSize() + 1) << 5 | fontDescription.widthVariant() << 3
                        | (fontDescription.orientation() == Vertical ? 4 : 0) | (syntheticBold ? 2 : 0) | (syntheticItalic ? 1 : 0);
     RefPtr<SimpleFontData> fontData = m_fontDataTable.add(hashKey, nullptr).iterator->value;
     if (fontData)
         return fontData.release();
+    RefPtr<Font> font = m_fontTable.add(hashKey, nullptr).iterator->value;
+    if (font)
+        return font.release();
     // If we are still loading, then we let the system pick a font.
 …
                 return nullptr;
             fontData = m_font->getFontData(fontDescription, m_string, syntheticBold, syntheticItalic, hasExternalSVGFont);
+            font = m_font->createFont(fontDescription, m_string, syntheticBold, syntheticItalic, hasExternalSVGFont);
         } else {
 #if ENABLE(SVG_FONTS)
 …
                     return nullptr;
                 std::unique_ptr<FontCustomPlatformData> customPlatformData = createFontCustomPlatformData(*m_generatedOTFBuffer);
                 fontData = SimpleFontData::create(customPlatformData->fontPlatformData(static_cast<int>(fontDescription.computedPixelSize()), syntheticBold, syntheticItalic, fontDescription.orientation(), fontDescription.widthVariant(), fontDescription.renderingMode()), true, false);
+                font = Font::create(customPlatformData->fontPlatformData(static_cast<int>(fontDescription.computedPixelSize()), syntheticBold, syntheticItalic, fontDescription.orientation(), fontDescription.widthVariant(), fontDescription.renderingMode()), true, false);
 #else
                 fontData = SimpleFontData::create(std::make_unique<SVGFontData>(m_svgFontFaceElement.get()), fontDescription.computedPixelSize(), syntheticBold, syntheticItalic);
+                font = Font::create(std::make_unique<SVGFontData>(m_svgFontFaceElement.get()), fontDescription.computedPixelSize(), syntheticBold, syntheticItalic);
 #endif
+            }
 …
         fontSelector->beginLoadingFontSoon(m_font.get());
         Ref<SimpleFontData> placeholderFont = fontCache().lastResortFallbackFont(fontDescription);
         Ref<SimpleFontData> placeholderFontCopyInLoadingState = SimpleFontData::create(placeholderFont->platformData(), true, true);
+        Ref<Font> placeholderFont = fontCache().lastResortFallbackFont(fontDescription);
+        Ref<Font> placeholderFontCopyInLoadingState = Font::create(placeholderFont->platformData(), true, true);
         return WTF::move(placeholderFontCopyInLoadingState);
+    }
     return fontData.release();
+    return font.release();
+}

trunk/Source/WebCore/css/CSSFontFaceSource.h

-              r178292
+              r178940
 class CSSFontFace;
 class CSSFontSelector;
+class Font;
 class FontDescription;
-class SimpleFontData;
 class CSSFontFaceSource final : public CachedFontClient {
 …
     virtual void fontLoaded(CachedFont*) override;
     PassRefPtr<SimpleFontData> getFontData(const FontDescription&, bool syntheticBold, bool syntheticItalic, CSSFontSelector*);
+    RefPtr<Font> font(const FontDescription&, bool syntheticBold, bool syntheticItalic, CSSFontSelector*);
     void pruneTable();
 …
     CachedResourceHandle<CachedFont> m_font; // For remote fonts, a pointer to our cached resource.
     CSSFontFace* m_face; // Our owning font face.
     HashMap<unsigned, RefPtr<SimpleFontData>> m_fontDataTable; // The hash key is composed of size synthetic styles.
+    HashMap<unsigned, RefPtr<Font>> m_fontTable; // The hash key is composed of size synthetic styles.
 #if ENABLE(SVG_OTF_CONVERTER)

trunk/Source/WebCore/css/CSSFontSelector.cpp

-              r178388
+              r178940
 #include "CachedResourceLoader.h"
 #include "Document.h"
+#include "Font.h"
 #include "FontCache.h"
 #include "Frame.h"
 …
 #include "SVGNames.h"
 #include "Settings.h"
-#include "SimpleFontData.h"
 #include "StyleProperties.h"
 #include "StyleResolver.h"
 …
+}
 size_t CSSFontSelector::fallbackFontDataCount()
+size_t CSSFontSelector::fallbackFontCount()
+{
     if (!m_document)
 …
+}
 PassRefPtr<SimpleFontData> CSSFontSelector::fallbackFontDataAt(const FontDescription& fontDescription, size_t index)
+PassRefPtr<Font> CSSFontSelector::fallbackFontAt(const FontDescription& fontDescription, size_t index)
+{
     ASSERT_UNUSED(index, !index);

trunk/Source/WebCore/css/CSSFontSelector.h

-              r178388
+              r178940
 #include "CachedResourceHandle.h"
+#include "Font.h"
 #include "FontSelector.h"
-#include "SimpleFontData.h"
 #include "Timer.h"
 #include <memory>
 …
     virtual FontRanges fontRangesForFamily(const FontDescription&, const AtomicString&) override;
     virtual size_t fallbackFontDataCount() override;
     virtual PassRefPtr<SimpleFontData> fallbackFontDataAt(const FontDescription&, size_t) override;
+    virtual size_t fallbackFontCount() override;
+    virtual PassRefPtr<Font> fallbackFontAt(const FontDescription&, size_t) override;
     CSSSegmentedFontFace* getFontFace(const FontDescription&, const AtomicString& family);

trunk/Source/WebCore/css/CSSSegmentedFontFace.cpp

-              r178388
+              r178940
 #include "CSSFontSelector.h"
 #include "Document.h"
+#include "Font.h"
 #include "FontDescription.h"
 #include "RuntimeEnabledFeatures.h"
-#include "SimpleFontData.h"
 namespace WebCore {
 …
+}
 static void appendFontDataWithInvalidUnicodeRangeIfLoading(FontRanges& ranges, Ref<SimpleFontData>&& fontData, const Vector<CSSFontFace::UnicodeRange>& unicodeRanges)
+static void appendFontWithInvalidUnicodeRangeIfLoading(FontRanges& ranges, Ref<Font>&& font, const Vector<CSSFontFace::UnicodeRange>& unicodeRanges)
+{
     if (fontData->isLoading()) {
         ranges.appendRange(FontRanges::Range(0, 0, WTF::move(fontData)));
+    if (font->isLoading()) {
+        ranges.appendRange(FontRanges::Range(0, 0, WTF::move(font)));
         return;
+    }
 …
     unsigned numRanges = unicodeRanges.size();
     if (!numRanges) {
         ranges.appendRange(FontRanges::Range(0, 0x7FFFFFFF, WTF::move(fontData)));
+        ranges.appendRange(FontRanges::Range(0, 0x7FFFFFFF, WTF::move(font)));
         return;
+    }
     for (unsigned j = 0; j < numRanges; ++j)
         ranges.appendRange(FontRanges::Range(unicodeRanges[j].from(), unicodeRanges[j].to(), fontData.copyRef()));
+        ranges.appendRange(FontRanges::Range(unicodeRanges[j].from(), unicodeRanges[j].to(), font.copyRef()));
+}
 …
             bool syntheticBold = !(traitsMask & (FontWeight600Mask | FontWeight700Mask | FontWeight800Mask | FontWeight900Mask)) && (desiredTraitsMask & (FontWeight600Mask | FontWeight700Mask | FontWeight800Mask | FontWeight900Mask));
             bool syntheticItalic = !(traitsMask & FontStyleItalicMask) && (desiredTraitsMask & FontStyleItalicMask);
             if (RefPtr<SimpleFontData> faceFontData = face->getFontData(fontDescription, syntheticBold, syntheticItalic))
                 appendFontDataWithInvalidUnicodeRangeIfLoading(fontRanges, faceFontData.releaseNonNull(), face->ranges());
+            if (RefPtr<Font> faceFont = face->font(fontDescription, syntheticBold, syntheticItalic))
+                appendFontWithInvalidUnicodeRangeIfLoading(fontRanges, faceFont.releaseNonNull(), face->ranges());
+        }
+    }

trunk/Source/WebCore/editing/Editor.h

-              r177739
+              r178940
 class Pasteboard;
 class SharedBuffer;
 class SimpleFontData;
+class Font;
 class SpellCheckRequest;
 class SpellChecker;
 …
     WEBCORE_EXPORT static RenderStyle* styleForSelectionStart(Frame* , Node *&nodeToRemove);
     WEBCORE_EXPORT bool insertParagraphSeparatorInQuotedContent();
     WEBCORE_EXPORT const SimpleFontData* fontForSelection(bool&) const;
+    WEBCORE_EXPORT const Font* fontForSelection(bool&) const;
     WEBCORE_EXPORT NSDictionary *fontAttributesForSelectionStart() const;
     WEBCORE_EXPORT String stringSelectionForPasteboard();

trunk/Source/WebCore/editing/cocoa/HTMLConverter.mm

-              r178510
+              r178940
     if (!renderer)
         return nil;
     return renderer->style().fontCascade().primaryFontData().getNSFont();
+    return renderer->style().fontCascade().primaryFont().getNSFont();
+}
 #else
 …
     if (!renderer)
         return nil;
     return (PlatformFont *)renderer->style().fontCascade().primaryFontData().getCTFont();
+    return (PlatformFont *)renderer->style().fontCascade().primaryFont().getCTFont();
+}
 #endif
 …
         if (style.textDecorationsInEffect() & TextDecorationLineThrough)
             [attrs.get() setObject:[NSNumber numberWithInteger:NSUnderlineStyleSingle] forKey:NSStrikethroughStyleAttributeName];
         if (NSFont *font = style.fontCascade().primaryFontData().getNSFont())
+        if (NSFont *font = style.fontCascade().primaryFont().getNSFont())
             [attrs.get() setObject:font forKey:NSFontAttributeName];
         else
             [attrs.get() setObject:[fontManager convertFont:WebDefaultFont() toSize:style.fontCascade().primaryFontData().platformData().size()] forKey:NSFontAttributeName];
+            [attrs.get() setObject:[fontManager convertFont:WebDefaultFont() toSize:style.fontCascade().primaryFont().platformData().size()] forKey:NSFontAttributeName];
         if (style.visitedDependentColor(CSSPropertyColor).alpha())
             [attrs.get() setObject:nsColor(style.visitedDependentColor(CSSPropertyColor)) forKey:NSForegroundColorAttributeName];

trunk/Source/WebCore/editing/ios/EditorIOS.mm

-              r178510
+              r178940
+}
 const SimpleFontData* Editor::fontForSelection(bool& hasMultipleFonts) const
+const Font* Editor::fontForSelection(bool& hasMultipleFonts) const
+{
     hasMultipleFonts = false;
 …
         RenderStyle* style = styleForSelectionStart(&m_frame, nodeToRemove); // sets nodeToRemove
         const SimpleFontData* result = nullptr;
+        const Font* result = nullptr;
         if (style)
             result = &style->fontCascade().primaryFontData();
+            result = &style->fontCascade().primaryFont();
         if (nodeToRemove) {
 …
+    }
     const SimpleFontData* font = 0;
+    const Font* font = 0;
     RefPtr<Range> range = m_frame.selection().toNormalizedRange();
     if (Node* startNode = adjustedSelectionStartForStyleComputation(m_frame.selection().selection()).deprecatedNode()) {
 …
                 continue;
             // FIXME: Are there any node types that have renderers, but that we should be skipping?
             const SimpleFontData& primaryFont = renderer->style().fontCascade().primaryFontData();
+            const Font& primaryFont = renderer->style().fontCascade().primaryFont();
             if (!font)
                 font = &primaryFont;
 …
     NSMutableDictionary* result = [NSMutableDictionary dictionary];
     CTFontRef font = style->fontCascade().primaryFontData().getCTFont();
+    CTFontRef font = style->fontCascade().primaryFont().getCTFont();
     if (font)
         [result setObject:(id)font forKey:NSFontAttributeName];

trunk/Source/WebCore/editing/mac/EditorMac.mm

-              r178510
+              r178940
+}
 const SimpleFontData* Editor::fontForSelection(bool& hasMultipleFonts) const
+const Font* Editor::fontForSelection(bool& hasMultipleFonts) const
+{
     hasMultipleFonts = false;
 …
         RenderStyle* style = styleForSelectionStart(&m_frame, nodeToRemove); // sets nodeToRemove
         const SimpleFontData* result = nullptr;
+        const Font* result = nullptr;
         if (style)
             result = &style->fontCascade().primaryFontData();
+            result = &style->fontCascade().primaryFont();
         if (nodeToRemove)
 …
+    }
     const SimpleFontData* font = 0;
+    const Font* font = 0;
     RefPtr<Range> range = m_frame.selection().toNormalizedRange();
     Node* startNode = adjustedSelectionStartForStyleComputation(m_frame.selection().selection()).deprecatedNode();
 …
                 continue;
             // FIXME: Are there any node types that have renderers, but that we should be skipping?
             const SimpleFontData& primaryFont = renderer->style().fontCascade().primaryFontData();
+            const Font& primaryFont = renderer->style().fontCascade().primaryFont();
             if (!font)
                 font = &primaryFont;
 …
         [result setObject:nsColor(style->visitedDependentColor(CSSPropertyBackgroundColor)) forKey:NSBackgroundColorAttributeName];
     if (style->fontCascade().primaryFontData().getNSFont())
         [result setObject:style->fontCascade().primaryFontData().getNSFont() forKey:NSFontAttributeName];
+    if (style->fontCascade().primaryFont().getNSFont())
+        [result setObject:style->fontCascade().primaryFont().getNSFont() forKey:NSFontAttributeName];
     if (style->visitedDependentColor(CSSPropertyColor).isValid() && style->visitedDependentColor(CSSPropertyColor) != Color::black)

trunk/Source/WebCore/loader/cache/CachedFont.cpp

r178628	r178940
100	100	bool CachedFont::ensureCustomFontData(SharedBuffer* data)
101	101	{
102		if (!m_fontData && !errorOccurred() && !isLoading() && data) {
	102	if (!m_fontCustomPlatformData && !errorOccurred() && !isLoading() && data) {
103	103	RefPtr<SharedBuffer> buffer(data);
104	104
…	…
113	113	#endif
114	114
115		m_fontData = buffer ? createFontCustomPlatformData(*buffer) : nullptr;
116		m_hasCreatedFontDataWrappingResource = m_fontData && (buffer == m_data);
117		if (!m_fontData)
	115	m_fontCustomPlatformData = buffer ? createFontCustomPlatformData(*buffer) : nullptr;
	116	m_hasCreatedFontDataWrappingResource = m_fontCustomPlatformData && (buffer == m_data);
	117	if (!m_fontCustomPlatformData)
118	118	setStatus(DecodeError);
119	119	}
120	120
121		return m_fontData.get();
	121	return m_fontCustomPlatformData.get();
122	122	}
123	123
124		~~PassRefPtr<SimpleFontData> CachedFont::getFontData~~(const FontDescription& fontDescription, const AtomicString&, bool syntheticBold, bool syntheticItalic, bool)
	124	RefPtr<Font> CachedFont::createFont(const FontDescription& fontDescription, const AtomicString&, bool syntheticBold, bool syntheticItalic, bool)
125	125	{
126		return ~~SimpleFontData~~::create(platformDataFromCustomData(fontDescription.computedPixelSize(), syntheticBold, syntheticItalic,
	126	return Font::create(platformDataFromCustomData(fontDescription.computedPixelSize(), syntheticBold, syntheticItalic,
127	127	fontDescription.orientation(), fontDescription.widthVariant(), fontDescription.renderingMode()), true, false);
128	128	}
…	…
130	130	FontPlatformData CachedFont::platformDataFromCustomData(float size, bool bold, bool italic, FontOrientation orientation, FontWidthVariant widthVariant, FontRenderingMode renderingMode)
131	131	{
132		ASSERT(m_fontData);
133		return m_fontData->fontPlatformData(static_cast<int>(size), bold, italic, orientation, widthVariant, renderingMode);
	132	ASSERT(m_fontCustomPlatformData);
	133	return m_fontCustomPlatformData->fontPlatformData(static_cast<int>(size), bold, italic, orientation, widthVariant, renderingMode);
134	134	}
135	135
136	136	void CachedFont::allClientsRemoved()
137	137	{
138		m_fontData = nullptr;
	138	m_fontCustomPlatformData = nullptr;
139	139	}
140	140

trunk/Source/WebCore/loader/cache/CachedFont.h

-              r178628
+              r178940
 #include "CachedResource.h"
 #include "CachedResourceClient.h"
+#include "Font.h"
 #include "FontOrientation.h"
 #include "FontRenderingMode.h"
 #include "FontWidthVariant.h"
-#include "SimpleFontData.h"
 namespace WebCore {
 …
     virtual bool ensureCustomFontData(bool externalSVG, const AtomicString& remoteURI);
     virtual PassRefPtr<SimpleFontData> getFontData(const FontDescription&, const AtomicString& remoteURI, bool syntheticBold, bool syntheticItalic, bool externalSVG);
+    virtual RefPtr<Font> createFont(const FontDescription&, const AtomicString& remoteURI, bool syntheticBold, bool syntheticItalic, bool externalSVG);
 protected:
 …
     virtual void allClientsRemoved() override;
     std::unique_ptr<FontCustomPlatformData> m_fontData;
+    std::unique_ptr<FontCustomPlatformData> m_fontCustomPlatformData;
     bool m_loadInitiated;
     bool m_hasCreatedFontDataWrappingResource;

trunk/Source/WebCore/loader/cache/CachedSVGFont.cpp

-              r178628
+              r178940
+}
 PassRefPtr<SimpleFontData> CachedSVGFont::getFontData(const FontDescription& fontDescription, const AtomicString& remoteURI, bool syntheticBold, bool syntheticItalic, bool externalSVG)
+RefPtr<Font> CachedSVGFont::createFont(const FontDescription& fontDescription, const AtomicString& remoteURI, bool syntheticBold, bool syntheticItalic, bool externalSVG)
+{
 #if ENABLE(SVG_OTF_CONVERTER)
     if (!externalSVG || firstFontFace(remoteURI))
         return CachedFont::getFontData(fontDescription, remoteURI, syntheticBold, syntheticItalic, externalSVG);
+        return CachedFont::createFont(fontDescription, remoteURI, syntheticBold, syntheticItalic, externalSVG);
 #else
     if (!externalSVG)
         return CachedFont::getFontData(fontDescription, remoteURI, syntheticBold, syntheticItalic, externalSVG);
+        return CachedFont::createFont(fontDescription, remoteURI, syntheticBold, syntheticItalic, externalSVG);
     if (SVGFontFaceElement* firstFontFace = this->firstFontFace(remoteURI))
         return SimpleFontData::create(std::make_unique<SVGFontData>(firstFontFace), fontDescription.computedPixelSize(), syntheticBold, syntheticItalic);
+        return Font::create(std::make_unique<SVGFontData>(firstFontFace), fontDescription.computedPixelSize(), syntheticBold, syntheticItalic);
 #endif
     return nullptr;

trunk/Source/WebCore/loader/cache/CachedSVGFont.h

r178628	r178940
41	41	virtual bool ensureCustomFontData(bool externalSVG, const AtomicString& remoteURI) override;
42	42
43		virtual ~~PassRefPtr<SimpleFontData> getFontData~~(const FontDescription&, const AtomicString& remoteURI, bool syntheticBold, bool syntheticItalic, bool externalSVG) override;
	43	virtual RefPtr<Font> createFont(const FontDescription&, const AtomicString& remoteURI, bool syntheticBold, bool syntheticItalic, bool externalSVG) override;
44	44
45	45	private:

trunk/Source/WebCore/platform/graphics/Font.cpp

-              r178650
+              r178940
 #include "config.h"
 #include "SimpleFontData.h"
+#include "Font.h"
 #if PLATFORM(IOS) || (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED > 1080)
 …
 const float emphasisMarkFontSizeMultiplier = 0.5f;
 SimpleFontData::SimpleFontData(const FontPlatformData& platformData, bool isCustomFont, bool isLoading, bool isTextOrientationFallback)
+Font::Font(const FontPlatformData& platformData, bool isCustomFont, bool isLoading, bool isTextOrientationFallback)
     : m_maxCharWidth(-1)
     , m_avgCharWidth(-1)
 …
+}
 SimpleFontData::SimpleFontData(std::unique_ptr<SVGData> svgData, float fontSize, bool syntheticBold, bool syntheticItalic)
+Font::Font(std::unique_ptr<SVGData> svgData, float fontSize, bool syntheticBold, bool syntheticItalic)
     : m_platformData(FontPlatformData(fontSize, syntheticBold, syntheticItalic))
     , m_svgData(WTF::move(svgData))
 …
 #endif
+{
     m_svgData->initializeFontData(this, fontSize);
+    m_svgData->initializeFont(this, fontSize);
+}
 // Estimates of avgCharWidth and maxCharWidth for platforms that don't support accessing these values from the font.
 void SimpleFontData::initCharWidths()
+void Font::initCharWidths()
+{
     auto* glyphPageZero = glyphPage(0);
 …
+}
 void SimpleFontData::platformGlyphInit()
+void Font::platformGlyphInit()
+{
     auto* glyphPageZero = glyphPage(0);
 …
     // Nasty hack to determine if we should round or ceil space widths.
     // If the font is monospace or fake monospace we ceil to ensure that
     // every character and the space are the same width.  Otherwise we round.
+    // every character and the space are the same width. Otherwise we round.
     m_spaceGlyph = glyphPageZero->glyphDataForCharacter(' ').glyph;
     float width = widthForGlyph(m_spaceGlyph);
 …
     // Force the glyph for ZERO WIDTH SPACE to have zero width, unless it is shared with SPACE.
     // Helvetica is an example of a non-zero width ZERO WIDTH SPACE glyph.
     // See <http://bugs.webkit.org/show_bug.cgi?id=13178> and SimpleFontData::isZeroWidthSpaceGlyph()
+    // See <http://bugs.webkit.org/show_bug.cgi?id=13178> and Font::isZeroWidthSpaceGlyph()
     if (m_zeroWidthSpaceGlyph == m_spaceGlyph)
         m_zeroWidthSpaceGlyph = 0;
+}
 SimpleFontData::~SimpleFontData()
+Font::~Font()
+{
     removeFromSystemFallbackCache();
+}
 static bool fillGlyphPage(GlyphPage& pageToFill, unsigned offset, unsigned length, UChar* buffer, unsigned bufferLength, const SimpleFontData* fontData)
+static bool fillGlyphPage(GlyphPage& pageToFill, unsigned offset, unsigned length, UChar* buffer, unsigned bufferLength, const Font* font)
+{
 #if ENABLE(SVG_FONTS)
     if (auto* svgData = fontData->svgData())
         return svgData->fillSVGGlyphPage(&pageToFill, offset, length, buffer, bufferLength, fontData);
 #endif
     bool hasGlyphs = pageToFill.fill(offset, length, buffer, bufferLength, fontData);
+    if (auto* svgData = font->svgData())
+        return svgData->fillSVGGlyphPage(&pageToFill, offset, length, buffer, bufferLength, font);
+#endif
+    bool hasGlyphs = pageToFill.fill(offset, length, buffer, bufferLength, font);
 #if ENABLE(OPENTYPE_VERTICAL)
     if (hasGlyphs && fontData->verticalData())
         fontData->verticalData()->substituteWithVerticalGlyphs(fontData, &pageToFill, offset, length);
+    if (hasGlyphs && font->verticalData())
+        font->verticalData()->substituteWithVerticalGlyphs(font, &pageToFill, offset, length);
 #endif
     return hasGlyphs;
+}
 static RefPtr<GlyphPage> createAndFillGlyphPage(unsigned pageNumber, const SimpleFontData* fontData)
+static RefPtr<GlyphPage> createAndFillGlyphPage(unsigned pageNumber, const Font* font)
+{
 #if PLATFORM(IOS)
     // FIXME: Times New Roman contains Arabic glyphs, but Core Text doesn't know how to shape them. See <rdar://problem/9823975>.
     // Once we have the fix for <rdar://problem/9823975> then remove this code together with SimpleFontData::shouldNotBeUsedForArabic()
+    // Once we have the fix for <rdar://problem/9823975> then remove this code together with Font::shouldNotBeUsedForArabic()
     // in <rdar://problem/12096835>.
     if (pageNumber == 6 && fontData->shouldNotBeUsedForArabic())
+    if (pageNumber == 6 && font->shouldNotBeUsedForArabic())
         return nullptr;
 #endif
 …
             buffer[i] = start + i;
         if (start == 0) {
+        if (!start) {
             // Control characters must not render at all.
             for (unsigned i = 0; i < 0x20; ++i)
 …
     // for only 128 out of 256 characters.
     RefPtr<GlyphPage> glyphPage;
     if (GlyphPage::mayUseMixedFontDataWhenFilling(buffer, bufferLength, fontData))
         glyphPage = GlyphPage::createForMixedFontData();
+    if (GlyphPage::mayUseMixedFontsWhenFilling(buffer, bufferLength, font))
+        glyphPage = GlyphPage::createForMixedFonts();
     else
         glyphPage = GlyphPage::createForSingleFontData(fontData);
     bool haveGlyphs = fillGlyphPage(*glyphPage, 0, GlyphPage::size, buffer, bufferLength, fontData);
+        glyphPage = GlyphPage::createForSingleFont(font);
+    bool haveGlyphs = fillGlyphPage(*glyphPage, 0, GlyphPage::size, buffer, bufferLength, font);
     if (!haveGlyphs)
         return nullptr;
 …
+}
 const GlyphPage* SimpleFontData::glyphPage(unsigned pageNumber) const
+{
     if (pageNumber == 0) {
+const GlyphPage* Font::glyphPage(unsigned pageNumber) const
+{
+    if (!pageNumber) {
         if (!m_glyphPageZero)
             m_glyphPageZero = createAndFillGlyphPage(0, this);
 …
+}
 Glyph SimpleFontData::glyphForCharacter(UChar32 character) const
+Glyph Font::glyphForCharacter(UChar32 character) const
+{
     auto* page = glyphPage(character / GlyphPage::size);
 …
+}
 GlyphData SimpleFontData::glyphDataForCharacter(UChar32 character) const
+GlyphData Font::glyphDataForCharacter(UChar32 character) const
+{
     auto* page = glyphPage(character / GlyphPage::size);
 …
+}
 PassRefPtr<SimpleFontData> SimpleFontData::verticalRightOrientationFontData() const
+PassRefPtr<Font> Font::verticalRightOrientationFont() const
+{
     if (!m_derivedFontData)
 …
+}
 PassRefPtr<SimpleFontData> SimpleFontData::uprightOrientationFontData() const
+PassRefPtr<Font> Font::uprightOrientationFont() const
+{
     if (!m_derivedFontData)
 …
+}
 PassRefPtr<SimpleFontData> SimpleFontData::smallCapsFontData(const FontDescription& fontDescription) const
+PassRefPtr<Font> Font::smallCapsFont(const FontDescription& fontDescription) const
+{
     if (!m_derivedFontData)
         m_derivedFontData = std::make_unique<DerivedFontData>(isCustomFont());
     if (!m_derivedFontData->smallCaps)
         m_derivedFontData->smallCaps = createScaledFontData(fontDescription, smallCapsFontSizeMultiplier);
+        m_derivedFontData->smallCaps = createScaledFont(fontDescription, smallCapsFontSizeMultiplier);
     return m_derivedFontData->smallCaps;
+}
 PassRefPtr<SimpleFontData> SimpleFontData::emphasisMarkFontData(const FontDescription& fontDescription) const
+PassRefPtr<Font> Font::emphasisMarkFont(const FontDescription& fontDescription) const
+{
     if (!m_derivedFontData)
         m_derivedFontData = std::make_unique<DerivedFontData>(isCustomFont());
     if (!m_derivedFontData->emphasisMark)
         m_derivedFontData->emphasisMark = createScaledFontData(fontDescription, emphasisMarkFontSizeMultiplier);
+        m_derivedFontData->emphasisMark = createScaledFont(fontDescription, emphasisMarkFontSizeMultiplier);
     return m_derivedFontData->emphasisMark;
+}
 PassRefPtr<SimpleFontData> SimpleFontData::brokenIdeographFontData() const
+PassRefPtr<Font> Font::brokenIdeographFont() const
+{
     if (!m_derivedFontData)
 …
+}
 PassRefPtr<SimpleFontData> SimpleFontData::nonSyntheticItalicFontData() const
+PassRefPtr<Font> Font::nonSyntheticItalicFont() const
+{
     if (!m_derivedFontData)
 …
 #ifndef NDEBUG
 String SimpleFontData::description() const
+String Font::description() const
+{
     if (isSVGFont())
 …
 #endif
 const OpenTypeMathData* SimpleFontData::mathData() const
+const OpenTypeMathData* Font::mathData() const
+{
     if (m_isLoading)
 …
+}
 SimpleFontData::DerivedFontData::~DerivedFontData()
+{
+}
 PassRefPtr<SimpleFontData> SimpleFontData::createScaledFontData(const FontDescription& fontDescription, float scaleFactor) const
+Font::DerivedFontData::~DerivedFontData()
+{
+}
+PassRefPtr<Font> Font::createScaledFont(const FontDescription& fontDescription, float scaleFactor) const
+{
     if (isSVGFont())
         return nullptr;
     return platformCreateScaledFontData(fontDescription, scaleFactor);
+}
 bool SimpleFontData::applyTransforms(GlyphBufferGlyph* glyphs, GlyphBufferAdvance* advances, size_t glyphCount, TypesettingFeatures typesettingFeatures) const
+    return platformCreateScaledFont(fontDescription, scaleFactor);
+}
+bool Font::applyTransforms(GlyphBufferGlyph* glyphs, GlyphBufferAdvance* advances, size_t glyphCount, TypesettingFeatures typesettingFeatures) const
+{
     // We need to handle transforms on SVG fonts internally, since they are rendered internally.
 …
+}
 // FontDatas are not refcounted to avoid cycles.
 typedef HashMap<std::pair<UChar32, unsigned>, SimpleFontData*> CharacterFallbackMap;
 typedef HashMap<const SimpleFontData*, CharacterFallbackMap> SystemFallbackCache;
+// Fonts are not ref'd to avoid cycles.
+typedef HashMap<std::pair<UChar32, unsigned>, Font*> CharacterFallbackMap;
+typedef HashMap<const Font*, CharacterFallbackMap> SystemFallbackCache;
 static SystemFallbackCache& systemFallbackCache()
 …
+}
 RefPtr<SimpleFontData> SimpleFontData::systemFallbackFontDataForCharacter(UChar32 character, const FontDescription& description, bool isForPlatformFont) const
+RefPtr<Font> Font::systemFallbackFontForCharacter(UChar32 character, const FontDescription& description, bool isForPlatformFont) const
+{
     auto fontAddResult = systemFallbackCache().add(this, CharacterFallbackMap());
 …
     auto characterAddResult = fontAddResult.iterator->value.add(key, nullptr);
     SimpleFontData*& fallbackFontData = characterAddResult.iterator->value;
     if (!fallbackFontData) {
+    Font*& fallbackFont = characterAddResult.iterator->value;
+    if (!fallbackFont) {
         UChar codeUnits[2];
         int codeUnitsLength;
 …
+        }
         fallbackFontData = fontCache().systemFallbackForCharacters(description, this, isForPlatformFont, codeUnits, codeUnitsLength).get();
         if (fallbackFontData)
             fallbackFontData->m_isUsedInSystemFallbackCache = true;
+    }
     return fallbackFontData;
+}
 void SimpleFontData::removeFromSystemFallbackCache()
+        fallbackFont = fontCache().systemFallbackForCharacters(description, this, isForPlatformFont, codeUnits, codeUnitsLength).get();
+        if (fallbackFont)
+            fallbackFont->m_isUsedInSystemFallbackCache = true;
+    }
+    return fallbackFont;
+}
+void Font::removeFromSystemFallbackCache()
+{
     systemFallbackCache().remove(this);

trunk/Source/WebCore/platform/graphics/Font.h

-              r178650
+              r178940
  */
+#ifndef SimpleFontData_h
+#define SimpleFontData_h
+#ifndef Font_h
+#define Font_h
+#include "FloatRect.h"
 #include "FontBaseline.h"
 #include "FontMetrics.h"
 #include "FontPlatformData.h"
-#include "FloatRect.h"
 #include "GlyphBuffer.h"
 #include "GlyphMetricsMap.h"
 …
 struct WidthIterator;
 enum FontDataVariant { AutoVariant, NormalVariant, SmallCapsVariant, EmphasisMarkVariant, BrokenIdeographVariant };
+enum FontVariant { AutoVariant, NormalVariant, SmallCapsVariant, EmphasisMarkVariant, BrokenIdeographVariant };
 enum Pitch { UnknownPitch, FixedPitch, VariablePitch };
 class SimpleFontData : public RefCounted<SimpleFontData> {
+class Font : public RefCounted<Font> {
 public:
     class SVGData {
 …
         virtual ~SVGData() { }
         virtual void initializeFontData(SimpleFontData*, float fontSize) = 0;
+        virtual void initializeFont(Font*, float fontSize) = 0;
         virtual float widthForSVGGlyph(Glyph, float fontSize) const = 0;
         virtual bool fillSVGGlyphPage(GlyphPage*, unsigned offset, unsigned length, UChar* buffer, unsigned bufferLength, const SimpleFontData*) const = 0;
+        virtual bool fillSVGGlyphPage(GlyphPage*, unsigned offset, unsigned length, UChar* buffer, unsigned bufferLength, const Font*) const = 0;
     };
     // Used to create platform fonts.
     static Ref<SimpleFontData> create(const FontPlatformData& platformData, bool isCustomFont = false, bool isLoading = false, bool isTextOrientationFallback = false)
+    static Ref<Font> create(const FontPlatformData& platformData, bool isCustomFont = false, bool isLoading = false, bool isTextOrientationFallback = false)
+    {
         return adoptRef(*new SimpleFontData(platformData, isCustomFont, isLoading, isTextOrientationFallback));
+        return adoptRef(*new Font(platformData, isCustomFont, isLoading, isTextOrientationFallback));
+    }
     // Used to create SVG Fonts.
     static Ref<SimpleFontData> create(std::unique_ptr<SVGData> svgData, float fontSize, bool syntheticBold, bool syntheticItalic)
+    static Ref<Font> create(std::unique_ptr<SVGData> svgData, float fontSize, bool syntheticBold, bool syntheticItalic)
+    {
         return adoptRef(*new SimpleFontData(WTF::move(svgData), fontSize, syntheticBold, syntheticItalic));
+    }
     ~SimpleFontData();
     static const SimpleFontData* systemFallback() { return reinterpret_cast<const SimpleFontData*>(-1); }
+        return adoptRef(*new Font(WTF::move(svgData), fontSize, syntheticBold, syntheticItalic));
+    }
+    ~Font();
+    static const Font* systemFallback() { return reinterpret_cast<const Font*>(-1); }
     const FontPlatformData& platformData() const { return m_platformData; }
 …
 #endif
     PassRefPtr<SimpleFontData> smallCapsFontData(const FontDescription&) const;
     PassRefPtr<SimpleFontData> emphasisMarkFontData(const FontDescription&) const;
     PassRefPtr<SimpleFontData> brokenIdeographFontData() const;
     PassRefPtr<SimpleFontData> nonSyntheticItalicFontData() const;
     PassRefPtr<SimpleFontData> variantFontData(const FontDescription& description, FontDataVariant variant) const
+    PassRefPtr<Font> smallCapsFont(const FontDescription&) const;
+    PassRefPtr<Font> emphasisMarkFont(const FontDescription&) const;
+    PassRefPtr<Font> brokenIdeographFont() const;
+    PassRefPtr<Font> nonSyntheticItalicFont() const;
+    PassRefPtr<Font> variantFont(const FontDescription& description, FontVariant variant) const
+    {
         switch (variant) {
         case SmallCapsVariant:
             return smallCapsFontData(description);
+            return smallCapsFont(description);
         case EmphasisMarkVariant:
             return emphasisMarkFontData(description);
+            return emphasisMarkFont(description);
         case BrokenIdeographVariant:
             return brokenIdeographFontData();
+            return brokenIdeographFont();
         case AutoVariant:
         case NormalVariant:
 …
+        }
         ASSERT_NOT_REACHED();
         return const_cast<SimpleFontData*>(this);
+    }
     PassRefPtr<SimpleFontData> verticalRightOrientationFontData() const;
     PassRefPtr<SimpleFontData> uprightOrientationFontData() const;
+        return const_cast<Font*>(this);
+    }
+    PassRefPtr<Font> verticalRightOrientationFont() const;
+    PassRefPtr<Font> uprightOrientationFont() const;
     bool hasVerticalGlyphs() const { return m_hasVerticalGlyphs; }
 …
     FloatRect boundsForGlyph(Glyph) const;
     float widthForGlyph(Glyph glyph) const;
+    float widthForGlyph(Glyph) const;
     FloatRect platformBoundsForGlyph(Glyph) const;
     float platformWidthForGlyph(Glyph) const;
 …
     Glyph glyphForCharacter(UChar32) const;
     RefPtr<SimpleFontData> systemFallbackFontDataForCharacter(UChar32, const FontDescription&, bool isForPlatformFont) const;
+    RefPtr<Font> systemFallbackFontForCharacter(UChar32, const FontDescription&, bool isForPlatformFont) const;
     const GlyphPage* glyphPage(unsigned pageNumber) const;
 …
 #if USE(APPKIT)
     const SimpleFontData* compositeFontReferenceFontData(NSFont *key) const;
+    const Font* compositeFontReferenceFont(NSFont *key) const;
     NSFont* getNSFont() const { return m_platformData.nsFont(); }
 #endif
 …
 private:
     SimpleFontData(const FontPlatformData&, bool isCustomFont = false, bool isLoading = false, bool isTextOrientationFallback = false);
     SimpleFontData(std::unique_ptr<SVGData>, float fontSize, bool syntheticBold, bool syntheticItalic);
+    Font(const FontPlatformData&, bool isCustomFont = false, bool isLoading = false, bool isTextOrientationFallback = false);
+    Font(std::unique_ptr<SVGData>, float fontSize, bool syntheticBold, bool syntheticItalic);
     void platformInit();
 …
     void initCharWidths();
     PassRefPtr<SimpleFontData> createScaledFontData(const FontDescription&, float scaleFactor) const;
     PassRefPtr<SimpleFontData> platformCreateScaledFontData(const FontDescription&, float scaleFactor) const;
+    PassRefPtr<Font> createScaledFont(const FontDescription&, float scaleFactor) const;
+    PassRefPtr<Font> platformCreateScaledFont(const FontDescription&, float scaleFactor) const;
     void removeFromSystemFallbackCache();
 …
     void initGDIFont();
     void platformCommonDestroy();
     FloatRect boundsForGDIGlyph(Glyph glyph) const;
     float widthForGDIGlyph(Glyph glyph) const;
+    FloatRect boundsForGDIGlyph(Glyph) const;
+    float widthForGDIGlyph(Glyph) const;
 #endif
 #if USE(CG)
     bool canUseFastGlyphAdvanceGetter(Glyph glyph, CGSize& advance, bool& populatedAdvance) const;
+    bool canUseFastGlyphAdvanceGetter(Glyph, CGSize& advance, bool& populatedAdvance) const;
     CGFontRenderingStyle renderingStyle() const;
     bool advanceForColorBitmapFont(Glyph, CGSize& result) const; // Returns true if the font is a color bitmap font
 …
     bool m_treatAsFixedPitch;
     bool m_isCustomFont;  // Whether or not we are custom font loaded via @font-face
+    bool m_isCustomFont; // Whether or not we are custom font loaded via @font-face
     bool m_isLoading; // Whether or not this custom font is still in the act of loading.
 …
         bool forCustomFont;
         RefPtr<SimpleFontData> smallCaps;
         RefPtr<SimpleFontData> emphasisMark;
         RefPtr<SimpleFontData> brokenIdeograph;
         RefPtr<SimpleFontData> verticalRightOrientation;
         RefPtr<SimpleFontData> uprightOrientation;
         RefPtr<SimpleFontData> nonSyntheticItalic;
+        RefPtr<Font> smallCaps;
+        RefPtr<Font> emphasisMark;
+        RefPtr<Font> brokenIdeograph;
+        RefPtr<Font> verticalRightOrientation;
+        RefPtr<Font> uprightOrientation;
+        RefPtr<Font> nonSyntheticItalic;
 #if USE(APPKIT)
         HashMap<NSFont*, RefPtr<SimpleFontData>> compositeFontReferences;
+        HashMap<NSFont*, RefPtr<Font>> compositeFontReferences;
 #endif
     };
 …
 };
 ALWAYS_INLINE FloatRect SimpleFontData::boundsForGlyph(Glyph glyph) const
+ALWAYS_INLINE FloatRect Font::boundsForGlyph(Glyph glyph) const
+{
     if (isZeroWidthSpaceGlyph(glyph))
 …
+}
 ALWAYS_INLINE float SimpleFontData::widthForGlyph(Glyph glyph) const
+ALWAYS_INLINE float Font::widthForGlyph(Glyph glyph) const
+{
     if (isZeroWidthSpaceGlyph(glyph))
 …
 } // namespace WebCore
 #endif // SimpleFontData_h
+#endif // Font_h

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

-              r178853
+              r178940
 // FIXME: We may be able to simplify this code using C++11 threading primitives, including std::call_once().
 static pthread_mutex_t fontDataLock;
+static pthread_mutex_t fontLock;
 static void initFontCacheLockOnce()
 …
     pthread_mutexattr_init(&mutexAttribute);
     pthread_mutexattr_settype(&mutexAttribute, PTHREAD_MUTEX_RECURSIVE);
     pthread_mutex_init(&fontDataLock, &mutexAttribute);
+    pthread_mutex_init(&fontLock, &mutexAttribute);
     pthread_mutexattr_destroy(&mutexAttribute);
+}
 …
+    {
         pthread_once(&initFontLockControl, initFontCacheLockOnce);
         int lockcode = pthread_mutex_lock(&fontDataLock);
         ASSERT_WITH_MESSAGE_UNUSED(lockcode, !lockcode, "fontDataLock lock failed with code:%d", lockcode);
+        int lockcode = pthread_mutex_lock(&fontLock);
+        ASSERT_WITH_MESSAGE_UNUSED(lockcode, !lockcode, "fontLock lock failed with code:%d", lockcode);
+    }
     ~FontLocker()
+    {
         int lockcode = pthread_mutex_unlock(&fontDataLock);
         ASSERT_WITH_MESSAGE_UNUSED(lockcode, !lockcode, "fontDataLock unlock failed with code:%d", lockcode);
+        int lockcode = pthread_mutex_unlock(&fontLock);
+        ASSERT_WITH_MESSAGE_UNUSED(lockcode, !lockcode, "fontLock unlock failed with code:%d", lockcode);
+    }
 };
 …
 };
 typedef HashMap<FontPlatformData, RefPtr<SimpleFontData>, FontDataCacheKeyHash, FontDataCacheKeyTraits> FontDataCache;
+typedef HashMap<FontPlatformData, RefPtr<Font>, FontDataCacheKeyHash, FontDataCacheKeyTraits> FontDataCache;
 static FontDataCache& cachedFonts()
 …
 const int cTargetUnderMemoryPressureInactiveFontData = 30;
 RefPtr<SimpleFontData> FontCache::fontForFamily(const FontDescription& fontDescription, const AtomicString& family, bool checkingAlternateName)
+RefPtr<Font> FontCache::fontForFamily(const FontDescription& fontDescription, const AtomicString& family, bool checkingAlternateName)
+{
     if (!m_purgeTimer.isActive())
 …
+}
 Ref<SimpleFontData> FontCache::fontForPlatformData(const FontPlatformData& platformData)
+Ref<Font> FontCache::fontForPlatformData(const FontPlatformData& platformData)
+{
 #if PLATFORM(IOS)
 …
     auto addResult = cachedFonts().add(platformData, nullptr);
     if (addResult.isNewEntry)
         addResult.iterator->value = SimpleFontData::create(platformData);
+        addResult.iterator->value = Font::create(platformData);
     return *addResult.iterator->value;
 …
     if (cachedFonts().size() < inactiveFontDataLimit)
         return;
     int inactiveCount = inactiveFontDataCount();
+    int inactiveCount = inactiveFontCount();
     if (inactiveCount <= inactiveFontDataLimit)
         return;
 …
     while (purgeCount) {
         Vector<RefPtr<SimpleFontData>, 20> fontsToDelete;
+        Vector<RefPtr<Font>, 20> fontsToDelete;
         for (auto& font : cachedFonts().values()) {
             if (!font->hasOneRef())
 …
                 verticalData->m_inFontCache = false;
+        }
         for (auto& fontData : cachedFonts().values()) {
             auto* verticalData = const_cast<OpenTypeVerticalData*>(fontData->verticalData());
+        for (auto& font : cachedFonts().values()) {
+            auto* verticalData = const_cast<OpenTypeVerticalData*>(font->verticalData());
             if (verticalData)
                 verticalData->m_inFontCache = true;
 …
+}
 size_t FontCache::fontDataCount()
+size_t FontCache::fontCount()
+{
     return cachedFonts().size();
+}
 size_t FontCache::inactiveFontDataCount()
+size_t FontCache::inactiveFontCount()
+{
 #if PLATFORM(IOS)
 …
 #if !PLATFORM(COCOA)
 RefPtr<SimpleFontData> FontCache::similarFontPlatformData(const FontDescription&)
+RefPtr<Font> FontCache::similarFont(const FontDescription&)
+{
     return nullptr;

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

-              r178510
+              r178940
 class FontSelector;
 class OpenTypeVerticalData;
 class SimpleFontData;
+class Font;
 #if PLATFORM(WIN)
 …
     // This method is implemented by the platform.
     RefPtr<SimpleFontData> systemFallbackForCharacters(const FontDescription&, const SimpleFontData* originalFontData, bool isPlatformFont, const UChar* characters, int length);
+    RefPtr<Font> systemFallbackForCharacters(const FontDescription&, const Font* originalFontData, bool isPlatformFont, const UChar* characters, int length);
     // Also implemented by the platform.
 …
     void getTraitsInFamily(const AtomicString&, Vector<unsigned>&);
     WEBCORE_EXPORT RefPtr<SimpleFontData> fontForFamily(const FontDescription&, const AtomicString&, bool checkingAlternateName = false);
     WEBCORE_EXPORT Ref<SimpleFontData> lastResortFallbackFont(const FontDescription&);
     WEBCORE_EXPORT Ref<SimpleFontData> fontForPlatformData(const FontPlatformData&);
     RefPtr<SimpleFontData> similarFontPlatformData(const FontDescription&);
+    WEBCORE_EXPORT RefPtr<Font> fontForFamily(const FontDescription&, const AtomicString&, bool checkingAlternateName = false);
+    WEBCORE_EXPORT Ref<Font> lastResortFallbackFont(const FontDescription&);
+    WEBCORE_EXPORT Ref<Font> fontForPlatformData(const FontPlatformData&);
+    RefPtr<Font> similarFont(const FontDescription&);
     void addClient(FontSelector*);
 …
     WEBCORE_EXPORT void invalidate();
     WEBCORE_EXPORT size_t fontDataCount();
     WEBCORE_EXPORT size_t inactiveFontDataCount();
+    WEBCORE_EXPORT size_t fontCount();
+    WEBCORE_EXPORT size_t inactiveFontCount();
     WEBCORE_EXPORT void purgeInactiveFontData(int count = INT_MAX);
 #if PLATFORM(WIN)
     RefPtr<SimpleFontData> fontDataFromDescriptionAndLogFont(const FontDescription&, const LOGFONT&, AtomicString& outFontFamilyName);
+    RefPtr<Font> fontFromDescriptionAndLogFont(const FontDescription&, const LOGFONT&, AtomicString& outFontFamilyName);
 #endif
 …
 #if PLATFORM(IOS)
     FontPlatformData* getCustomFallbackFont(const UInt32, const FontDescription&);
     PassRefPtr<SimpleFontData> getSystemFontFallbackForCharacters(const FontDescription&, const SimpleFontData*, const UChar* characters, int length);
+    PassRefPtr<Font> getSystemFontFallbackForCharacters(const FontDescription&, const Font*, const UChar* characters, int length);
 #endif
     std::unique_ptr<FontPlatformData> createFontPlatformData(const FontDescription&, const AtomicString& family);
 …
     friend class ComplexTextController;
 #endif
     friend class SimpleFontData;
+    friend class Font;
 };

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

-              r178853
+              r178940
 // FIXME: We should make this constructor platform-independent.
 FontCascade::FontCascade(const FontPlatformData& fontData, bool isPrinterFont, FontSmoothingMode fontSmoothingMode)
     : m_glyphs(FontGlyphs::createForPlatformFont(fontData))
+FontCascade::FontCascade(const FontPlatformData& font, bool isPrinterFont, FontSmoothingMode fontSmoothingMode)
+    : m_glyphs(FontGlyphs::createForPlatformFont(font))
     , m_letterSpacing(0)
     , m_wordSpacing(0)
 …
     m_fontDescription.setFontSmoothing(fontSmoothingMode);
 #if PLATFORM(IOS)
     m_fontDescription.setSpecifiedSize(CTFontGetSize(fontData.font()));
     m_fontDescription.setComputedSize(CTFontGetSize(fontData.font()));
     m_fontDescription.setIsItalic(CTFontGetSymbolicTraits(fontData.font()) & kCTFontTraitItalic);
     m_fontDescription.setWeight((CTFontGetSymbolicTraits(fontData.font()) & kCTFontTraitBold) ? FontWeightBold : FontWeightNormal);
+    m_fontDescription.setSpecifiedSize(CTFontGetSize(font.font()));
+    m_fontDescription.setComputedSize(CTFontGetSize(font.font()));
+    m_fontDescription.setIsItalic(CTFontGetSymbolicTraits(font.font()) & kCTFontTraitItalic);
+    m_fontDescription.setWeight((CTFontGetSymbolicTraits(font.font()) & kCTFontTraitBold) ? FontWeightBold : FontWeightNormal);
 #endif
+}
 …
 // FIXME: We should make this constructor platform-independent.
 #if PLATFORM(IOS)
 FontCascade::FontCascade(const FontPlatformData& fontData, PassRefPtr<FontSelector> fontSelector)
     : m_glyphs(FontGlyphs::createForPlatformFont(fontData))
+FontCascade::FontCascade(const FontPlatformData& font, PassRefPtr<FontSelector> fontSelector)
+    : m_glyphs(FontGlyphs::createForPlatformFont(font))
     , m_letterSpacing(0)
     , m_wordSpacing(0)
     , m_typesettingFeatures(computeTypesettingFeatures())
+{
     CTFontRef primaryFont = fontData.font();
+    CTFontRef primaryFont = font.font();
     m_fontDescription.setSpecifiedSize(CTFontGetSize(primaryFont));
     m_fontDescription.setComputedSize(CTFontGetSize(primaryFont));
     m_fontDescription.setIsItalic(CTFontGetSymbolicTraits(primaryFont) & kCTFontTraitItalic);
     m_fontDescription.setWeight((CTFontGetSymbolicTraits(primaryFont) & kCTFontTraitBold) ? FontWeightBold : FontWeightNormal);
     m_fontDescription.setUsePrinterFont(fontData.isPrinterFont());
+    m_fontDescription.setUsePrinterFont(font.isPrinterFont());
     m_glyphs = retrieveOrAddCachedFontGlyphs(m_fontDescription, fontSelector.get());
+}
 …
+}
 float FontCascade::width(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
+float FontCascade::width(const TextRun& run, HashSet<const Font*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
+{
     CodePath codePathToUse = codePath(run);
 …
         return *cacheEntry;
     HashSet<const SimpleFontData*> localFallbackFonts;
+    HashSet<const Font*> localFallbackFonts;
     if (!fallbackFonts)
         fallbackFonts = &localFallbackFonts;
 …
+}
 GlyphData FontCascade::glyphDataForCharacter(UChar32 c, bool mirror, FontDataVariant variant) const
+GlyphData FontCascade::glyphDataForCharacter(UChar32 c, bool mirror, FontVariant variant) const
+{
     if (variant == AutoVariant) {
         if (m_fontDescription.smallCaps() && !primaryFontData().isSVGFont()) {
+        if (m_fontDescription.smallCaps() && !primaryFont().isSVGFont()) {
             UChar32 upperC = u_toupper(c);
             if (upperC != c) {
 …
+}
 float FontCascade::width(TextLayout&, unsigned, unsigned, HashSet<const SimpleFontData*>*)
+float FontCascade::width(TextLayout&, unsigned, unsigned, HashSet<const Font*>*)
+{
     ASSERT_NOT_REACHED();
 …
 #if PLATFORM(MAC) || PLATFORM(IOS)
     // Internal fonts on OS X and iOS also have an invalid entry in the table for avgCharWidth.
     if (primaryFontDataIsSystemFont())
+    if (primaryFontIsSystemFont())
         return false;
 #endif
 …
     bool success = hasValidAverageCharWidth();
     if (success)
         width = roundf(primaryFontData().avgCharWidth()); // FIXME: primaryFontData() might not correspond to firstFamily().
+        width = roundf(primaryFont().avgCharWidth()); // FIXME: primaryFont() might not correspond to firstFamily().
     return success;
+}
 …
         return 0;
     const SimpleFontData* markFontData = markGlyphData.fontData;
+    const Font* markFontData = markGlyphData.font;
     ASSERT(markFontData);
     if (!markFontData)
 …
         return 0;
     const SimpleFontData* markFontData = markGlyphData.fontData;
+    const Font* markFontData = markGlyphData.font;
     ASSERT(markFontData);
     if (!markFontData)
 …
         return 0;
     const SimpleFontData* markFontData = markGlyphData.fontData;
+    const Font* markFontData = markGlyphData.font;
     ASSERT(markFontData);
     if (!markFontData)
 …
     // Draw each contiguous run of glyphs that use the same font data.
     const SimpleFontData* fontData = glyphBuffer.fontDataAt(0);
+    const Font* fontData = glyphBuffer.fontAt(0);
     FloatSize offset = glyphBuffer.offsetAt(0);
     FloatPoint startPoint(point.x(), point.y() - glyphBuffer.initialAdvance().height());
 …
 #endif
     while (nextGlyph < glyphBuffer.size()) {
         const SimpleFontData* nextFontData = glyphBuffer.fontDataAt(nextGlyph);
+        const Font* nextFontData = glyphBuffer.fontAt(nextGlyph);
         FloatSize nextOffset = glyphBuffer.offsetAt(nextGlyph);
 …
+}
 inline static float offsetToMiddleOfGlyph(const SimpleFontData* fontData, Glyph glyph)
+inline static float offsetToMiddleOfGlyph(const Font* fontData, Glyph glyph)
+{
     if (fontData->platformData().orientation() == Horizontal) {
 …
 inline static float offsetToMiddleOfGlyphAtIndex(const GlyphBuffer& glyphBuffer, size_t i)
+{
     return offsetToMiddleOfGlyph(glyphBuffer.fontDataAt(i), glyphBuffer.glyphAt(i));
+    return offsetToMiddleOfGlyph(glyphBuffer.fontAt(i), glyphBuffer.glyphAt(i));
+}
 …
         return;
     const SimpleFontData* markFontData = markGlyphData.fontData;
+    const Font* markFontData = markGlyphData.font;
     ASSERT(markFontData);
     if (!markFontData)
 …
+}
 float FontCascade::floatWidthForSimpleText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
+float FontCascade::floatWidthForSimpleText(const TextRun& run, HashSet<const Font*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
+{
     WidthIterator it(this, run, fallbackFonts, glyphOverflow);

trunk/Source/WebCore/platform/graphics/FontCascade.h

-              r178853
+              r178940
 #include "DashArray.h"
+#include "Font.h"
 #include "FontDescription.h"
 #include "FontGlyphs.h"
 #include "Path.h"
-#include "SimpleFontData.h"
 #include "TextDirection.h"
 #include "TypesettingFeatures.h"
 …
     enum CustomFontNotReadyAction { DoNotPaintIfFontNotReady, UseFallbackIfFontNotReady };
     WEBCORE_EXPORT float drawText(GraphicsContext*, const TextRun&, const FloatPoint&, int from = 0, int to = -1, CustomFontNotReadyAction = DoNotPaintIfFontNotReady) const;
     void drawGlyphs(GraphicsContext*, const SimpleFontData*, const GlyphBuffer&, int from, int numGlyphs, const FloatPoint&) const;
+    void drawGlyphs(GraphicsContext*, const Font*, const GlyphBuffer&, int from, int numGlyphs, const FloatPoint&) const;
     void drawEmphasisMarks(GraphicsContext*, const TextRun&, const AtomicString& mark, const FloatPoint&, int from = 0, int to = -1) const;
     DashArray dashesForIntersectionsWithRect(const TextRun&, const FloatPoint& textOrigin, const FloatRect& lineExtents) const;
     WEBCORE_EXPORT float width(const TextRun&, HashSet<const SimpleFontData*>* fallbackFonts = 0, GlyphOverflow* = 0) const;
+    WEBCORE_EXPORT float width(const TextRun&, HashSet<const Font*>* fallbackFonts = 0, GlyphOverflow* = 0) const;
     float width(const TextRun&, int& charsConsumed, String& glyphName) const;
     PassOwnPtr<TextLayout> createLayout(RenderText*, float xPos, bool collapseWhiteSpace) const;
     static void deleteLayout(TextLayout*);
     static float width(TextLayout&, unsigned from, unsigned len, HashSet<const SimpleFontData*>* fallbackFonts = 0);
+    static float width(TextLayout&, unsigned from, unsigned len, HashSet<const Font*>* fallbackFonts = 0);
     int offsetForPosition(const TextRun&, float position, bool includePartialGlyphs) const;
 …
     bool isPlatformFont() const { return m_glyphs->isForPlatformFont(); }
     const FontMetrics& fontMetrics() const { return primaryFontData().fontMetrics(); }
     float spaceWidth() const { return primaryFontData().spaceWidth() + m_letterSpacing; }
     float tabWidth(const SimpleFontData&, unsigned tabSize, float position) const;
     float tabWidth(unsigned tabSize, float position) const { return tabWidth(primaryFontData(), tabSize, position); }
+    const FontMetrics& fontMetrics() const { return primaryFont().fontMetrics(); }
+    float spaceWidth() const { return primaryFont().spaceWidth() + m_letterSpacing; }
+    float tabWidth(const Font&, unsigned tabSize, float position) const;
+    float tabWidth(unsigned tabSize, float position) const { return tabWidth(primaryFont(), tabSize, position); }
     bool hasValidAverageCharWidth() const;
     bool fastAverageCharWidthIfAvailable(float &width) const; // returns true on success
 …
     int emphasisMarkHeight(const AtomicString&) const;
     const SimpleFontData& primaryFontData() const;
+    const Font& primaryFont() const;
     const FontRanges& fallbackRangesAt(unsigned) const;
     GlyphData glyphDataForCharacter(UChar32, bool mirror, FontDataVariant = AutoVariant) const;
+    GlyphData glyphDataForCharacter(UChar32, bool mirror, FontVariant = AutoVariant) const;
 #if PLATFORM(COCOA)
     const SimpleFontData* fontDataForCombiningCharacterSequence(const UChar*, size_t length, FontDataVariant) const;
+    const Font* fontForCombiningCharacterSequence(const UChar*, size_t length, FontVariant) const;
 #endif
 …
     static CodePath characterRangeCodePath(const UChar*, unsigned len);
     bool primaryFontDataIsSystemFont() const;
+    bool primaryFontIsSystemFont() const;
 private:
 …
     void drawGlyphBuffer(GraphicsContext*, const TextRun&, const GlyphBuffer&, FloatPoint&) const;
     void drawEmphasisMarks(GraphicsContext*, const TextRun&, const GlyphBuffer&, const AtomicString&, const FloatPoint&) const;
     float floatWidthForSimpleText(const TextRun&, HashSet<const SimpleFontData*>* fallbackFonts = 0, GlyphOverflow* = 0) const;
+    float floatWidthForSimpleText(const TextRun&, HashSet<const Font*>* fallbackFonts = 0, GlyphOverflow* = 0) const;
     int offsetForPositionForSimpleText(const TextRun&, float position, bool includePartialGlyphs) const;
     void adjustSelectionRectForSimpleText(const TextRun&, LayoutRect& selectionRect, int from, int to) const;
 …
     float drawComplexText(GraphicsContext*, const TextRun&, const FloatPoint&, int from, int to) const;
     void drawEmphasisMarksForComplexText(GraphicsContext*, const TextRun&, const AtomicString& mark, const FloatPoint&, int from, int to) const;
     float floatWidthForComplexText(const TextRun&, HashSet<const SimpleFontData*>* fallbackFonts = 0, GlyphOverflow* = 0) const;
+    float floatWidthForComplexText(const TextRun&, HashSet<const Font*>* fallbackFonts = 0, GlyphOverflow* = 0) const;
     int offsetForPositionForComplexText(const TextRun&, float position, bool includePartialGlyphs) const;
     void adjustSelectionRectForComplexText(const TextRun&, LayoutRect& selectionRect, int from, int to) const;
 …
+}
 inline const SimpleFontData& FontCascade::primaryFontData() const
+inline const Font& FontCascade::primaryFont() const
+{
     ASSERT(m_glyphs);
     return m_glyphs->primarySimpleFontData(m_fontDescription);
+    return m_glyphs->primaryFont(m_fontDescription);
+}
 …
+}
 inline float FontCascade::tabWidth(const SimpleFontData& fontData, unsigned tabSize, float position) const
+inline float FontCascade::tabWidth(const Font& font, unsigned tabSize, float position) const
+{
     if (!tabSize)
         return letterSpacing();
     float tabWidth = tabSize * fontData.spaceWidth() + letterSpacing();
+    float tabWidth = tabSize * font.spaceWidth() + letterSpacing();
     float tabDeltaWidth = tabWidth - fmodf(position, tabWidth);
     return (tabDeltaWidth < fontData.spaceWidth() / 2) ? tabWidth : tabDeltaWidth;
+    return (tabDeltaWidth < font.spaceWidth() / 2) ? tabWidth : tabDeltaWidth;
+}

trunk/Source/WebCore/platform/graphics/FontGlyphs.cpp

-              r178853
+              r178940
 FontGlyphs::FontGlyphs(PassRefPtr<FontSelector> fontSelector)
     : m_cachedPrimarySimpleFontData(0)
+    : m_cachedPrimaryFont(0)
     , m_fontSelector(fontSelector)
     , m_fontSelectorVersion(m_fontSelector ? m_fontSelector->version() : 0)
 …
 FontGlyphs::FontGlyphs(const FontPlatformData& platformData)
     : m_cachedPrimarySimpleFontData(0)
+    : m_cachedPrimaryFont(0)
     , m_fontSelector(0)
     , m_fontSelectorVersion(0)
 …
     unsigned numRanges = primaryRanges.size();
     if (numRanges == 1)
         m_pitch = primaryRanges.rangeAt(0).fontData().pitch();
+        m_pitch = primaryRanges.rangeAt(0).font().pitch();
     else
         m_pitch = VariablePitch;
 …
     // For example on OS X, we know to map any families containing the words Arabic, Pashto, or Urdu to the
     // Geeza Pro font.
     return FontRanges(fontCache().similarFontPlatformData(description));
+    return FontRanges(fontCache().similarFont(description));
+}
 …
         unsigned fontSelectorFallbackIndex = m_lastRealizedFallbackIndex - description.familyCount();
         if (fontSelectorFallbackIndex == m_fontSelector->fallbackFontDataCount())
+        if (fontSelectorFallbackIndex == m_fontSelector->fallbackFontCount())
             return fontRanges;
         ++m_lastRealizedFallbackIndex;
         fontRanges = FontRanges(m_fontSelector->fallbackFontDataAt(description, fontSelectorFallbackIndex));
+        fontRanges = FontRanges(m_fontSelector->fallbackFontAt(description, fontSelectorFallbackIndex));
+    }
 …
 static GlyphData glyphDataForCJKCharacterWithoutSyntheticItalic(UChar32 character, GlyphData& data)
+{
     GlyphData nonItalicData = data.fontData->nonSyntheticItalicFontData()->glyphDataForCharacter(character);
     if (nonItalicData.fontData)
+    GlyphData nonItalicData = data.font->nonSyntheticItalicFont()->glyphDataForCharacter(character);
+    if (nonItalicData.font)
         return nonItalicData;
     return data;
 …
+{
     if (orientation == NonCJKGlyphOrientationUpright || shouldIgnoreRotation(character)) {
         GlyphData uprightData = data.fontData->uprightOrientationFontData()->glyphDataForCharacter(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.
         if (data.glyph == uprightData.glyph)
 …
         // 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.fontData)
+        if (uprightData.font)
             return uprightData;
     } else if (orientation == NonCJKGlyphOrientationVerticalRight) {
         GlyphData verticalRightData = data.fontData->verticalRightOrientationFontData()->glyphDataForCharacter(character);
+        GlyphData verticalRightData = data.font->verticalRightOrientationFont()->glyphDataForCharacter(character);
         // If the glyphs are distinct, we will make the assumption that the font has a vertical-right glyph baked
         // into it.
 …
             return data;
         // The glyphs are identical, meaning that we should just use the horizontal glyph.
         if (verticalRightData.fontData)
+        if (verticalRightData.font)
             return verticalRightData;
+    }
 …
+}
 GlyphData FontGlyphs::glyphDataForSystemFallback(UChar32 c, const FontDescription& description, FontDataVariant variant)
+GlyphData FontGlyphs::glyphDataForSystemFallback(UChar32 c, const FontDescription& description, FontVariant variant)
+{
     // System fallback is character-dependent.
     auto& primaryRanges = realizeFallbackRangesAt(description, 0);
     auto* originalFontData = primaryRanges.fontDataForCharacter(c);
     if (!originalFontData)
         originalFontData = &primaryRanges.fontDataForFirstRange();
     RefPtr<SimpleFontData> systemFallbackFontData = originalFontData->systemFallbackFontDataForCharacter(c, description, m_isForPlatformFont);
     if (!systemFallbackFontData)
+    auto* originalFont = primaryRanges.fontForCharacter(c);
+    if (!originalFont)
+        originalFont = &primaryRanges.fontForFirstRange();
+    RefPtr<Font> systemFallbackFont = originalFont->systemFallbackFontForCharacter(c, description, m_isForPlatformFont);
+    if (!systemFallbackFont)
         return GlyphData();
     if (systemFallbackFontData->platformData().orientation() == Vertical && !systemFallbackFontData->hasVerticalGlyphs() && FontCascade::isCJKIdeographOrSymbol(c))
+    if (systemFallbackFont->platformData().orientation() == Vertical && !systemFallbackFont->hasVerticalGlyphs() && FontCascade::isCJKIdeographOrSymbol(c))
         variant = BrokenIdeographVariant;
     GlyphData fallbackGlyphData;
     if (variant == NormalVariant)
         fallbackGlyphData = systemFallbackFontData->glyphDataForCharacter(c);
+        fallbackGlyphData = systemFallbackFont->glyphDataForCharacter(c);
     else
         fallbackGlyphData = systemFallbackFontData->variantFontData(description, variant)->glyphDataForCharacter(c);
     if (variant == NormalVariant && fallbackGlyphData.fontData) {
         if (!FontCascade::isCJKIdeographOrSymbol(c) && fallbackGlyphData.fontData->platformData().orientation() == Vertical && !fallbackGlyphData.fontData->isTextOrientationFallback())
+        fallbackGlyphData = systemFallbackFont->variantFont(description, variant)->glyphDataForCharacter(c);
+    if (variant == NormalVariant && fallbackGlyphData.font) {
+        if (!FontCascade::isCJKIdeographOrSymbol(c) && fallbackGlyphData.font->platformData().orientation() == Vertical && !fallbackGlyphData.font->isTextOrientationFallback())
             fallbackGlyphData = glyphDataForNonCJKCharacterWithGlyphOrientation(c, description.nonCJKGlyphOrientation(), fallbackGlyphData);
+    }
 …
     // Keep the system fallback fonts we use alive.
     if (fallbackGlyphData.glyph)
         m_systemFallbackFontDataSet.add(systemFallbackFontData.release());
+        m_systemFallbackFontSet.add(systemFallbackFont.release());
     return fallbackGlyphData;
+}
 GlyphData FontGlyphs::glyphDataForVariant(UChar32 c, const FontDescription& description, FontDataVariant variant, unsigned fallbackIndex)
+GlyphData FontGlyphs::glyphDataForVariant(UChar32 c, const FontDescription& description, FontVariant variant, unsigned fallbackIndex)
+{
     while (true) {
 …
         if (fontRanges.isNull())
             break;
         auto* fontData = fontRanges.fontDataForCharacter(c);
         GlyphData data = fontData ? fontData->glyphDataForCharacter(c) : GlyphData();
         if (data.fontData) {
             // The variantFontData function should not normally return 0.
+        auto* font = fontRanges.fontForCharacter(c);
+        GlyphData data = font ? font->glyphDataForCharacter(c) : GlyphData();
+        if (data.font) {
+            // The variantFont function should not normally return 0.
             // But if it does, we will just render the capital letter big.
             RefPtr<SimpleFontData> variantFontData = data.fontData->variantFontData(description, variant);
             if (!variantFontData)
+            RefPtr<Font> variantFont = data.font->variantFont(description, variant);
+            if (!variantFont)
                 return data;
             return variantFontData->glyphDataForCharacter(c);
+            return variantFont->glyphDataForCharacter(c);
+        }
+    }
 …
         if (fontRanges.isNull())
             break;
         auto* simpleFontData = fontRanges.fontDataForCharacter(c);
         auto* page = simpleFontData ? simpleFontData->glyphPage(pageNumber) : nullptr;
+        auto* font = fontRanges.fontForCharacter(c);
+        auto* page = font ? font->glyphPage(pageNumber) : nullptr;
         if (!page)
             continue;
         GlyphData data = page->glyphDataForCharacter(c);
         if (data.fontData) {
             if (data.fontData->platformData().orientation() == Vertical && !data.fontData->isTextOrientationFallback()) {
+        if (data.font) {
+            if (data.font->platformData().orientation() == Vertical && !data.font->isTextOrientationFallback()) {
                 if (!FontCascade::isCJKIdeographOrSymbol(c))
                     return glyphDataForNonCJKCharacterWithGlyphOrientation(c, description.nonCJKGlyphOrientation(), data);
                 if (!data.fontData->hasVerticalGlyphs()) {
+                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).
 …
+                }
 #if PLATFORM(COCOA)
                 if (data.fontData->platformData().syntheticOblique())
+                if (data.font->platformData().syntheticOblique())
                     return glyphDataForCJKCharacterWithoutSyntheticItalic(c, data);
 #endif
 …
 static RefPtr<GlyphPage> glyphPageFromFontRanges(unsigned pageNumber, const FontRanges& fontRanges)
+{
     const SimpleFontData* simpleFontData = nullptr;
+    const Font* font = nullptr;
     UChar32 pageRangeFrom = pageNumber * GlyphPage::size;
     UChar32 pageRangeTo = pageRangeFrom + GlyphPage::size - 1;
 …
         if (range.to()) {
             if (range.from() <= pageRangeFrom && pageRangeTo <= range.to())
                 simpleFontData = &range.fontData();
+                font = &range.font();
             break;
+        }
+    }
     if (!simpleFontData)
+    if (!font)
         return nullptr;
     if (simpleFontData->platformData().orientation() == Vertical)
+    if (font->platformData().orientation() == Vertical)
         return nullptr;
     return const_cast<GlyphPage*>(simpleFontData->glyphPage(pageNumber));
+}
 GlyphData FontGlyphs::glyphDataForCharacter(UChar32 c, const FontDescription& description, FontDataVariant variant)
+    return const_cast<GlyphPage*>(font->glyphPage(pageNumber));
+}
+GlyphData FontGlyphs::glyphDataForCharacter(UChar32 c, const FontDescription& description, FontVariant variant)
+{
     ASSERT(isMainThread());
 …
     if (!glyphData.glyph) {
         if (!cachedPage)
             cachedPage = GlyphPage::createForMixedFontData();
+            cachedPage = GlyphPage::createForMixedFonts();
         else if (cachedPage->isImmutable())
             cachedPage = GlyphPage::createCopyForMixedFontData(*cachedPage);
+            cachedPage = GlyphPage::createCopyForMixedFonts(*cachedPage);
         glyphData = glyphDataForNormalVariant(c, description);
         cachedPage->setGlyphDataForCharacter(c, glyphData.glyph, glyphData.fontData);
+        cachedPage->setGlyphDataForCharacter(c, glyphData.glyph, glyphData.font);
+    }
     return glyphData;
 …
 void FontGlyphs::pruneSystemFallbacks()
+{
     if (m_systemFallbackFontDataSet.isEmpty())
+    if (m_systemFallbackFontSet.isEmpty())
         return;
     // Mutable glyph pages may reference fallback fonts.
 …
         return !keyAndValue.value->isImmutable();
     });
     m_systemFallbackFontDataSet.clear();
+}
+}
+    m_systemFallbackFontSet.clear();
+}
+}

trunk/Source/WebCore/platform/graphics/FontGlyphs.h

-              r178853
+              r178940
 #define FontGlyphs_h
+#include "Font.h"
 #include "FontRanges.h"
 #include "FontSelector.h"
 #include "GlyphPage.h"
-#include "SimpleFontData.h"
 #include "WidthCache.h"
 #include <wtf/Forward.h>
 …
     bool isForPlatformFont() const { return m_isForPlatformFont; }
     GlyphData glyphDataForCharacter(UChar32, const FontDescription&, FontDataVariant);
+    GlyphData glyphDataForCharacter(UChar32, const FontDescription&, FontVariant);
     bool isFixedPitch(const FontDescription&);
 …
     const WidthCache& widthCache() const { return m_widthCache; }
     const SimpleFontData& primarySimpleFontData(const FontDescription&);
+    const Font& primaryFont(const FontDescription&);
     WEBCORE_EXPORT const FontRanges& realizeFallbackRangesAt(const FontDescription&, unsigned fallbackIndex);
 …
     FontGlyphs(const FontPlatformData&);
     GlyphData glyphDataForSystemFallback(UChar32, const FontDescription&, FontDataVariant);
+    GlyphData glyphDataForSystemFallback(UChar32, const FontDescription&, FontVariant);
     GlyphData glyphDataForNormalVariant(UChar32, const FontDescription&);
     GlyphData glyphDataForVariant(UChar32, const FontDescription&, FontDataVariant, unsigned fallbackIndex);
+    GlyphData glyphDataForVariant(UChar32, const FontDescription&, FontVariant, unsigned fallbackIndex);
     Vector<FontRanges, 1> m_realizedFallbackRanges;
 …
     HashMap<int, RefPtr<GlyphPage>> m_cachedPages;
     HashSet<RefPtr<SimpleFontData>> m_systemFallbackFontDataSet;
+    HashSet<RefPtr<Font>> m_systemFallbackFontSet;
     const SimpleFontData* m_cachedPrimarySimpleFontData;
+    const Font* m_cachedPrimaryFont;
     RefPtr<FontSelector> m_fontSelector;
 …
 };
 inline const SimpleFontData& FontGlyphs::primarySimpleFontData(const FontDescription& description)
+inline const Font& FontGlyphs::primaryFont(const FontDescription& description)
+{
     ASSERT(isMainThread());
     if (!m_cachedPrimarySimpleFontData) {
+    if (!m_cachedPrimaryFont) {
         auto& primaryRanges = realizeFallbackRangesAt(description, 0);
         m_cachedPrimarySimpleFontData = primaryRanges.fontDataForCharacter(' ');
         if (!m_cachedPrimarySimpleFontData)
             m_cachedPrimarySimpleFontData = &primaryRanges.fontDataForFirstRange();
+        m_cachedPrimaryFont = primaryRanges.fontForCharacter(' ');
+        if (!m_cachedPrimaryFont)
+            m_cachedPrimaryFont = &primaryRanges.fontForFirstRange();
+    }
     return *m_cachedPrimarySimpleFontData;
+    return *m_cachedPrimaryFont;
+}

trunk/Source/WebCore/platform/graphics/FontMetrics.h

r176298	r178940
134	134
135	135	private:
136		friend class ~~SimpleFontData~~;
	136	friend class Font;
137	137
138	138	void reset()

trunk/Source/WebCore/platform/graphics/FontRanges.cpp

r178388	r178940
27	27	#include "FontRanges.h"
28	28
29		#include "~~SimpleFontData~~.h"
	29	#include "Font.h"
30	30	#include <wtf/Assertions.h>
31	31	#include <wtf/text/WTFString.h>
…	…
37	37	}
38	38
39		FontRanges::FontRanges(RefPtr<~~SimpleFontData>&& fontData~~)
	39	FontRanges::FontRanges(RefPtr<Font>&& font)
40	40	{
41		if (font~~Data~~)
42		m_ranges.append(Range { 0, 0x7FFFFFFF, font~~Data~~.releaseNonNull() });
	41	if (font)
	42	m_ranges.append(Range { 0, 0x7FFFFFFF, font.releaseNonNull() });
43	43	}
44	44
…	…
47	47	}
48	48
49		const ~~SimpleFontData* FontRanges::fontData~~ForCharacter(UChar32 c) const
	49	const Font* FontRanges::fontForCharacter(UChar32 c) const
50	50	{
51	51	for (auto& range : m_ranges) {
52	52	if (range.from() <= c && c <= range.to())
53		return &range.font~~Data~~();
	53	return &range.font();
54	54	}
55	55	return nullptr;
56	56	}
57	57
58		const ~~SimpleFontData& FontRanges::fontData~~ForFirstRange() const
	58	const Font& FontRanges::fontForFirstRange() const
59	59	{
60		return m_ranges[0].font~~Data~~();
	60	return m_ranges[0].font();
61	61	}
62	62
…	…
64	64	{
65	65	for (auto& range : m_ranges) {
66		if (range.font~~Data~~().isLoading())
	66	if (range.font().isLoading())
67	67	return true;
68	68	}

trunk/Source/WebCore/platform/graphics/FontRanges.h

-              r178388
+              r178940
 #define FontRanges_h
 #include "SimpleFontData.h"
+#include "Font.h"
 #include <wtf/TypeCasts.h>
 #include <wtf/Vector.h>
 …
 public:
     struct Range {
         Range(UChar32 from, UChar32 to, Ref<SimpleFontData>&& fontData)
+        Range(UChar32 from, UChar32 to, Ref<Font>&& font)
             : m_from(from)
             , m_to(to)
             , m_fontData(WTF::move(fontData))
+            , m_font(WTF::move(font))
+        {
+        }
 …
         UChar32 from() const { return m_from; }
         UChar32 to() const { return m_to; }
         const SimpleFontData& fontData() const { return *m_fontData; }
+        const Font& font() const { return *m_font; }
     private:
         UChar32 m_from;
         UChar32 m_to;
         RefPtr<SimpleFontData> m_fontData;
+        RefPtr<Font> m_font;
     };
     FontRanges();
     explicit FontRanges(RefPtr<SimpleFontData>&&);
+    explicit FontRanges(RefPtr<Font>&&);
     ~FontRanges();
 …
     const Range& rangeAt(unsigned i) const { return m_ranges[i]; }
     const SimpleFontData* fontDataForCharacter(UChar32) const;
     const SimpleFontData& fontDataForFirstRange() const;
+    const Font* fontForCharacter(UChar32) const;
+    const Font& fontForFirstRange() const;
     bool isLoading() const;

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

-              r178388
+              r178940
     virtual FontRanges fontRangesForFamily(const FontDescription&, const AtomicString&) = 0;
     virtual PassRefPtr<SimpleFontData> fallbackFontDataAt(const FontDescription&, size_t) = 0;
+    virtual PassRefPtr<Font> fallbackFontAt(const FontDescription&, size_t) = 0;
     virtual size_t fallbackFontDataCount() = 0;
+    virtual size_t fallbackFontCount() = 0;
     virtual bool resolvesFamilyFor(const FontDescription&) const = 0;

trunk/Source/WebCore/platform/graphics/GlyphBuffer.h

-              r174269
+              r178940
 namespace WebCore {
 class SimpleFontData;
+class Font;
 #if USE(CAIRO)
 …
 class GlyphBuffer {
 public:
     bool isEmpty() const { return m_fontData.isEmpty(); }
     int size() const { return m_fontData.size(); }
+    bool isEmpty() const { return m_font.isEmpty(); }
+    int size() const { return m_font.size(); }
     void clear()
+    {
         m_fontData.clear();
+        m_font.clear();
         m_glyphs.clear();
         m_advances.clear();
 …
     const GlyphBufferAdvance* advances(int from) const { return m_advances.data() + from; }
     const SimpleFontData* fontDataAt(int index) const { return m_fontData[index]; }
+    const Font* fontAt(int index) const { return m_font[index]; }
     void setInitialAdvance(GlyphBufferAdvance initialAdvance) { m_initialAdvance = initialAdvance; }
 …
     static const unsigned noOffset = UINT_MAX;
     void add(Glyph glyph, const SimpleFontData* font, float width, unsigned offsetInString = noOffset, const FloatSize* offset = 0)
+    {
         m_fontData.append(font);
+    void add(Glyph glyph, const Font* font, float width, unsigned offsetInString = noOffset, const FloatSize* offset = 0)
+    {
+        m_font.append(font);
 #if USE(CAIRO)
 …
 #if !USE(WINGDI)
     void add(Glyph glyph, const SimpleFontData* font, GlyphBufferAdvance advance, unsigned offsetInString = noOffset)
+    {
         m_fontData.append(font);
+    void add(Glyph glyph, const Font* font, GlyphBufferAdvance advance, unsigned offsetInString = noOffset)
+    {
+        m_font.append(font);
 #if USE(CAIRO)
         cairo_glyph_t cairoGlyph;
 …
     void swap(int index1, int index2)
+    {
         const SimpleFontData* f = m_fontData[index1];
         m_fontData[index1] = m_fontData[index2];
         m_fontData[index2] = f;
+        const Font* f = m_font[index1];
+        m_font[index1] = m_font[index2];
+        m_font[index2] = f;
         GlyphBufferGlyph g = m_glyphs[index1];
 …
+    }
     Vector<const SimpleFontData*, 2048> m_fontData;
+    Vector<const Font*, 2048> m_font;
     Vector<GlyphBufferGlyph, 2048> m_glyphs;
     Vector<GlyphBufferAdvance, 2048> m_advances;

trunk/Source/WebCore/platform/graphics/GlyphPage.h

-              r177876
+              r178940
 namespace WebCore {
 class SimpleFontData;
+class Font;
 // Holds the glyph index and the corresponding SimpleFontData information for a given
+// Holds the glyph index and the corresponding Font information for a given
 // character.
 struct GlyphData {
     GlyphData(Glyph g = 0, const SimpleFontData* f = 0)
+    GlyphData(Glyph g = 0, const Font* f = 0)
         : glyph(g)
         , fontData(f)
+        , font(f)
+    {
+    }
     Glyph glyph;
     const SimpleFontData* fontData;
+    const Font* font;
 };
 …
 class GlyphPage : public RefCounted<GlyphPage> {
 public:
     static PassRefPtr<GlyphPage> createForMixedFontData()
+    static PassRefPtr<GlyphPage> createForMixedFonts()
+    {
         void* slot = fastMalloc(sizeof(GlyphPage) + sizeof(SimpleFontData*) * GlyphPage::size);
+        void* slot = fastMalloc(sizeof(GlyphPage) + sizeof(Font*) * GlyphPage::size);
         return adoptRef(new (NotNull, slot) GlyphPage(nullptr));
+    }
     static PassRefPtr<GlyphPage> createCopyForMixedFontData(const GlyphPage& original)
+    static PassRefPtr<GlyphPage> createCopyForMixedFonts(const GlyphPage& original)
+    {
         RefPtr<GlyphPage> page = createForMixedFontData();
+        RefPtr<GlyphPage> page = createForMixedFonts();
         for (unsigned i = 0; i < GlyphPage::size; ++i)
             page->setGlyphDataForIndex(i, original.glyphDataForIndex(i));
 …
+    }
     static PassRefPtr<GlyphPage> createForSingleFontData(const SimpleFontData* fontData)
+    static PassRefPtr<GlyphPage> createForSingleFont(const Font* font)
+    {
         ASSERT(fontData);
         return adoptRef(new GlyphPage(fontData));
+        ASSERT(font);
+        return adoptRef(new GlyphPage(font));
+    }
 …
         if (hasPerGlyphFontData())
             return GlyphData(glyph, m_perGlyphFontData[index]);
         return GlyphData(glyph, glyph ? m_fontDataForAllGlyphs : 0);
+        return GlyphData(glyph, glyph ? m_fontForAllGlyphs : 0);
+    }
 …
+    }
     ALWAYS_INLINE const SimpleFontData* fontDataForCharacter(UChar32 c) const
+    ALWAYS_INLINE const Font* fontForCharacter(UChar32 c) const
+    {
         unsigned index = indexForCharacter(c);
         if (hasPerGlyphFontData())
             return m_perGlyphFontData[index];
         return m_glyphs[index] ? m_fontDataForAllGlyphs : 0;
+        return m_glyphs[index] ? m_fontForAllGlyphs : 0;
+    }
     void setGlyphDataForCharacter(UChar32 c, Glyph g, const SimpleFontData* f)
+    void setGlyphDataForCharacter(UChar32 c, Glyph g, const Font* f)
+    {
         setGlyphDataForIndex(indexForCharacter(c), g, f);
+    }
     void setGlyphDataForIndex(unsigned index, Glyph glyph, const SimpleFontData* fontData)
+    void setGlyphDataForIndex(unsigned index, Glyph glyph, const Font* font)
+    {
         ASSERT_WITH_SECURITY_IMPLICATION(index < size);
 …
         m_glyphs[index] = glyph;
         // GlyphPage getters will always return a null SimpleFontData* for glyph #0 if there's no per-glyph font array.
+        // GlyphPage getters will always return a null Font* for glyph #0 if there's no per-glyph font array.
         if (hasPerGlyphFontData()) {
             m_perGlyphFontData[index] = glyph ? fontData : 0;
+            m_perGlyphFontData[index] = glyph ? font : 0;
             return;
+        }
         // A single-font GlyphPage already assigned m_fontDataForAllGlyphs in the constructor.
         ASSERT(!glyph || fontData == m_fontDataForAllGlyphs);
+        // A single-font GlyphPage already assigned m_fontForAllGlyphs in the constructor.
+        ASSERT(!glyph || font == m_fontForAllGlyphs);
+    }
     void setGlyphDataForIndex(unsigned index, const GlyphData& glyphData)
+    {
         setGlyphDataForIndex(index, glyphData.glyph, glyphData.fontData);
+        setGlyphDataForIndex(index, glyphData.glyph, glyphData.font);
+    }
     // Implemented by the platform.
     bool fill(unsigned offset, unsigned length, UChar* characterBuffer, unsigned bufferLength, const SimpleFontData*);
+    bool fill(unsigned offset, unsigned length, UChar* characterBuffer, unsigned bufferLength, const Font*);
 #if PLATFORM(COCOA)
     static bool mayUseMixedFontDataWhenFilling(const UChar* characterBuffer, unsigned bufferLength, const SimpleFontData*);
+    static bool mayUseMixedFontsWhenFilling(const UChar* characterBuffer, unsigned bufferLength, const Font*);
 #else
     static bool mayUseMixedFontDataWhenFilling(const UChar*, unsigned, const SimpleFontData*) { return false; }
+    static bool mayUseMixedFontsWhenFilling(const UChar*, unsigned, const Font*) { return false; }
 #endif
 private:
     explicit GlyphPage(const SimpleFontData* fontDataForAllGlyphs)
         : m_fontDataForAllGlyphs(fontDataForAllGlyphs)
+    explicit GlyphPage(const Font* fontForAllGlyphs)
+        : m_fontForAllGlyphs(fontForAllGlyphs)
+    {
         memset(m_glyphs, 0, sizeof(m_glyphs));
         if (hasPerGlyphFontData())
             memset(m_perGlyphFontData, 0, sizeof(SimpleFontData*) * GlyphPage::size);
+            memset(m_perGlyphFontData, 0, sizeof(Font*) * GlyphPage::size);
         ++s_count;
+    }
     bool hasPerGlyphFontData() const { return !m_fontDataForAllGlyphs; }
+    bool hasPerGlyphFontData() const { return !m_fontForAllGlyphs; }
     const SimpleFontData* m_fontDataForAllGlyphs;
+    const Font* m_fontForAllGlyphs;
     Glyph m_glyphs[size];
     bool m_isImmutable { false };
     // NOTE: This array has (GlyphPage::size) elements if m_fontDataForAllGlyphs is null.
     const SimpleFontData* m_perGlyphFontData[0];
+    // NOTE: This array has (GlyphPage::size) elements if m_fontForAllGlyphs is null.
+    const Font* m_perGlyphFontData[0];
     static unsigned s_count;

trunk/Source/WebCore/platform/graphics/GraphicsContext.cpp

-              r178510
+              r178940
 #endif // !PLATFORM(IOS)
 void GraphicsContext::drawGlyphs(const FontCascade& font, const SimpleFontData& fontData, const GlyphBuffer& buffer, int from, int numGlyphs, const FloatPoint& point)
+{
     if (paintingDisabled())
         return;
     font.drawGlyphs(this, &fontData, buffer, from, numGlyphs, point);
+void GraphicsContext::drawGlyphs(const FontCascade& fontCascade, const Font& font, const GlyphBuffer& buffer, int from, int numGlyphs, const FloatPoint& point)
+{
+    if (paintingDisabled())
+        return;
+    fontCascade.drawGlyphs(this, &font, buffer, from, numGlyphs, point);
+}

trunk/Source/WebCore/platform/graphics/GraphicsContext.h

-              r178510
+              r178940
 #if USE(WINGDI)
     class SharedBitmap;
     class SimpleFontData;
+    class Font;
     class GlyphBuffer;
 #endif
 …
         float drawText(const FontCascade&, const TextRun&, const FloatPoint&, int from = 0, int to = -1);
 #endif
         void drawGlyphs(const FontCascade&, const SimpleFontData&, const GlyphBuffer&, int from, int numGlyphs, const FloatPoint&);
+        void drawGlyphs(const FontCascade&, const Font&, const GlyphBuffer&, int from, int numGlyphs, const FloatPoint&);
         void drawEmphasisMarks(const FontCascade&, const TextRun& , const AtomicString& mark, const FloatPoint&, int from = 0, int to = -1);
 #if !PLATFORM(IOS)
 …
         void resetAffineTransform();
         void fillRect(const FloatRect&, const Gradient*);
         void drawText(const SimpleFontData* fontData, const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& point);
+        void drawText(const Font*, const GlyphBuffer&, int from, int numGlyphs, const FloatPoint&);
         void drawFrameControl(const IntRect& rect, unsigned type, unsigned state);
         void drawFocusRect(const IntRect& rect);

trunk/Source/WebCore/platform/graphics/TextRun.h

-              r178510
+              r178940
 class GlyphBuffer;
 class GlyphToPathTranslator;
 class SimpleFontData;
+class Font;
 struct GlyphData;
 …
 #if ENABLE(SVG_FONTS)
         virtual GlyphData glyphDataForCharacter(const FontCascade&, WidthIterator&, UChar32 character, bool mirror, int currentCharacter, unsigned& advanceLength, String& normalizedSpacesStringCache) = 0;
         virtual void drawSVGGlyphs(GraphicsContext*, const SimpleFontData*, const GlyphBuffer&, int from, int to, const FloatPoint&) const = 0;
+        virtual void drawSVGGlyphs(GraphicsContext*, const Font*, const GlyphBuffer&, int from, int to, const FloatPoint&) const = 0;
         virtual float floatWidthUsingSVGFont(const FontCascade&, const TextRun&, int& charsConsumed, String& glyphName) const = 0;
         virtual bool applySVGKerning(const SimpleFontData*, WidthIterator&, GlyphBuffer*, int from) const = 0;
         virtual std::unique_ptr<GlyphToPathTranslator> createGlyphToPathTranslator(const SimpleFontData&, const TextRun*, const GlyphBuffer&, int from, int numGlyphs, const FloatPoint&) const = 0;
+        virtual bool applySVGKerning(const Font*, WidthIterator&, GlyphBuffer*, int from) const = 0;
+        virtual std::unique_ptr<GlyphToPathTranslator> createGlyphToPathTranslator(const Font&, const TextRun*, const GlyphBuffer&, int from, int numGlyphs, const FloatPoint&) const = 0;
 #endif
     };

trunk/Source/WebCore/platform/graphics/WidthIterator.cpp

-              r178510
+              r178940
 #include "WidthIterator.h"
+#include "Font.h"
 #include "FontCascade.h"
 #include "GlyphBuffer.h"
 #include "Latin1TextIterator.h"
-#include "SimpleFontData.h"
 #include "SurrogatePairAwareTextIterator.h"
 #include <wtf/MathExtras.h>
 …
 namespace WebCore {
 WidthIterator::WidthIterator(const FontCascade* font, const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, bool accountForGlyphBounds, bool forTextEmphasis)
+WidthIterator::WidthIterator(const FontCascade* font, const TextRun& run, HashSet<const Font*>* fallbackFonts, bool accountForGlyphBounds, bool forTextEmphasis)
     : m_font(font)
     , m_run(run)
 …
 typedef Vector<std::pair<int, OriginalAdvancesForCharacterTreatedAsSpace>, 64> CharactersTreatedAsSpace;
 static inline float applyFontTransforms(GlyphBuffer* glyphBuffer, bool ltr, int& lastGlyphCount, const SimpleFontData* fontData, WidthIterator& iterator, TypesettingFeatures typesettingFeatures, CharactersTreatedAsSpace& charactersTreatedAsSpace)
+static inline float applyFontTransforms(GlyphBuffer* glyphBuffer, bool ltr, int& lastGlyphCount, const Font* font, WidthIterator& iterator, TypesettingFeatures typesettingFeatures, CharactersTreatedAsSpace& charactersTreatedAsSpace)
+{
     ASSERT(typesettingFeatures & (Kerning | Ligatures));
 …
 #else
     // We need to handle transforms on SVG fonts internally, since they are rendered internally.
     if (fontData->isSVGFont()) {
+    if (font->isSVGFont()) {
         // SVG font ligatures are handled during glyph selection, only kerning remaining.
         if (iterator.run().renderingContext() && (typesettingFeatures & Kerning)) {
             // FIXME: We could pass the necessary context down to this level so we can lazily create rendering contexts at this point.
             // However, a larger refactoring of SVG fonts might necessary to sidestep this problem completely.
             iterator.run().renderingContext()->applySVGKerning(fontData, iterator, glyphBuffer, lastGlyphCount);
+            iterator.run().renderingContext()->applySVGKerning(font, iterator, glyphBuffer, lastGlyphCount);
+        }
     } else
 #endif
         fontData->applyTransforms(glyphBuffer->glyphs(lastGlyphCount), advances + lastGlyphCount, glyphBufferSize - lastGlyphCount, typesettingFeatures);
+        font->applyTransforms(glyphBuffer->glyphs(lastGlyphCount), advances + lastGlyphCount, glyphBufferSize - lastGlyphCount, typesettingFeatures);
     if (!ltr)
 …
     FloatRect bounds;
     const SimpleFontData& primaryFontData = m_font->primaryFontData();
     const SimpleFontData* lastFontData = &primaryFontData;
+    const Font& primaryFont = m_font->primaryFont();
+    const Font* lastFontData = &primaryFont;
     int lastGlyphCount = glyphBuffer ? glyphBuffer->size() : 0;
 …
             continue;
+        }
         const SimpleFontData* fontData = glyphData.fontData;
         ASSERT(fontData);
+        const Font* font = glyphData.font;
+        ASSERT(font);
         // Now that we have a glyph and font data, get its width.
         float width;
         if (character == '\t' && m_run.allowTabs())
             width = m_font->tabWidth(*fontData, m_run.tabSize(), m_run.xPos() + m_runWidthSoFar + widthSinceLastRounding);
+            width = m_font->tabWidth(*font, m_run.tabSize(), m_run.xPos() + m_runWidthSoFar + widthSinceLastRounding);
         else {
             width = fontData->widthForGlyph(glyph);
+            width = font->widthForGlyph(glyph);
             // SVG uses horizontalGlyphStretch(), when textLength is used to stretch/squeeze text.
 …
             // Second, in fixed-pitch fonts we ensure that all characters that
             // match the width of the space character have the same width as the space character.
             if (m_run.applyWordRounding() && width == fontData->spaceWidth() && (fontData->pitch() == FixedPitch || glyph == fontData->spaceGlyph()))
                 width = fontData->adjustedSpaceWidth();
+        }
         if (fontData != lastFontData && width) {
+            if (m_run.applyWordRounding() && width == font->spaceWidth() && (font->pitch() == FixedPitch || glyph == font->spaceGlyph()))
+                width = font->adjustedSpaceWidth();
+        }
+        if (font != lastFontData && width) {
             if (shouldApplyFontTransforms()) {
                 m_runWidthSoFar += applyFontTransforms(glyphBuffer, m_run.ltr(), lastGlyphCount, lastFontData, *this, m_typesettingFeatures, charactersTreatedAsSpace);
 …
+            }
             lastFontData = fontData;
             if (m_fallbackFonts && fontData != &primaryFontData) {
+            lastFontData = font;
+            if (m_fallbackFonts && font != &primaryFont) {
                 // FIXME: This does a little extra work that could be avoided if
                 // glyphDataForCharacter() returned whether it chose to use a small caps font.
                 if (!m_font->isSmallCaps() || character == u_toupper(character))
                     m_fallbackFonts->add(fontData);
+                    m_fallbackFonts->add(font);
                 else {
                     const GlyphData& uppercaseGlyphData = m_font->glyphDataForCharacter(u_toupper(character), rtl);
                     if (uppercaseGlyphData.fontData != &primaryFontData)
                         m_fallbackFonts->add(uppercaseGlyphData.fontData);
+                    if (uppercaseGlyphData.font != &primaryFont)
+                        m_fallbackFonts->add(uppercaseGlyphData.font);
+                }
+            }
 …
                             if (glyphBuffer->isEmpty()) {
                                 if (m_forTextEmphasis)
                                     glyphBuffer->add(fontData->zeroWidthSpaceGlyph(), fontData, m_expansionPerOpportunity, currentCharacter);
+                                    glyphBuffer->add(font->zeroWidthSpaceGlyph(), font, m_expansionPerOpportunity, currentCharacter);
                                 else
                                     glyphBuffer->add(fontData->spaceGlyph(), fontData, expansionAtThisOpportunity, currentCharacter);
+                                    glyphBuffer->add(font->spaceGlyph(), font, expansionAtThisOpportunity, currentCharacter);
                             } else
                                 glyphBuffer->expandLastAdvance(expansionAtThisOpportunity);
 …
         if (m_accountForGlyphBounds) {
             bounds = fontData->boundsForGlyph(glyph);
+            bounds = font->boundsForGlyph(glyph);
             if (!currentCharacter)
                 m_firstGlyphOverflow = std::max<float>(0, -bounds.x());
 …
         if (glyphBuffer)
             glyphBuffer->add(glyph, fontData, (rtl ? oldWidth + lastRoundingWidth : width), currentCharacter);
+            glyphBuffer->add(glyph, font, (rtl ? oldWidth + lastRoundingWidth : width), currentCharacter);
         lastRoundingWidth = width - oldWidth;

trunk/Source/WebCore/platform/graphics/WidthIterator.h

-              r178510
+              r178940
 class FontCascade;
 class GlyphBuffer;
 class SimpleFontData;
+class Font;
 class TextRun;
 struct GlyphData;
 …
     WTF_MAKE_FAST_ALLOCATED;
 public:
     WidthIterator(const FontCascade*, const TextRun&, HashSet<const SimpleFontData*>* fallbackFonts = 0, bool accountForGlyphBounds = false, bool forTextEmphasis = false);
+    WidthIterator(const FontCascade*, const TextRun&, HashSet<const Font*>* fallbackFonts = 0, bool accountForGlyphBounds = false, bool forTextEmphasis = false);
     unsigned advance(int to, GlyphBuffer*);
 …
     TypesettingFeatures m_typesettingFeatures;
     HashSet<const SimpleFontData*>* m_fallbackFonts;
+    HashSet<const Font*>* m_fallbackFonts;
     bool m_accountForGlyphBounds;
     float m_maxGlyphBoundingBoxY;

trunk/Source/WebCore/platform/graphics/cairo/FontCairo.cpp

-              r178510
+              r178940
 #include "AffineTransform.h"
 #include "CairoUtilities.h"
+#include "Font.h"
 #include "GlyphBuffer.h"
 #include "Gradient.h"
 …
 #include "PlatformPathCairo.h"
 #include "ShadowBlur.h"
-#include "SimpleFontData.h"
 namespace WebCore {
 static void drawGlyphsToContext(cairo_t* context, const SimpleFontData* font, GlyphBufferGlyph* glyphs, int numGlyphs)
+static void drawGlyphsToContext(cairo_t* context, const Font* font, GlyphBufferGlyph* glyphs, int numGlyphs)
+{
     cairo_matrix_t originalTransform;
 …
+}
 static void drawGlyphsShadow(GraphicsContext* graphicsContext, const FloatPoint& point, const SimpleFontData* font, GlyphBufferGlyph* glyphs, int numGlyphs)
+static void drawGlyphsShadow(GraphicsContext* graphicsContext, const FloatPoint& point, const Font* font, GlyphBufferGlyph* glyphs, int numGlyphs)
+{
     ShadowBlur& shadow = graphicsContext->platformContext()->shadowBlur();
 …
+}
 void FontCascade::drawGlyphs(GraphicsContext* context, const SimpleFontData* font, const GlyphBuffer& glyphBuffer,
+void FontCascade::drawGlyphs(GraphicsContext* context, const Font* font, const GlyphBuffer& glyphBuffer,
     int from, int numGlyphs, const FloatPoint& point) const
+{
 …
         , m_textRun(textRun)
         , m_glyphBuffer(glyphBuffer)
         , m_fontData(glyphBuffer.fontDataAt(m_index))
+        , m_fontData(glyphBuffer.fontAt(m_index))
         , m_translation(AffineTransform().translate(textOrigin.x(), textOrigin.y()))
+    {
 …
     const TextRun& m_textRun;
     const GlyphBuffer& m_glyphBuffer;
     const SimpleFontData* m_fontData;
+    const Font* m_fontData;
     AffineTransform m_translation;
 };
 …
         if (m_index >= m_glyphBuffer.size())
             break;
         m_fontData = m_glyphBuffer.fontDataAt(m_index);
+        m_fontData = m_glyphBuffer.fontAt(m_index);
     } while (m_fontData->isSVGFont() && m_index < m_glyphBuffer.size());
+}
 …
     // FIXME: Handle SVG + non-SVG interleaved runs. https://bugs.webkit.org/show_bug.cgi?id=133778
     const SimpleFontData* fontData = glyphBuffer.fontDataAt(0);
+    const Font* fontData = glyphBuffer.fontAt(0);
     std::unique_ptr<GlyphToPathTranslator> translator;
     bool isSVG = false;
 …
         float centerOfLine = lineExtents.y() + (lineExtents.height() / 2);
         GlyphIterationState info = GlyphIterationState(FloatPoint(), FloatPoint(), centerOfLine, lineExtents.x() + lineExtents.width(), lineExtents.x());
         const SimpleFontData* localFontData = glyphBuffer.fontDataAt(index);
+        const Font* localFontData = glyphBuffer.fontAt(index);
         if (!localFontData || (!isSVG && localFontData->isSVGFont()) || (isSVG && localFontData != fontData)) {
             // The advances will get all messed up if we do anything other than bail here.

trunk/Source/WebCore/platform/graphics/cairo/FontCairoHarfbuzzNG.cpp

-              r178510
+              r178940
 #include "FontCascade.h"
+#include "Font.h"
 #include "GraphicsContext.h"
 #include "HarfBuzzShaper.h"
 …
 #include "NotImplemented.h"
 #include "PlatformContextCairo.h"
-#include "SimpleFontData.h"
 #include <cairo.h>
 …
+}
 float FontCascade::floatWidthForComplexText(const TextRun& run, HashSet<const SimpleFontData*>*, GlyphOverflow*) const
+float FontCascade::floatWidthForComplexText(const TextRun& run, HashSet<const Font*>*, GlyphOverflow*) const
+{
     HarfBuzzShaper shaper(this, run);

trunk/Source/WebCore/platform/graphics/cairo/GraphicsContextCairo.cpp

-              r174931
+              r178940
 #include "FloatRect.h"
 #include "FloatRoundedRect.h"
+#include "Font.h"
 #include "GraphicsContextPlatformPrivateCairo.h"
 #include "IntRect.h"
 …
 #include "RefPtrCairo.h"
 #include "ShadowBlur.h"
-#include "SimpleFontData.h"
 #include "TransformationMatrix.h"
 #include <cairo.h>

trunk/Source/WebCore/platform/graphics/cocoa/FontCascadeCocoa.mm

-              r178578
+              r178940
 #import "CoreTextSPI.h"
 #import "DashArray.h"
+#import "Font.h"
 #import "GlyphBuffer.h"
 #import "GraphicsContext.h"
 #import "LayoutRect.h"
 #import "Logging.h"
-#import "SimpleFontData.h"
 #import "WebCoreSystemInterface.h"
 #if USE(APPKIT)
 …
+}
 static void showLetterpressedGlyphsWithAdvances(const FloatPoint& point, const SimpleFontData* font, CGContextRef context, const CGGlyph* glyphs, const CGSize* advances, size_t count)
+static void showLetterpressedGlyphsWithAdvances(const FloatPoint& point, const Font* font, CGContextRef context, const CGGlyph* glyphs, const CGSize* advances, size_t count)
+{
 #if ENABLE(LETTERPRESS)
 …
+}
 static void showGlyphsWithAdvances(const FloatPoint& point, const SimpleFontData* font, CGContextRef context, const CGGlyph* glyphs, const CGSize* advances, size_t count)
+static void showGlyphsWithAdvances(const FloatPoint& point, const Font* font, CGContextRef context, const CGGlyph* glyphs, const CGSize* advances, size_t count)
+{
     if (!count)
 …
 #endif
 void FontCascade::drawGlyphs(GraphicsContext* context, const SimpleFontData* font, const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& anchorPoint) const
+void FontCascade::drawGlyphs(GraphicsContext* context, const Font* font, const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& anchorPoint) const
+{
     const FontPlatformData& platformData = font->platformData();
 …
         , m_textRun(textRun)
         , m_glyphBuffer(glyphBuffer)
         , m_fontData(glyphBuffer.fontDataAt(m_index))
+        , m_fontData(glyphBuffer.fontAt(m_index))
         , m_translation(CGAffineTransformScale(CGAffineTransformMakeTranslation(textOrigin.x(), textOrigin.y()), 1, -1))
+    {
 …
     const TextRun& m_textRun;
     const GlyphBuffer& m_glyphBuffer;
     const SimpleFontData* m_fontData;
+    const Font* m_fontData;
     CGAffineTransform m_translation;
 };
 …
         if (m_index >= m_glyphBuffer.size())
             break;
         m_fontData = m_glyphBuffer.fontDataAt(m_index);
+        m_fontData = m_glyphBuffer.fontAt(m_index);
     } while (m_fontData->isSVGFont() && m_index < m_glyphBuffer.size());
+}
 …
     // FIXME: Handle SVG + non-SVG interleaved runs. https://bugs.webkit.org/show_bug.cgi?id=133778
     const SimpleFontData* fontData = glyphBuffer.fontDataAt(0);
+    const Font* fontData = glyphBuffer.fontAt(0);
     std::unique_ptr<GlyphToPathTranslator> translator;
     bool isSVG = false;
 …
     for (int index = 0; translator->containsMorePaths(); ++index, translator->advance()) {
         GlyphIterationState info = GlyphIterationState(CGPointMake(0, 0), CGPointMake(0, 0), lineExtents.y(), lineExtents.y() + lineExtents.height(), lineExtents.x() + lineExtents.width(), lineExtents.x());
         const SimpleFontData* localFontData = glyphBuffer.fontDataAt(index);
         if (!localFontData || (!isSVG && localFontData->isSVGFont()) || (isSVG && localFontData != fontData)) {
+        const Font* localFont = glyphBuffer.fontAt(index);
+        if (!localFont || (!isSVG && localFont->isSVGFont()) || (isSVG && localFont != fontData)) {
             // The advances will get all messed up if we do anything other than bail here.
             result.clear();
 …
 #endif
 bool FontCascade::primaryFontDataIsSystemFont() const
+bool FontCascade::primaryFontIsSystemFont() const
+{
 #if PLATFORM(IOS) || __MAC_OS_X_VERSION_MIN_REQUIRED > 1090
     const auto& fontData = primaryFontData();
+    const auto& fontData = primaryFont();
     return !fontData.isSVGFont() && CTFontDescriptorIsSystemUIFont(adoptCF(CTFontCopyFontDescriptor(fontData.platformData().ctFont())).get());
 #else
 …
+}
 float FontCascade::floatWidthForComplexText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
+float FontCascade::floatWidthForComplexText(const TextRun& run, HashSet<const Font*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
+{
     ComplexTextController controller(this, run, true, fallbackFonts);
 …
+}
 const SimpleFontData* FontCascade::fontDataForCombiningCharacterSequence(const UChar* characters, size_t length, FontDataVariant variant) const
+const Font* FontCascade::fontForCombiningCharacterSequence(const UChar* characters, size_t length, FontVariant variant) const
+{
     UChar32 baseCharacter;
 …
     if (length == baseCharacterLength)
         return baseCharacterGlyphData.fontData;
     bool triedBaseCharacterFontData = false;
+        return baseCharacterGlyphData.font;
+    bool triedBaseCharacterFont = false;
     for (unsigned i = 0; !fallbackRangesAt(i).isNull(); ++i) {
         const SimpleFontData* simpleFontData = fallbackRangesAt(i).fontDataForCharacter(baseCharacter);
         if (!simpleFontData)
+        const Font* font = fallbackRangesAt(i).fontForCharacter(baseCharacter);
+        if (!font)
             continue;
 #if PLATFORM(IOS)
         if (baseCharacter >= 0x0600 && baseCharacter <= 0x06ff && simpleFontData->shouldNotBeUsedForArabic())
+        if (baseCharacter >= 0x0600 && baseCharacter <= 0x06ff && font->shouldNotBeUsedForArabic())
             continue;
 #endif
         if (variant == NormalVariant) {
             if (simpleFontData->platformData().orientation() == Vertical) {
                 if (isCJKIdeographOrSymbol(baseCharacter) && !simpleFontData->hasVerticalGlyphs()) {
+            if (font->platformData().orientation() == Vertical) {
+                if (isCJKIdeographOrSymbol(baseCharacter) && !font->hasVerticalGlyphs()) {
                     variant = BrokenIdeographVariant;
                     simpleFontData = simpleFontData->brokenIdeographFontData().get();
+                    font = font->brokenIdeographFont().get();
                 } else if (m_fontDescription.nonCJKGlyphOrientation() == NonCJKGlyphOrientationVerticalRight) {
                     SimpleFontData* verticalRightFontData = simpleFontData->verticalRightOrientationFontData().get();
                     Glyph verticalRightGlyph = verticalRightFontData->glyphForCharacter(baseCharacter);
+                    Font* verticalRightFont = font->verticalRightOrientationFont().get();
+                    Glyph verticalRightGlyph = verticalRightFont->glyphForCharacter(baseCharacter);
                     if (verticalRightGlyph == baseCharacterGlyphData.glyph)
                         simpleFontData = verticalRightFontData;
+                        font = verticalRightFont;
                 } else {
                     SimpleFontData* uprightFontData = simpleFontData->uprightOrientationFontData().get();
                     Glyph uprightGlyph = uprightFontData->glyphForCharacter(baseCharacter);
+                    Font* uprightFont = font->uprightOrientationFont().get();
+                    Glyph uprightGlyph = uprightFont->glyphForCharacter(baseCharacter);
                     if (uprightGlyph != baseCharacterGlyphData.glyph)
                         simpleFontData = uprightFontData;
+                        font = uprightFont;
+                }
+            }
         } else {
             if (const SimpleFontData* variantFontData = simpleFontData->variantFontData(m_fontDescription, variant).get())
                 simpleFontData = variantFontData;
+        }
         if (simpleFontData == baseCharacterGlyphData.fontData)
             triedBaseCharacterFontData = true;
         if (simpleFontData->canRenderCombiningCharacterSequence(characters, length))
             return simpleFontData;
+    }
     if (!triedBaseCharacterFontData && baseCharacterGlyphData.fontData && baseCharacterGlyphData.fontData->canRenderCombiningCharacterSequence(characters, length))
         return baseCharacterGlyphData.fontData;
     return SimpleFontData::systemFallback();
+}
+}
+            if (const Font* variantFont = font->variantFont(m_fontDescription, variant).get())
+                font = variantFont;
+        }
+        if (font == baseCharacterGlyphData.font)
+            triedBaseCharacterFont = true;
+        if (font->canRenderCombiningCharacterSequence(characters, length))
+            return font;
+    }
+    if (!triedBaseCharacterFont && baseCharacterGlyphData.font && baseCharacterGlyphData.font->canRenderCombiningCharacterSequence(characters, length))
+        return baseCharacterGlyphData.font;
+    return Font::systemFallback();
+}
+}

trunk/Source/WebCore/platform/graphics/freetype/FontCacheFreeType.cpp

-              r178510
+              r178940
 #include "FontCache.h"
+#include "Font.h"
 #include "OwnPtrCairo.h"
 #include "RefPtrCairo.h"
-#include "SimpleFontData.h"
 #include "UTF16UChar32Iterator.h"
 #include <cairo-ft.h>
 …
+}
 RefPtr<SimpleFontData> FontCache::systemFallbackForCharacters(const FontDescription& description, const SimpleFontData* originalFontData, bool, const UChar* characters, int length)
+RefPtr<Font> FontCache::systemFallbackForCharacters(const FontDescription& description, const Font* originalFontData, bool, const UChar* characters, int length)
+{
     RefPtr<FcPattern> pattern = adoptRef(createFontConfigPatternForCharacters(characters, length));
 …
+}
 Ref<SimpleFontData> FontCache::lastResortFallbackFont(const FontDescription& fontDescription)
+Ref<Font> FontCache::lastResortFallbackFont(const FontDescription& fontDescription)
+{
     // We want to return a fallback font here, otherwise the logic preventing FontConfig

trunk/Source/WebCore/platform/graphics/freetype/GlyphPageTreeNodeFreeType.cpp

-              r177876
+              r178940
 #include "GlyphPage.h"
 #include "SimpleFontData.h"
+#include "Font.h"
 #include "UTF16UChar32Iterator.h"
 #include <cairo-ft.h>
 …
 namespace WebCore {
 bool GlyphPage::fill(unsigned offset, unsigned length, UChar* buffer, unsigned bufferLength, const SimpleFontData* fontData)
+bool GlyphPage::fill(unsigned offset, unsigned length, UChar* buffer, unsigned bufferLength, const Font* fontData)
+{
     cairo_scaled_font_t* scaledFont = fontData->platformData().scaledFont();

trunk/Source/WebCore/platform/graphics/freetype/SimpleFontDataFreeType.cpp

r178510	r178940
32	32
33	33	#include "config.h"
34		#include "~~SimpleFontData~~.h"
	34	#include "Font.h"
35	35
36	36	#include "FloatConversion.h"
…	…
52	52	namespace WebCore {
53	53
54		void ~~SimpleFontData~~::platformInit()
	54	void Font::platformInit()
55	55	{
56	56	if (!m_platformData.m_size)
…	…
94	94	}
95	95
96		void ~~SimpleFontData~~::platformCharWidthInit()
	96	void Font::platformCharWidthInit()
97	97	{
98	98	m_avgCharWidth = 0.f;
…	…
101	101	}
102	102
103		PassRefPtr<~~SimpleFontData> SimpleFontData::platformCreateScaledFontData~~(const FontDescription& fontDescription, float scaleFactor) const
	103	PassRefPtr<Font> Font::platformCreateScaledFont(const FontDescription& fontDescription, float scaleFactor) const
104	104	{
105	105	ASSERT(m_platformData.scaledFont());
106		return ~~SimpleFontData~~::create(FontPlatformData(cairo_scaled_font_get_font_face(m_platformData.scaledFont()),
	106	return Font::create(FontPlatformData(cairo_scaled_font_get_font_face(m_platformData.scaledFont()),
107	107	scaleFactor * fontDescription.computedSize(),
108	108	m_platformData.syntheticBold(),
…	…
112	112	}
113	113
114		void ~~SimpleFontData~~::determinePitch()
	114	void Font::determinePitch()
115	115	{
116	116	m_treatAsFixedPitch = m_platformData.isFixedPitch();
117	117	}
118	118
119		FloatRect ~~SimpleFontData~~::platformBoundsForGlyph(Glyph glyph) const
	119	FloatRect Font::platformBoundsForGlyph(Glyph glyph) const
120	120	{
121	121	if (!m_platformData.size())
…	…
132	132	}
133	133
134		float ~~SimpleFontData~~::platformWidthForGlyph(Glyph glyph) const
	134	float Font::platformWidthForGlyph(Glyph glyph) const
135	135	{
136	136	if (!m_platformData.size())
…	…
148	148
149	149	#if USE(HARFBUZZ)
150		bool ~~SimpleFontData~~::canRenderCombiningCharacterSequence(const UChar* characters, size_t length) const
	150	bool Font::canRenderCombiningCharacterSequence(const UChar* characters, size_t length) const
151	151	{
152	152	if (!m_combiningCharacterSequenceSupport)

trunk/Source/WebCore/platform/graphics/harfbuzz/HarfBuzzFaceCairo.cpp

-              r176945
+              r178940
 #include "HarfBuzzFace.h"
+#include "Font.h"
 #include "FontPlatformData.h"
 #include "GlyphBuffer.h"
 #include "HarfBuzzShaper.h"
-#include "SimpleFontData.h"
 #include "TextEncoding.h"
 #include <cairo-ft.h>

trunk/Source/WebCore/platform/graphics/harfbuzz/HarfBuzzFaceCoreText.cpp

-              r178166
+              r178940
 #include "HarfBuzzFace.h"
+#include "Font.h"
 #include "FontPlatformData.h"
 #include "HarfBuzzShaper.h"
-#include "SimpleFontData.h"
 #include <ApplicationServices/ApplicationServices.h>
 #include <hb.h>

trunk/Source/WebCore/platform/graphics/harfbuzz/HarfBuzzShaper.cpp

-              r178510
+              r178940
+}
 HarfBuzzShaper::HarfBuzzRun::HarfBuzzRun(const SimpleFontData* fontData, unsigned startIndex, unsigned numCharacters, TextDirection direction, hb_script_t script)
+HarfBuzzShaper::HarfBuzzRun::HarfBuzzRun(const Font* fontData, unsigned startIndex, unsigned numCharacters, TextDirection direction, hb_script_t script)
     : m_fontData(fontData)
     , m_startIndex(startIndex)
 …
         return false;
     const SimpleFontData* nextFontData = m_font->glyphDataForCharacter(character, false).fontData;
+    const Font* nextFontData = m_font->glyphDataForCharacter(character, false).font;
     UErrorCode errorCode = U_ZERO_ERROR;
     UScriptCode nextScript = uscript_getScript(character, &errorCode);
 …
     do {
         const UChar* currentCharacterPosition = iterator.characters();
         const SimpleFontData* currentFontData = nextFontData;
+        const Font* currentFontData = nextFontData;
         if (!currentFontData)
             currentFontData = &m_font->primaryFontData();
+            currentFontData = &m_font->primaryFont();
         UScriptCode currentScript = nextScript;
 …
                     continue;
+                }
                 nextFontData = m_font->glyphDataForCharacter(character, false).fontData;
+                nextFontData = m_font->glyphDataForCharacter(character, false).font;
             } else
                 nextFontData = m_font->glyphDataForCharacter(character, false).fontData;
+                nextFontData = m_font->glyphDataForCharacter(character, false).font;
             nextScript = uscript_getScript(character, &errorCode);
 …
         unsigned runIndex = m_run.rtl() ? m_harfBuzzRuns.size() - i - 1 : i;
         HarfBuzzRun* currentRun = m_harfBuzzRuns[runIndex].get();
         const SimpleFontData* currentFontData = currentRun->fontData();
+        const Font* currentFontData = currentRun->fontData();
         if (currentFontData->isSVGFont())
             return false;
 …
         if (m_font->isSmallCaps() && u_islower(m_normalizedBuffer[currentRun->startIndex()])) {
             String upperText = String(m_normalizedBuffer.get() + currentRun->startIndex(), currentRun->numCharacters()).upper();
             currentFontData = m_font->glyphDataForCharacter(upperText[0], false, SmallCapsVariant).fontData;
+            currentFontData = m_font->glyphDataForCharacter(upperText[0], false, SmallCapsVariant).font;
             const UChar* characters = StringView(upperText).upconvertedCharacters();
             hb_buffer_add_utf16(harfBuzzBuffer.get(), reinterpret_cast<const uint16_t*>(characters), currentRun->numCharacters(), 0, currentRun->numCharacters());
 …
 void HarfBuzzShaper::setGlyphPositionsForHarfBuzzRun(HarfBuzzRun* currentRun, hb_buffer_t* harfBuzzBuffer)
+{
     const SimpleFontData* currentFontData = currentRun->fontData();
+    const Font* currentFontData = currentRun->fontData();
     hb_glyph_info_t* glyphInfos = hb_buffer_get_glyph_infos(harfBuzzBuffer, 0);
     hb_glyph_position_t* glyphPositions = hb_buffer_get_glyph_positions(harfBuzzBuffer, 0);

trunk/Source/WebCore/platform/graphics/harfbuzz/HarfBuzzShaper.h

-              r178510
+              r178940
 namespace WebCore {
+class Font;
 class FontCascade;
-class SimpleFontData;
 class HarfBuzzShaper {
 …
     class HarfBuzzRun {
     public:
         HarfBuzzRun(const SimpleFontData*, unsigned startIndex, unsigned numCharacters, TextDirection, hb_script_t);
+        HarfBuzzRun(const Font*, unsigned startIndex, unsigned numCharacters, TextDirection, hb_script_t);
         void applyShapeResult(hb_buffer_t*);
 …
         float xPositionForOffset(unsigned offset);
         const SimpleFontData* fontData() { return m_fontData; }
+        const Font* fontData() { return m_fontData; }
         unsigned startIndex() const { return m_startIndex; }
         unsigned numCharacters() const { return m_numCharacters; }
 …
     private:
         const SimpleFontData* m_fontData;
+        const Font* m_fontData;
         unsigned m_startIndex;
         size_t m_numCharacters;

trunk/Source/WebCore/platform/graphics/ios/FontCacheIOS.mm

-              r178510
+              r178940
+}
 PassRefPtr<SimpleFontData> FontCache::getSystemFontFallbackForCharacters(const FontDescription& description, const SimpleFontData* originalFontData, const UChar* characters, int length)
+PassRefPtr<Font> FontCache::getSystemFontFallbackForCharacters(const FontDescription& description, const Font* originalFontData, const UChar* characters, int length)
+{
     const FontPlatformData& platformData = originalFontData->platformData();
 …
+}
 RefPtr<SimpleFontData> FontCache::systemFallbackForCharacters(const FontDescription& description, const SimpleFontData* originalFontData, bool, const UChar* characters, int length)
+RefPtr<Font> FontCache::systemFallbackForCharacters(const FontDescription& description, const Font* originalFontData, bool, const UChar* characters, int length)
+{
     // Unlike OS X, our fallback font on iPhone is Arial Unicode, which doesn't have some apple-specific glyphs like F8FF.
 …
         languageSpecificFont = languageSpecificFallbackFont(c);
     RefPtr<SimpleFontData> simpleFontData;
+    RefPtr<Font> font;
     switch (languageSpecificFont) {
 …
+        }
         simpleFontData = fontForFamily(description, isFontWeightBold(description.weight()) ? *cjkBold[preferredCJKFont] : *cjkPlain[preferredCJKFont], false);
+        font = fontForFamily(description, isFontWeightBold(description.weight()) ? *cjkBold[preferredCJKFont] : *cjkPlain[preferredCJKFont], false);
         bool useSecondaryFont = true;
         if (simpleFontData) {
+        if (font) {
             CGGlyph glyphs[2];
             // CGFontGetGlyphsForUnichars takes UTF-16 buffer. Should only be 1 codepoint but since we may pass in two UTF-16 characters,
             // make room for 2 glyphs just to be safe.
             CGFontGetGlyphsForUnichars(simpleFontData->platformData().cgFont(), characters, glyphs, length);
+            CGFontGetGlyphsForUnichars(font->platformData().cgFont(), characters, glyphs, length);
             useSecondaryFont = (glyphs[0] == 0);
 …
         if (useSecondaryFont)
             simpleFontData = fontForFamily(description, isFontWeightBold(description.weight()) ? *cjkBold[secondaryCJKFont] : *cjkPlain[secondaryCJKFont], false);
+            font = fontForFamily(description, isFontWeightBold(description.weight()) ? *cjkBold[secondaryCJKFont] : *cjkPlain[secondaryCJKFont], false);
         break;
+    }
 …
         static NeverDestroyed<AtomicString> koreanPlain("AppleSDGothicNeo-Medium", AtomicString::ConstructFromLiteral);
         static NeverDestroyed<AtomicString> koreanBold("AppleSDGothicNeo-Bold", AtomicString::ConstructFromLiteral);
         simpleFontData = fontForFamily(description, isFontWeightBold(description.weight()) ? koreanBold : koreanPlain, false);
+        font = fontForFamily(description, isFontWeightBold(description.weight()) ? koreanBold : koreanPlain, false);
         break;
+    }
 …
         static NeverDestroyed<AtomicString> cyrillicPlain("HelveticaNeue", AtomicString::ConstructFromLiteral);
         static NeverDestroyed<AtomicString> cyrillicBold("HelveticaNeue-Bold", AtomicString::ConstructFromLiteral);
         simpleFontData = fontForFamily(description, isFontWeightBold(description.weight()) ? cyrillicBold : cyrillicPlain, false);
+        font = fontForFamily(description, isFontWeightBold(description.weight()) ? cyrillicBold : cyrillicPlain, false);
         break;
+    }
 …
         static NeverDestroyed<AtomicString> arabicPlain("GeezaPro", AtomicString::ConstructFromLiteral);
         static NeverDestroyed<AtomicString> arabicBold("GeezaPro-Bold", AtomicString::ConstructFromLiteral);
         simpleFontData = fontForFamily(description, isFontWeightBold(description.weight()) ? arabicBold : arabicPlain, false);
+        font = fontForFamily(description, isFontWeightBold(description.weight()) ? arabicBold : arabicPlain, false);
         break;
+    }
 …
         static NeverDestroyed<AtomicString> hebrewPlain("ArialHebrew", AtomicString::ConstructFromLiteral);
         static NeverDestroyed<AtomicString> hebrewBold("ArialHebrew-Bold", AtomicString::ConstructFromLiteral);
         simpleFontData = fontForFamily(description, isFontWeightBold(description.weight()) ? hebrewBold : hebrewPlain, false);
+        font = fontForFamily(description, isFontWeightBold(description.weight()) ? hebrewBold : hebrewPlain, false);
         break;
+    }
 …
             AtomicString* indicFontString = isFontWeightBold(description.weight()) ? indicUnicodePageFontsBold[indicPageOrderIndex] : indicUnicodePageFonts[indicPageOrderIndex];
             if (indicFontString)
                 simpleFontData = fontForFamily(description, *indicFontString, false);
+                font = fontForFamily(description, *indicFontString, false);
+        }
         break;
 …
         static NeverDestroyed<AtomicString> thaiPlain("Thonburi", AtomicString::ConstructFromLiteral);
         static NeverDestroyed<AtomicString> thaiBold("Thonburi-Bold", AtomicString::ConstructFromLiteral);
         simpleFontData = fontForFamily(description, isFontWeightBold(description.weight()) ? thaiBold : thaiPlain, false);
+        font = fontForFamily(description, isFontWeightBold(description.weight()) ? thaiBold : thaiPlain, false);
         break;
+    }
 …
         static NeverDestroyed<AtomicString> tibetanPlain("Kailasa", AtomicString::ConstructFromLiteral);
         static NeverDestroyed<AtomicString> tibetanBold("Kailasa-Bold", AtomicString::ConstructFromLiteral);
         simpleFontData = fontForFamily(description, isFontWeightBold(description.weight()) ? tibetanBold : tibetanPlain, false);
+        font = fontForFamily(description, isFontWeightBold(description.weight()) ? tibetanBold : tibetanPlain, false);
         break;
+    }
 …
         static NeverDestroyed<AtomicString> casPlain("EuphemiaUCAS", AtomicString::ConstructFromLiteral);
         static NeverDestroyed<AtomicString> casBold("EuphemiaUCAS-Bold", AtomicString::ConstructFromLiteral);
         simpleFontData = fontForFamily(description, isFontWeightBold(description.weight()) ? casBold : casPlain, false);
+        font = fontForFamily(description, isFontWeightBold(description.weight()) ? casBold : casPlain, false);
         break;
+    }
     case LanguageSpecificFont::Khmer: {
         static NeverDestroyed<AtomicString> khmer("KhmerSangamMN", AtomicString::ConstructFromLiteral);
         simpleFontData = fontForFamily(description, khmer, false);
+        font = fontForFamily(description, khmer, false);
         break;
+    }
     case LanguageSpecificFont::Lao: {
         static NeverDestroyed<AtomicString> lao("LaoSangamMN", AtomicString::ConstructFromLiteral);
         simpleFontData = fontForFamily(description, lao, false);
+        font = fontForFamily(description, lao, false);
         break;
+    }
 …
+        }
         if (useEmojiFont)
             simpleFontData = fontForFamily(description, appleColorEmoji, false);
+            font = fontForFamily(description, appleColorEmoji, false);
         else {
             RetainPtr<CTFontRef> fallbackFont = adoptCF(CTFontCreateForCharacters(originalFontData->getCTFont(), characters, length, nullptr));
             if (RetainPtr<CFStringRef> foundFontName = adoptCF(CTFontCopyPostScriptName(fallbackFont.get())))
                 simpleFontData = fontForFamily(description, foundFontName.get(), false);
+        }
         break;
+    }
+    }
     if (simpleFontData)
         return simpleFontData.release();
+                font = fontForFamily(description, foundFontName.get(), false);
+        }
+        break;
+    }
+    }
+    if (font)
+        return font.release();
     return lastResortFallbackFont(description);
+}
 RefPtr<SimpleFontData> FontCache::similarFontPlatformData(const FontDescription& description)
+RefPtr<Font> FontCache::similarFont(const FontDescription& description)
+{
     // Attempt to find an appropriate font using a match based on the presence of keywords in
     // the requested names. For example, we'll match any name that contains "Arabic" to Geeza Pro.
     RefPtr<SimpleFontData> simpleFontData;
+    RefPtr<Font> font;
     for (unsigned i = 0; i < description.familyCount(); ++i) {
         const AtomicString& family = description.familyAt(i);
 …
         static NeverDestroyed<AtomicString> courier("courier", AtomicString::ConstructFromLiteral);
         if (equalIgnoringCase(family, monaco) || equalIgnoringCase(family, menlo)) {
             simpleFontData = fontForFamily(description, courier);
+            font = fontForFamily(description, courier);
             continue;
+        }
 …
         static NeverDestroyed<AtomicString> verdana("verdana", AtomicString::ConstructFromLiteral);
         if (equalIgnoringCase(family, lucidaGrande)) {
             simpleFontData = fontForFamily(description, verdana);
+            font = fontForFamily(description, verdana);
             continue;
+        }
 …
         static NeverDestroyed<AtomicString> geezaPlain("GeezaPro", AtomicString::ConstructFromLiteral);
         static NeverDestroyed<AtomicString> geezaBold("GeezaPro-Bold", AtomicString::ConstructFromLiteral);
         for (int j = 0; j < 3 && !simpleFontData; ++j)
+        for (int j = 0; j < 3 && !font; ++j) {
             if (family.contains(*matchWords[j], false))
+                simpleFontData = fontForFamily(description, isFontWeightBold(description.weight()) ? geezaBold : geezaPlain);
+    }
+    return simpleFontData.release();
+}
+Ref<SimpleFontData> FontCache::lastResortFallbackFont(const FontDescription& fontDescription)
+                font = fontForFamily(description, isFontWeightBold(description.weight()) ? geezaBold : geezaPlain);
+        }
+    }
+    return font.release();
+}
+Ref<Font> FontCache::lastResortFallbackFont(const FontDescription& fontDescription)
+{
     static NeverDestroyed<AtomicString> fallbackFontFamily(".PhoneFallback", AtomicString::ConstructFromLiteral);

trunk/Source/WebCore/platform/graphics/ios/SimpleFontDataIOS.mm

r178510	r178940
26	26
27	27	#import "config.h"
28		#import "~~SimpleFontData~~.h"
	28	#import "Font.h"
29	29
30	30	#import "BlockExceptions.h"
…	…
68	68	}
69	69
70		void ~~SimpleFontData~~::platformInit()
	70	void Font::platformInit()
71	71	{
72	72	m_syntheticBoldOffset = m_platformData.m_syntheticBold ? ceilf(m_platformData.size() / 24.0f) : 0.f;
…	…
129	129	}
130	130
131		void ~~SimpleFontData~~::platformCharWidthInit()
	131	void Font::platformCharWidthInit()
132	132	{
133	133	m_avgCharWidth = 0;
…	…
138	138	}
139	139
140		PassRefPtr<~~SimpleFontData> SimpleFontData::platformCreateScaledFontData~~(const FontDescription&, float scaleFactor) const
	140	PassRefPtr<Font> Font::platformCreateScaledFont(const FontDescription&, float scaleFactor) const
141	141	{
142	142	if (isCustomFont()) {
143	143	FontPlatformData scaledFontData(m_platformData);
144	144	scaledFontData.m_size = scaledFontData.m_size * scaleFactor;
145		return ~~SimpleFontData~~::create(scaledFontData, true, false);
	145	return Font::create(scaledFontData, true, false);
146	146	}
147	147
…	…
168	168	}
169	169
170		void ~~SimpleFontData~~::determinePitch()
	170	void Font::determinePitch()
171	171	{
172	172	CTFontRef ctFont = m_platformData.font();
…	…
185	185	}
186	186
187		CGFontRenderingStyle ~~SimpleFontData~~::renderingStyle() const
	187	CGFontRenderingStyle Font::renderingStyle() const
188	188	{
189	189	return kCGFontRenderingStyleAntialiasing \| kCGFontRenderingStyleSubpixelPositioning \| kCGFontRenderingStyleSubpixelQuantization \| kCGFontAntialiasingStyleUnfiltered;
190	190	}
191	191
192		bool ~~SimpleFontData~~::advanceForColorBitmapFont(Glyph, CGSize&) const
	192	bool Font::advanceForColorBitmapFont(Glyph, CGSize&) const
193	193	{
194	194	return false;

trunk/Source/WebCore/platform/graphics/mac/ComplexTextController.cpp

-              r178510
+              r178940
+    }
     float width(unsigned from, unsigned len, HashSet<const SimpleFontData*>* fallbackFonts)
+    float width(unsigned from, unsigned len, HashSet<const Font*>* fallbackFonts)
+    {
         m_controller->advance(from, 0, ByWholeGlyphs, fallbackFonts);
 …
+}
 float FontCascade::width(TextLayout& layout, unsigned from, unsigned len, HashSet<const SimpleFontData*>* fallbackFonts)
+float FontCascade::width(TextLayout& layout, unsigned from, unsigned len, HashSet<const Font*>* fallbackFonts)
+{
     return layout.width(from, len, fallbackFonts);
 …
+}
 ComplexTextController::ComplexTextController(const FontCascade* font, const TextRun& run, bool mayUseNaturalWritingDirection, HashSet<const SimpleFontData*>* fallbackFonts, bool forTextEmphasis)
+ComplexTextController::ComplexTextController(const FontCascade* font, const TextRun& run, bool mayUseNaturalWritingDirection, HashSet<const Font*>* fallbackFonts, bool forTextEmphasis)
     : m_font(*font)
     , m_run(run)
 …
         return;
     // We break up glyph run generation for the string by FontData.
+    // We break up glyph run generation for the string by Font.
     const UChar* cp;
 …
     const UChar* end = cp + m_end;
     const SimpleFontData* fontData;
+    const Font* font;
     bool isMissingGlyph;
     const SimpleFontData* nextFontData;
+    const Font* nextFont;
     bool nextIsMissingGlyph;
 …
     nextIsMissingGlyph = false;
     nextFontData = m_font.fontDataForCombiningCharacterSequence(sequenceStart, curr - sequenceStart, nextIsSmallCaps ? SmallCapsVariant : NormalVariant);
     if (!nextFontData)
+    nextFont = m_font.fontForCombiningCharacterSequence(sequenceStart, curr - sequenceStart, nextIsSmallCaps ? SmallCapsVariant : NormalVariant);
+    if (!nextFont)
         nextIsMissingGlyph = true;
     while (curr < end) {
         fontData = nextFontData;
+        font = nextFont;
         isMissingGlyph = nextIsMissingGlyph;
         isSmallCaps = nextIsSmallCaps;
 …
         nextIsMissingGlyph = false;
         if (baseCharacter == zeroWidthJoiner)
             nextFontData = fontData;
+            nextFont = font;
         else {
             nextFontData = m_font.fontDataForCombiningCharacterSequence(cp + index, curr - cp - index, nextIsSmallCaps ? SmallCapsVariant : NormalVariant);
             if (!nextFontData)
+            nextFont = m_font.fontForCombiningCharacterSequence(cp + index, curr - cp - index, nextIsSmallCaps ? SmallCapsVariant : NormalVariant);
+            if (!nextFont)
                 nextIsMissingGlyph = true;
+        }
         if (nextFontData != fontData || nextIsMissingGlyph != isMissingGlyph) {
+        if (nextFont != font || nextIsMissingGlyph != isMissingGlyph) {
             int itemStart = static_cast<int>(indexOfFontTransition);
             int itemLength = index - indexOfFontTransition;
             collectComplexTextRunsForCharacters((isSmallCaps ? m_smallCapsBuffer.data() : cp) + itemStart, itemLength, itemStart, !isMissingGlyph ? fontData : 0);
+            collectComplexTextRunsForCharacters((isSmallCaps ? m_smallCapsBuffer.data() : cp) + itemStart, itemLength, itemStart, !isMissingGlyph ? font : 0);
             indexOfFontTransition = index;
+        }
 …
     if (itemLength) {
         int itemStart = indexOfFontTransition;
         collectComplexTextRunsForCharacters((nextIsSmallCaps ? m_smallCapsBuffer.data() : cp) + itemStart, itemLength, itemStart, !nextIsMissingGlyph ? nextFontData : 0);
+        collectComplexTextRunsForCharacters((nextIsSmallCaps ? m_smallCapsBuffer.data() : cp) + itemStart, itemLength, itemStart, !nextIsMissingGlyph ? nextFont : 0);
+    }
 …
+}
 void ComplexTextController::advance(unsigned offset, GlyphBuffer* glyphBuffer, GlyphIterationStyle iterationStyle, HashSet<const SimpleFontData*>* fallbackFonts)
+void ComplexTextController::advance(unsigned offset, GlyphBuffer* glyphBuffer, GlyphIterationStyle iterationStyle, HashSet<const Font*>* fallbackFonts)
+{
     if (static_cast<int>(offset) > m_end)
 …
         unsigned g = ltr ? m_glyphInCurrentRun : glyphCount - 1 - m_glyphInCurrentRun;
         unsigned k = leftmostGlyph + g;
         if (fallbackFonts && &complexTextRun.fontData() != &m_font.primaryFontData())
             fallbackFonts->add(&complexTextRun.fontData());
+        if (fallbackFonts && &complexTextRun.font() != &m_font.primaryFont())
+            fallbackFonts->add(&complexTextRun.font());
         // We must store the initial advance for the first glyph we are going to draw.
 …
             if (glyphBuffer && !m_characterInCurrentGlyph)
                 glyphBuffer->add(m_adjustedGlyphs[k], &complexTextRun.fontData(), adjustedAdvance, complexTextRun.indexAt(m_glyphInCurrentRun));
+                glyphBuffer->add(m_adjustedGlyphs[k], &complexTextRun.font(), adjustedAdvance, complexTextRun.indexAt(m_glyphInCurrentRun));
             unsigned oldCharacterInCurrentGlyph = m_characterInCurrentGlyph;
 …
         ComplexTextRun& complexTextRun = *m_complexTextRuns[r];
         unsigned glyphCount = complexTextRun.glyphCount();
         const SimpleFontData& fontData = complexTextRun.fontData();
+        const Font& font = complexTextRun.font();
 #if PLATFORM(IOS)
         bool isEmoji = fontData.platformData().m_isEmoji;
+        bool isEmoji = font.platformData().m_isEmoji;
 #endif
 …
         bool lastRun = r + 1 == runCount;
         bool roundsAdvances = !m_font.isPrinterFont() && fontData.platformData().roundsGlyphAdvances();
         float spaceWidth = fontData.spaceWidth() - fontData.syntheticBoldOffset();
+        bool roundsAdvances = !m_font.isPrinterFont() && font.platformData().roundsGlyphAdvances();
+        float spaceWidth = font.spaceWidth() - font.syntheticBoldOffset();
         CGFloat roundedSpaceWidth = roundCGFloat(spaceWidth);
         const UChar* cp = complexTextRun.characters();
 …
             bool treatAsSpace = FontCascade::treatAsSpace(ch);
             CGGlyph glyph = treatAsSpace ? fontData.spaceGlyph() : glyphs[i];
+            CGGlyph glyph = treatAsSpace ? font.spaceGlyph() : glyphs[i];
             CGSize advance = treatAsSpace ? CGSizeMake(spaceWidth, advances[i].height) : advances[i];
 #if PLATFORM(IOS)
             if (isEmoji && advance.width)
                 advance.width = fontData.widthForGlyph(glyph);
+                advance.width = font.widthForGlyph(glyph);
 #endif
             if (ch == '\t' && m_run.allowTabs())
                 advance.width = m_font.tabWidth(fontData, m_run.tabSize(), m_run.xPos() + m_totalWidth + widthSinceLastCommit);
+                advance.width = m_font.tabWidth(font, m_run.tabSize(), m_run.xPos() + m_totalWidth + widthSinceLastCommit);
             else if (FontCascade::treatAsZeroWidthSpace(ch) && !treatAsSpace) {
                 advance.width = 0;
                 glyph = fontData.spaceGlyph();
+                glyph = font.spaceGlyph();
+            }
 …
                 advance.width = roundedAdvanceWidth;
             advance.width += fontData.syntheticBoldOffset();
+            advance.width += font.syntheticBoldOffset();
 …
             // Second, in fixed-pitch fonts we ensure that all glyphs that
             // match the width of the space glyph have the same width as the space glyph.
             if (m_run.applyWordRounding() && roundedAdvanceWidth == roundedSpaceWidth && (fontData.pitch() == FixedPitch || glyph == fontData.spaceGlyph()))
                 advance.width = fontData.adjustedSpaceWidth();
+            if (m_run.applyWordRounding() && roundedAdvanceWidth == roundedSpaceWidth && (font.pitch() == FixedPitch || glyph == font.spaceGlyph()))
+                advance.width = font.adjustedSpaceWidth();
             if (hasExtraSpacing) {
 …
             m_adjustedGlyphs.append(glyph);
             FloatRect glyphBounds = fontData.boundsForGlyph(glyph);
+            FloatRect glyphBounds = font.boundsForGlyph(glyph);
             glyphBounds.move(glyphOrigin.x, glyphOrigin.y);
             m_minGlyphBoundingBoxX = std::min(m_minGlyphBoundingBoxX, glyphBounds.x());

trunk/Source/WebCore/platform/graphics/mac/ComplexTextController.h

-              r178510
+              r178940
 class FontCascade;
 class SimpleFontData;
+class Font;
 class TextRun;
 …
 class ComplexTextController {
 public:
     ComplexTextController(const FontCascade*, const TextRun&, bool mayUseNaturalWritingDirection = false, HashSet<const SimpleFontData*>* fallbackFonts = 0, bool forTextEmphasis = false);
+    ComplexTextController(const FontCascade*, const TextRun&, bool mayUseNaturalWritingDirection = false, HashSet<const Font*>* fallbackFonts = 0, bool forTextEmphasis = false);
     // Advance and emit glyphs up to the specified character.
     void advance(unsigned to, GlyphBuffer* = 0, GlyphIterationStyle = IncludePartialGlyphs, HashSet<const SimpleFontData*>* fallbackFonts = 0);
+    void advance(unsigned to, GlyphBuffer* = 0, GlyphIterationStyle = IncludePartialGlyphs, HashSet<const Font*>* fallbackFonts = 0);
     // Compute the character offset for a given x coordinate.
 …
     class ComplexTextRun : public RefCounted<ComplexTextRun> {
     public:
         static Ref<ComplexTextRun> create(CTRunRef ctRun, const SimpleFontData& fontData, const UChar* characters, unsigned stringLocation, size_t stringLength, CFRange runRange)
+        static Ref<ComplexTextRun> create(CTRunRef ctRun, const Font& font, const UChar* characters, unsigned stringLocation, size_t stringLength, CFRange runRange)
+        {
             return adoptRef(*new ComplexTextRun(ctRun, fontData, characters, stringLocation, stringLength, runRange));
+            return adoptRef(*new ComplexTextRun(ctRun, font, characters, stringLocation, stringLength, runRange));
+        }
         static Ref<ComplexTextRun> create(const SimpleFontData& fontData, const UChar* characters, unsigned stringLocation, size_t stringLength, bool ltr)
+        static Ref<ComplexTextRun> create(const Font& font, const UChar* characters, unsigned stringLocation, size_t stringLength, bool ltr)
+        {
             return adoptRef(*new ComplexTextRun(fontData, characters, stringLocation, stringLength, ltr));
+            return adoptRef(*new ComplexTextRun(font, characters, stringLocation, stringLength, ltr));
+        }
         unsigned glyphCount() const { return m_glyphCount; }
         const SimpleFontData& fontData() const { return m_fontData; }
+        const Font& font() const { return m_font; }
         const UChar* characters() const { return m_characters; }
         unsigned stringLocation() const { return m_stringLocation; }
 …
     private:
         ComplexTextRun(CTRunRef, const SimpleFontData&, const UChar* characters, unsigned stringLocation, size_t stringLength, CFRange runRange);
         ComplexTextRun(const SimpleFontData&, const UChar* characters, unsigned stringLocation, size_t stringLength, bool ltr);
+        ComplexTextRun(CTRunRef, const Font&, const UChar* characters, unsigned stringLocation, size_t stringLength, CFRange runRange);
+        ComplexTextRun(const Font&, const UChar* characters, unsigned stringLocation, size_t stringLength, bool ltr);
         unsigned m_glyphCount;
         const SimpleFontData& m_fontData;
+        const Font& m_font;
         const UChar* m_characters;
         unsigned m_stringLocation;
 …
     void collectComplexTextRuns();
     void collectComplexTextRunsForCharacters(const UChar*, unsigned length, unsigned stringLocation, const SimpleFontData*);
+    void collectComplexTextRunsForCharacters(const UChar*, unsigned length, unsigned stringLocation, const Font*);
     void adjustGlyphsAndAdvances();
 …
     bool m_afterExpansion;
     HashSet<const SimpleFontData*>* m_fallbackFonts;
+    HashSet<const Font*>* m_fallbackFonts;
     float m_minGlyphBoundingBoxX;

trunk/Source/WebCore/platform/graphics/mac/ComplexTextControllerCoreText.mm

-              r178510
+              r178940
     // By the time a WebCascadeList is used, the FontCascade has already been asked to realize all of its
     // FontData, so this loop does not hit the FontCache.
+    // Fonts, so this loop does not hit the FontCache.
     while (!_font->fallbackRangesAt(_count).isNull())
         _count++;
 …
         _fontDescriptors.grow(index + 1);
     const WebCore::SimpleFontData* simpleFontData = _font->fallbackRangesAt(index).fontDataForCharacter(_character);
     if (!simpleFontData)
         simpleFontData = &_font->fallbackRangesAt(index).fontDataForFirstRange();
     fontDescriptor = CTFontCopyFontDescriptor(simpleFontData->platformData().ctFont());
+    const WebCore::Font* font = _font->fallbackRangesAt(index).fontForCharacter(_character);
+    if (!font)
+        font = &_font->fallbackRangesAt(index).fontForFirstRange();
+    fontDescriptor = CTFontCopyFontDescriptor(font->platformData().ctFont());
     _fontDescriptors[index] = adoptCF(fontDescriptor);
     return (id)fontDescriptor;
 …
 namespace WebCore {
 ComplexTextController::ComplexTextRun::ComplexTextRun(CTRunRef ctRun, const SimpleFontData& fontData, const UChar* characters, unsigned stringLocation, size_t stringLength, CFRange runRange)
     : m_fontData(fontData)
+ComplexTextController::ComplexTextRun::ComplexTextRun(CTRunRef ctRun, const Font& font, const UChar* characters, unsigned stringLocation, size_t stringLength, CFRange runRange)
+    : m_font(font)
     , m_characters(characters)
     , m_stringLocation(stringLocation)
 …
 // Missing glyphs run constructor. Core Text will not generate a run of missing glyphs, instead falling back on
 // glyphs from LastResort. We want to use the primary font's missing glyph in order to match the fast text code path.
 ComplexTextController::ComplexTextRun::ComplexTextRun(const SimpleFontData& fontData, const UChar* characters, unsigned stringLocation, size_t stringLength, bool ltr)
     : m_fontData(fontData)
+ComplexTextController::ComplexTextRun::ComplexTextRun(const Font& font, const UChar* characters, unsigned stringLocation, size_t stringLength, bool ltr)
+    : m_font(font)
     , m_characters(characters)
     , m_stringLocation(stringLocation)
 …
     m_glyphsVector.fill(0, m_glyphCount);
     m_glyphs = m_glyphsVector.data();
     m_advancesVector.fill(CGSizeMake(m_fontData.widthForGlyph(0), 0), m_glyphCount);
+    m_advancesVector.fill(CGSizeMake(m_font.widthForGlyph(0), 0), m_glyphCount);
     m_advances = m_advancesVector.data();
+}
 …
+}
 void ComplexTextController::collectComplexTextRunsForCharacters(const UChar* cp, unsigned length, unsigned stringLocation, const SimpleFontData* fontData)
+{
     if (!fontData) {
+void ComplexTextController::collectComplexTextRunsForCharacters(const UChar* cp, unsigned length, unsigned stringLocation, const Font* font)
+{
+    if (!font) {
         // Create a run of missing glyphs from the primary font.
         m_complexTextRuns.append(ComplexTextRun::create(m_font.primaryFontData(), cp, stringLocation, length, m_run.ltr()));
+        m_complexTextRuns.append(ComplexTextRun::create(m_font.primaryFont(), cp, stringLocation, length, m_run.ltr()));
         return;
+    }
 …
     UChar32 baseCharacter = 0;
     RetainPtr<CFDictionaryRef> stringAttributes;
     if (fontData == SimpleFontData::systemFallback()) {
+    if (font == Font::systemFallback()) {
         // FIXME: This code path does not support small caps.
         isSystemFallback = true;
         U16_GET(cp, 0, 0, length, baseCharacter);
         fontData = m_font.fallbackRangesAt(0).fontDataForCharacter(baseCharacter);
         if (!fontData)
             fontData = &m_font.fallbackRangesAt(0).fontDataForFirstRange();
+        font = m_font.fallbackRangesAt(0).fontForCharacter(baseCharacter);
+        if (!font)
+            font = &m_font.fallbackRangesAt(0).fontForFirstRange();
         RetainPtr<WebCascadeList> cascadeList = adoptNS([[WebCascadeList alloc] initWithFont:&m_font character:baseCharacter]);
         stringAttributes = adoptCF(CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, fontData->getCFStringAttributes(m_font.typesettingFeatures(), fontData->platformData().orientation())));
+        stringAttributes = adoptCF(CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, font->getCFStringAttributes(m_font.typesettingFeatures(), font->platformData().orientation())));
         static const void* attributeKeys[] = { kCTFontCascadeListAttribute };
         const void* values[] = { cascadeList.get() };
         RetainPtr<CFDictionaryRef> attributes = adoptCF(CFDictionaryCreate(kCFAllocatorDefault, attributeKeys, values, sizeof(attributeKeys) / sizeof(*attributeKeys), &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
         RetainPtr<CTFontDescriptorRef> fontDescriptor = adoptCF(CTFontDescriptorCreateWithAttributes(attributes.get()));
         RetainPtr<CTFontRef> fontWithCascadeList = adoptCF(CTFontCreateCopyWithAttributes(fontData->platformData().ctFont(), m_font.pixelSize(), 0, fontDescriptor.get()));
+        RetainPtr<CTFontRef> fontWithCascadeList = adoptCF(CTFontCreateCopyWithAttributes(font->platformData().ctFont(), m_font.pixelSize(), 0, fontDescriptor.get()));
         CFDictionarySetValue(const_cast<CFMutableDictionaryRef>(stringAttributes.get()), kCTFontAttributeName, fontWithCascadeList.get());
     } else
         stringAttributes = fontData->getCFStringAttributes(m_font.typesettingFeatures(), fontData->platformData().orientation());
+        stringAttributes = font->getCFStringAttributes(m_font.typesettingFeatures(), font->platformData().orientation());
     RetainPtr<CTLineRef> line;
 …
         ASSERT(CFGetTypeID(ctRun) == CTRunGetTypeID());
         CFRange runRange = CTRunGetStringRange(ctRun);
         const SimpleFontData* runFontData = fontData;
+        const Font* runFont = font;
         if (isSystemFallback) {
             CFDictionaryRef runAttributes = CTRunGetAttributes(ctRun);
             CTFontRef runFont = static_cast<CTFontRef>(CFDictionaryGetValue(runAttributes, kCTFontAttributeName));
             ASSERT(CFGetTypeID(runFont) == CTFontGetTypeID());
             RetainPtr<CFTypeRef> runFontEqualityObject = FontPlatformData::objectForEqualityCheck(runFont);
             if (!CFEqual(runFontEqualityObject.get(), fontData->platformData().objectForEqualityCheck().get())) {
+            CTFontRef runCTFont = static_cast<CTFontRef>(CFDictionaryGetValue(runAttributes, kCTFontAttributeName));
+            ASSERT(CFGetTypeID(runCTFont) == CTFontGetTypeID());
+            RetainPtr<CFTypeRef> runFontEqualityObject = FontPlatformData::objectForEqualityCheck(runCTFont);
+            if (!CFEqual(runFontEqualityObject.get(), font->platformData().objectForEqualityCheck().get())) {
                 // Begin trying to see if runFont matches any of the fonts in the fallback list.
                 for (unsigned i = 0; !m_font.fallbackRangesAt(i).isNull(); ++i) {
                     runFontData = m_font.fallbackRangesAt(i).fontDataForCharacter(baseCharacter);
                     if (!runFontData)
+                    runFont = m_font.fallbackRangesAt(i).fontForCharacter(baseCharacter);
+                    if (!runFont)
                         continue;
                     RetainPtr<CFTypeRef> runFontEqualityObject = runFontData->platformData().objectForEqualityCheck();
+                    RetainPtr<CFTypeRef> runFontEqualityObject = runFont->platformData().objectForEqualityCheck();
                     if (CFEqual(runFontEqualityObject.get(), runFontEqualityObject.get()))
                         break;
                     runFontData = 0;
+                    runFont = nullptr;
+                }
                 // If there is no matching font, look up by name in the font cache.
                 if (!runFontData) {
+                if (!runFont) {
                     // Rather than using runFont as an NSFont and wrapping it in a FontPlatformData, go through
                     // the font cache and ultimately through NSFontManager in order to get an NSFont with the right
                     // NSFontRenderingMode.
                     RetainPtr<CFStringRef> fontName = adoptCF(CTFontCopyPostScriptName(runFont));
+                    RetainPtr<CFStringRef> fontName = adoptCF(CTFontCopyPostScriptName(runCTFont));
                     if (CFEqual(fontName.get(), CFSTR("LastResort"))) {
                         m_complexTextRuns.append(ComplexTextRun::create(m_font.primaryFontData(), cp, stringLocation + runRange.location, runRange.length, m_run.ltr()));
+                        m_complexTextRuns.append(ComplexTextRun::create(m_font.primaryFont(), cp, stringLocation + runRange.location, runRange.length, m_run.ltr()));
                         continue;
+                    }
                     runFontData = fontCache().fontForFamily(m_font.fontDescription(), fontName.get(), false).get();
+                    runFont = fontCache().fontForFamily(m_font.fontDescription(), fontName.get(), false).get();
 #if !PLATFORM(IOS)
                     // Core Text may have used a font that is not known to NSFontManager. In that case, fall back on
                     // using the font as returned, even though it may not have the best NSFontRenderingMode.
                     if (!runFontData) {
                         FontPlatformData runFontPlatformData((NSFont *)runFont, CTFontGetSize(runFont), m_font.fontDescription().usePrinterFont());
                         runFontData = &fontCache().fontForPlatformData(runFontPlatformData).get();
+                    if (!runFont) {
+                        FontPlatformData runFontPlatformData((NSFont *)runCTFont, CTFontGetSize(runCTFont), m_font.fontDescription().usePrinterFont());
+                        runFont = &fontCache().fontForPlatformData(runFontPlatformData).get();
+                    }
 #else
                     // FIXME: Just assert for now, until we can devise a better fix that works with iOS.
                     ASSERT(runFontData);
+                    ASSERT(runFont);
 #endif
+                }
                 if (m_fallbackFonts && runFontData != &m_font.primaryFontData())
                     m_fallbackFonts->add(runFontData);
+                if (m_fallbackFonts && runFont != &m_font.primaryFont())
+                    m_fallbackFonts->add(runFont);
+            }
+        }
         if (m_fallbackFonts && runFontData != &m_font.primaryFontData())
             m_fallbackFonts->add(fontData);
         m_complexTextRuns.append(ComplexTextRun::create(ctRun, *runFontData, cp, stringLocation, length, runRange));
+        if (m_fallbackFonts && runFont != &m_font.primaryFont())
+            m_fallbackFonts->add(font);
+        m_complexTextRuns.append(ComplexTextRun::create(ctRun, *runFont, cp, stringLocation, length, runRange));
+    }
+}

trunk/Source/WebCore/platform/graphics/mac/FontCacheMac.mm

-              r178510
+              r178940
 #import "CoreGraphicsSPI.h"
+#import "Font.h"
 #import "FontCascade.h"
-#import "SimpleFontData.h"
 #import "FontPlatformData.h"
 #import "NSFontSPI.h"
 …
+}
 RefPtr<SimpleFontData> FontCache::systemFallbackForCharacters(const FontDescription& description, const SimpleFontData* originalFontData, bool isPlatformFont, const UChar* characters, int length)
+RefPtr<Font> FontCache::systemFallbackForCharacters(const FontDescription& description, const Font* originalFontData, bool isPlatformFont, const UChar* characters, int length)
+{
     UChar32 character;
 …
+}
 RefPtr<SimpleFontData> FontCache::similarFontPlatformData(const FontDescription& description)
+RefPtr<Font> FontCache::similarFont(const FontDescription& description)
+{
     // Attempt to find an appropriate font using a match based on
     // the presence of keywords in the the requested names.  For example, we'll
     // match any name that contains "Arabic" to Geeza Pro.
     RefPtr<SimpleFontData> simpleFontData;
+    RefPtr<Font> font;
     for (unsigned i = 0; i < description.familyCount(); ++i) {
         const AtomicString& family = description.familyAt(i);
 …
         static String* matchWords[3] = { new String("Arabic"), new String("Pashto"), new String("Urdu") };
         DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, geezaStr, ("Geeza Pro", AtomicString::ConstructFromLiteral));
         for (int j = 0; j < 3 && !simpleFontData; ++j)
+        for (int j = 0; j < 3 && !font; ++j) {
             if (family.contains(*matchWords[j], false))
+                simpleFontData = fontForFamily(description, geezaStr);
+    }
+    return simpleFontData.release();
+}
+Ref<SimpleFontData> FontCache::lastResortFallbackFont(const FontDescription& fontDescription)
+                font = fontForFamily(description, geezaStr);
+        }
+    }
+    return font.release();
+}
+Ref<Font> FontCache::lastResortFallbackFont(const FontDescription& fontDescription)
+{
     DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, timesStr, ("Times", AtomicString::ConstructFromLiteral));
 …
     // FIXME: Would be even better to somehow get the user's default font here.  For now we'll pick
     // the default that the user would get without changing any prefs.
     RefPtr<SimpleFontData> simpleFontData = fontForFamily(fontDescription, timesStr, false);
     if (simpleFontData)
         return *simpleFontData;
+    RefPtr<Font> font = fontForFamily(fontDescription, timesStr, false);
+    if (font)
+        return *font;
     // The Times fallback will almost always work, but in the highly unusual case where

trunk/Source/WebCore/platform/graphics/mac/GlyphPageMac.cpp

-              r178510
+              r178940
 #include "CoreGraphicsSPI.h"
 #include "CoreTextSPI.h"
+#include "Font.h"
 #include "FontCascade.h"
-#include "SimpleFontData.h"
 #include "WebCoreSystemInterface.h"
 #if !PLATFORM(IOS)
 …
 namespace WebCore {
 static bool shouldUseCoreText(const UChar* buffer, unsigned bufferLength, const SimpleFontData* fontData)
+static bool shouldUseCoreText(const UChar* buffer, unsigned bufferLength, const Font* fontData)
+{
     if (fontData->platformData().isCompositeFontReference())
 …
+}
 bool GlyphPage::mayUseMixedFontDataWhenFilling(const UChar* buffer, unsigned bufferLength, const SimpleFontData* fontData)
+bool GlyphPage::mayUseMixedFontsWhenFilling(const UChar* buffer, unsigned bufferLength, const Font* fontData)
+{
 #if USE(APPKIT)
 …
+}
 bool GlyphPage::fill(unsigned offset, unsigned length, UChar* buffer, unsigned bufferLength, const SimpleFontData* fontData)
+bool GlyphPage::fill(unsigned offset, unsigned length, UChar* buffer, unsigned bufferLength, const Font* fontData)
+{
     bool haveGlyphs = false;
 …
 #if USE(APPKIT)
                 } else {
                     const SimpleFontData* runSimple = fontData->compositeFontReferenceFontData((NSFont *)runFont);
+                    const Font* runSimple = fontData->compositeFontReferenceFont((NSFont *)runFont);
                     if (runSimple) {
                         for (CFIndex i = 0; i < glyphCount; ++i) {

trunk/Source/WebCore/platform/graphics/mac/SimpleFontDataCoreText.cpp

-              r161589
+              r178940
 #include "config.h"
 #include "SimpleFontData.h"
+#include "Font.h"
 #if !PLATFORM(IOS)
 …
 namespace WebCore {
 CFDictionaryRef SimpleFontData::getCFStringAttributes(TypesettingFeatures typesettingFeatures, FontOrientation orientation) const
+CFDictionaryRef Font::getCFStringAttributes(TypesettingFeatures typesettingFeatures, FontOrientation orientation) const
+{
     unsigned key = typesettingFeatures + 1;

trunk/Source/WebCore/platform/graphics/mac/SimpleFontDataMac.mm

r178573	r178940
26	26
27	27	#import "config.h"
28		#import "~~SimpleFontData~~.h"
	28	#import "Font.h"
29	29
30	30	#import "BlockExceptions.h"
…	…
72	72	}
73	73
74		static bool initFontData(~~SimpleFontData~~* fontData)
	74	static bool initFontData(Font* fontData)
75	75	{
76	76	if (!fontData->platformData().cgFont())
…	…
86	86	}
87	87
88		const ~~SimpleFontData* SimpleFontData::compositeFontReferenceFontData~~(NSFont *key) const
	88	const Font* Font::compositeFontReferenceFont(NSFont *key) const
89	89	{
90	90	if (!key \|\| CFEqual(adoptCF(CTFontCopyPostScriptName(CTFontRef(key))).get(), CFSTR("LastResort")))
…	…
104	104
105	105	FontPlatformData substitutePlatform(substituteFont, platformData().size(), isUsingPrinterFont, syntheticBold, syntheticOblique, platformData().orientation(), platformData().widthVariant());
106		addResult.iterator->value = ~~SimpleFontData~~::create(substitutePlatform, isCustomFont());
	106	addResult.iterator->value = Font::create(substitutePlatform, isCustomFont());
107	107	}
108	108	return addResult.iterator->value.get();
109	109	}
110	110
111		void ~~SimpleFontData~~::platformInit()
	111	void Font::platformInit()
112	112	{
113	113	m_syntheticBoldOffset = m_platformData.m_syntheticBold ? 1.0f : 0.f;
…	…
227	227	xHeight = scaleEmToUnits(CGFontGetXHeight(m_platformData.cgFont()), unitsPerEm) * pointSize;
228	228	} else
229		xHeight = verticalRightOrientationFont~~Data~~()->fontMetrics().xHeight();
	229	xHeight = verticalRightOrientationFont()->fontMetrics().xHeight();
230	230
231	231	m_fontMetrics.setUnitsPerEm(unitsPerEm);
…	…
242	242	}
243	243
244		void ~~SimpleFontData~~::platformCharWidthInit()
	244	void Font::platformCharWidthInit()
245	245	{
246	246	m_avgCharWidth = 0;
…	…
270	270	#endif // USE(APPKIT)
271	271
272		void ~~SimpleFontData~~::platformDestroy()
	272	void Font::platformDestroy()
273	273	{
274	274	}
275	275
276	276	#if !PLATFORM(IOS)
277		PassRefPtr<~~SimpleFontData> SimpleFontData::platformCreateScaledFontData~~(const FontDescription& fontDescription, float scaleFactor) const
	277	PassRefPtr<Font> Font::platformCreateScaledFont(const FontDescription& fontDescription, float scaleFactor) const
278	278	{
279	279	if (isCustomFont()) {
280	280	FontPlatformData scaledFontData(m_platformData);
281	281	scaledFontData.m_size = scaledFontData.m_size * scaleFactor;
282		return ~~SimpleFontData~~::create(scaledFontData, true, false);
	282	return Font::create(scaledFontData, true, false);
283	283	}
284	284
…	…
311	311	}
312	312
313		void ~~SimpleFontData~~::determinePitch()
	313	void Font::determinePitch()
314	314	{
315	315	NSFont* f = m_platformData.nsFont();
…	…
334	334	#endif // !PLATFORM(IOS)
335	335
336		FloatRect ~~SimpleFontData~~::platformBoundsForGlyph(Glyph glyph) const
	336	FloatRect Font::platformBoundsForGlyph(Glyph glyph) const
337	337	{
338	338	FloatRect boundingBox;
…	…
346	346
347	347	#if PLATFORM(MAC)
348		inline CGFontRenderingStyle ~~SimpleFontData~~::renderingStyle() const
	348	inline CGFontRenderingStyle Font::renderingStyle() const
349	349	{
350	350	CGFontRenderingStyle style = kCGFontRenderingStyleAntialiasing \| kCGFontRenderingStyleSubpixelPositioning \| kCGFontRenderingStyleSubpixelQuantization;
…	…
365	365	}
366	366
367		inline bool ~~SimpleFontData~~::advanceForColorBitmapFont(Glyph glyph, CGSize& advance) const
	367	inline bool Font::advanceForColorBitmapFont(Glyph glyph, CGSize& advance) const
368	368	{
369	369	NSFont *font = platformData().nsFont();
…	…
395	395	}
396	396
397		inline bool ~~SimpleFontData~~::canUseFastGlyphAdvanceGetter(Glyph glyph, CGSize& advance, bool& populatedAdvance) const
	397	inline bool Font::canUseFastGlyphAdvanceGetter(Glyph glyph, CGSize& advance, bool& populatedAdvance) const
398	398	{
399	399	// Fast getter doesn't take custom tracking into account
…	…
411	411	}
412	412
413		float ~~SimpleFontData~~::platformWidthForGlyph(Glyph glyph) const
	413	float Font::platformWidthForGlyph(Glyph glyph) const
414	414	{
415	415	CGSize advance = CGSizeZero;
…	…
447	447	}
448	448
449		bool ~~SimpleFontData~~::canRenderCombiningCharacterSequence(const UChar* characters, size_t length) const
	449	bool Font::canRenderCombiningCharacterSequence(const UChar* characters, size_t length) const
450	450	{
451	451	ASSERT(isMainThread());

trunk/Source/WebCore/platform/graphics/opentype/OpenTypeMathData.cpp

-              r177955
+              r178940
 #include "OpenTypeMathData.h"
+#include "Font.h"
 #include "FontPlatformData.h"
 #if ENABLE(OPENTYPE_MATH)
 …
 #endif
 #include "SharedBuffer.h"
-#include "SimpleFontData.h"
 using namespace std;
 …
 #if ENABLE(OPENTYPE_MATH)
 OpenTypeMathData::OpenTypeMathData(const FontPlatformData& fontData)
+{
     m_mathBuffer = fontData.openTypeTable(OpenType::MATHTag);
+OpenTypeMathData::OpenTypeMathData(const FontPlatformData& font)
+{
+    m_mathBuffer = font.openTypeTable(OpenType::MATHTag);
     const OpenType::MATHTable* math = OpenType::validateTable<OpenType::MATHTable>(m_mathBuffer);
     if (!math) {
 …
 #if ENABLE(OPENTYPE_MATH)
 float OpenTypeMathData::getMathConstant(const SimpleFontData& font, MathConstant constant) const
+float OpenTypeMathData::getMathConstant(const Font& font, MathConstant constant) const
+{
     int32_t value = 0;
 …
     return value * font.sizePerUnit();
 #else
 float OpenTypeMathData::getMathConstant(const SimpleFontData&, MathConstant) const
+float OpenTypeMathData::getMathConstant(const Font&, MathConstant) const
+{
     ASSERT_NOT_REACHED();
 …
 #if ENABLE(OPENTYPE_MATH)
 float OpenTypeMathData::getItalicCorrection(const SimpleFontData& font, Glyph glyph) const
+float OpenTypeMathData::getItalicCorrection(const Font& font, Glyph glyph) const
+{
     const OpenType::MATHTable* math = OpenType::validateTable<OpenType::MATHTable>(m_mathBuffer);
 …
     return mathItalicsCorrectionInfo->getItalicCorrection(*m_mathBuffer, glyph) * font.sizePerUnit();
 #else
 float OpenTypeMathData::getItalicCorrection(const SimpleFontData&, Glyph) const
+float OpenTypeMathData::getItalicCorrection(const Font&, Glyph) const
+{
     ASSERT_NOT_REACHED();

trunk/Source/WebCore/platform/graphics/opentype/OpenTypeMathData.h

-              r177955
+              r178940
 class FontPlatformData;
 class SharedBuffer;
 class SimpleFontData;
+class Font;
 class OpenTypeMathData : public RefCounted<OpenTypeMathData> {
 public:
     static PassRefPtr<OpenTypeMathData> create(const FontPlatformData& fontData)
+    static PassRefPtr<OpenTypeMathData> create(const FontPlatformData& font)
+    {
         return adoptRef(new OpenTypeMathData(fontData));
+        return adoptRef(new OpenTypeMathData(font));
+    }
     ~OpenTypeMathData();
 …
     };
     float getMathConstant(const SimpleFontData&, MathConstant) const;
     float getItalicCorrection(const SimpleFontData&, Glyph) const;
+    float getMathConstant(const Font&, MathConstant) const;
+    float getItalicCorrection(const Font&, Glyph) const;
     void getMathVariants(Glyph, bool isVertical, Vector<Glyph>& sizeVariants, Vector<AssemblyPart>& assemblyParts) const;

trunk/Source/WebCore/platform/graphics/opentype/OpenTypeVerticalData.cpp

r166640	r178940
28	28
29	29	#include "FloatRect.h"
	30	#include "Font.h"
30	31	#include "GlyphPage.h"
31	32	#include "OpenTypeTypes.h"
32	33	#include "SharedBuffer.h"
33		~~#include "SimpleFontData.h"~~
34	34	#include <wtf/RefPtr.h>
35	35
…	…
480	480	}
481	481
482		float OpenTypeVerticalData::advanceHeight(const ~~SimpleFontData~~* font, Glyph glyph) const
	482	float OpenTypeVerticalData::advanceHeight(const Font* font, Glyph glyph) const
483	483	{
484	484	size_t countHeights = m_advanceHeights.size();
…	…
493	493	}
494	494
495		void OpenTypeVerticalData::getVerticalTranslationsForGlyphs(const ~~SimpleFontData~~* font, const Glyph* glyphs, size_t count, float* outXYArray) const
	495	void OpenTypeVerticalData::getVerticalTranslationsForGlyphs(const Font* font, const Glyph* glyphs, size_t count, float* outXYArray) const
496	496	{
497	497	size_t countWidths = m_advanceWidths.size();
…	…
536	536	}
537	537
538		void OpenTypeVerticalData::substituteWithVerticalGlyphs(const ~~SimpleFontData~~* font, GlyphPage* glyphPage, unsigned offset, unsigned length) const
	538	void OpenTypeVerticalData::substituteWithVerticalGlyphs(const Font* font, GlyphPage* glyphPage, unsigned offset, unsigned length) const
539	539	{
540	540	const HashMap<Glyph, Glyph>& map = m_verticalGlyphMap;

trunk/Source/WebCore/platform/graphics/opentype/OpenTypeVerticalData.h

-              r134871
+              r178940
 namespace WebCore {
+class Font;
 class FontPlatformData;
 class GlyphPage;
-class SimpleFontData;
 class OpenTypeVerticalData : public RefCounted<OpenTypeVerticalData> {
 …
     bool isOpenType() const { return !m_advanceWidths.isEmpty(); }
     bool hasVerticalMetrics() const { return !m_advanceHeights.isEmpty(); }
     float advanceHeight(const SimpleFontData*, Glyph) const;
     void getVerticalTranslationsForGlyphs(const SimpleFontData*, const Glyph*, size_t, float* outXYArray) const;
     void substituteWithVerticalGlyphs(const SimpleFontData*, GlyphPage*, unsigned offset, unsigned length) const;
+    float advanceHeight(const Font*, Glyph) const;
+    void getVerticalTranslationsForGlyphs(const Font*, const Glyph*, size_t, float* outXYArray) const;
+    void substituteWithVerticalGlyphs(const Font*, GlyphPage*, unsigned offset, unsigned length) const;
 private:

trunk/Source/WebCore/platform/graphics/win/FontCGWin.cpp

-              r178510
+              r178940
 #include "AffineTransform.h"
 #include "FloatConversion.h"
+#include "Font.h"
 #include "GlyphBuffer.h"
 #include "GraphicsContext.h"
 #include "IntRect.h"
-#include "SimpleFontData.h"
 #include "UniscribeController.h"
 #include "WebCoreTextRenderer.h"
 …
+}
 void FontCascade::drawGlyphs(GraphicsContext* graphicsContext, const SimpleFontData* font, const GlyphBuffer& glyphBuffer,
+void FontCascade::drawGlyphs(GraphicsContext* graphicsContext, const Font* font, const GlyphBuffer& glyphBuffer,
     int from, int numGlyphs, const FloatPoint& point) const
+{

trunk/Source/WebCore/platform/graphics/win/FontCacheWin.cpp

-              r178521
+              r178940
 #include "config.h"
 #include <winsock2.h>
+#include "Font.h"
 #include "FontCache.h"
 #include "HWndDC.h"
-#include "SimpleFontData.h"
 #include <mlang.h>
 #include <windows.h>
 …
+}
 RefPtr<SimpleFontData> FontCache::systemFallbackForCharacters(const FontDescription& description, const SimpleFontData* originalFontData, bool, const UChar* characters, int length)
+RefPtr<Font> FontCache::systemFallbackForCharacters(const FontDescription& description, const Font* originalFontData, bool, const UChar* characters, int length)
+{
     UChar character = characters[0];
     RefPtr<SimpleFontData> fontData;
+    RefPtr<Font> fontData;
     HWndDC hdc(0);
     HFONT primaryFont = originalFontData->platformData().hfont();
 …
+}
 RefPtr<SimpleFontData> FontCache::fontDataFromDescriptionAndLogFont(const FontDescription& fontDescription, const LOGFONT& font, AtomicString& outFontFamilyName)
+RefPtr<Font> FontCache::fontFromDescriptionAndLogFont(const FontDescription& fontDescription, const LOGFONT& font, AtomicString& outFontFamilyName)
+{
     AtomicString familyName = String(font.lfFaceName, wcsnlen(font.lfFaceName, LF_FACESIZE));
     RefPtr<SimpleFontData> fontData = fontForFamily(fontDescription, familyName);
+    RefPtr<Font> fontData = fontForFamily(fontDescription, familyName);
     if (fontData)
         outFontFamilyName = familyName;
 …
+}
 Ref<SimpleFontData> FontCache::lastResortFallbackFont(const FontDescription& fontDescription)
+Ref<Font> FontCache::lastResortFallbackFont(const FontDescription& fontDescription)
+{
     DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, fallbackFontName, ());
 …
         AtomicString("Arial", AtomicString::ConstructFromLiteral)
     };
     RefPtr<SimpleFontData> simpleFont;
+    RefPtr<Font> simpleFont;
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(fallbackFonts); ++i) {
         if (simpleFont = fontForFamily(fontDescription, fallbackFonts[i])) {
 …
         LOGFONT defaultGUILogFont;
         GetObject(defaultGUIFont, sizeof(defaultGUILogFont), &defaultGUILogFont);
         if (simpleFont = fontDataFromDescriptionAndLogFont(fontDescription, defaultGUILogFont, fallbackFontName))
+        if (simpleFont = fontFromDescriptionAndLogFont(fontDescription, defaultGUILogFont, fallbackFontName))
             return *simpleFont;
+    }
 …
     nonClientMetrics.cbSize = sizeof(nonClientMetrics);
     if (SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(nonClientMetrics), &nonClientMetrics, 0)) {
         if (simpleFont = fontDataFromDescriptionAndLogFont(fontDescription, nonClientMetrics.lfMessageFont, fallbackFontName))
+        if (simpleFont = fontFromDescriptionAndLogFont(fontDescription, nonClientMetrics.lfMessageFont, fallbackFontName))
             return *simpleFont;
         if (simpleFont = fontDataFromDescriptionAndLogFont(fontDescription, nonClientMetrics.lfMenuFont, fallbackFontName))
+        if (simpleFont = fontFromDescriptionAndLogFont(fontDescription, nonClientMetrics.lfMenuFont, fallbackFontName))
             return *simpleFont;
         if (simpleFont = fontDataFromDescriptionAndLogFont(fontDescription, nonClientMetrics.lfStatusFont, fallbackFontName))
+        if (simpleFont = fontFromDescriptionAndLogFont(fontDescription, nonClientMetrics.lfStatusFont, fallbackFontName))
             return *simpleFont;
         if (simpleFont = fontDataFromDescriptionAndLogFont(fontDescription, nonClientMetrics.lfCaptionFont, fallbackFontName))
+        if (simpleFont = fontFromDescriptionAndLogFont(fontDescription, nonClientMetrics.lfCaptionFont, fallbackFontName))
             return *simpleFont;
         if (simpleFont = fontDataFromDescriptionAndLogFont(fontDescription, nonClientMetrics.lfSmCaptionFont, fallbackFontName))
+        if (simpleFont = fontFromDescriptionAndLogFont(fontDescription, nonClientMetrics.lfSmCaptionFont, fallbackFontName))
             return *simpleFont;
+    }

trunk/Source/WebCore/platform/graphics/win/FontWin.cpp

-              r178510
+              r178940
 #include "FontCascade.h"
+#include "Font.h"
 #include "FontGlyphs.h"
 #include "GlyphBuffer.h"
 …
 #include "LayoutRect.h"
 #include "Logging.h"
-#include "SimpleFontData.h"
 #include "TextRun.h"
 #include "UniscribeController.h"
 …
+}
 float FontCascade::floatWidthForComplexText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
+float FontCascade::floatWidthForComplexText(const TextRun& run, HashSet<const Font*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
+{
     UniscribeController controller(this, run, fallbackFonts);

trunk/Source/WebCore/platform/graphics/win/GlyphPageTreeNodeCGWin.cpp

-              r177876
+              r178940
 #include "GlyphPage.h"
 #include "SimpleFontData.h"
+#include "Font.h"
 #include <WebKitSystemInterface/WebKitSystemInterface.h>
 namespace WebCore {
 bool GlyphPage::fill(unsigned offset, unsigned length, UChar* buffer, unsigned bufferLength, const SimpleFontData* fontData)
+bool GlyphPage::fill(unsigned offset, unsigned length, UChar* buffer, unsigned bufferLength, const Font* fontData)
+{
     // bufferLength will be greater than the requested number of glyphs if the buffer contains surrogate pairs.

trunk/Source/WebCore/platform/graphics/win/GlyphPageTreeNodeCairoWin.cpp

-              r177876
+              r178940
 #include "GlyphPage.h"
+#include "Font.h"
 #include "HWndDC.h"
-#include "SimpleFontData.h"
 namespace WebCore {
 bool GlyphPage::fill(unsigned offset, unsigned length, UChar* buffer, unsigned bufferLength, const SimpleFontData* fontData)
+bool GlyphPage::fill(unsigned offset, unsigned length, UChar* buffer, unsigned bufferLength, const Font* fontData)
+{
     // bufferLength will be greater than the requested number of glyphs if the buffer contains surrogate pairs.

trunk/Source/WebCore/platform/graphics/win/SimpleFontDataCGWin.cpp

r178510	r178940
28	28
29	29	#include "config.h"
30		#include "~~SimpleFontData~~.h"
	30	#include "Font.h"
31	31
32	32	#include "FloatRect.h"
…	…
49	49	using namespace std;
50	50
51		void ~~SimpleFontData~~::platformInit()
	51	void Font::platformInit()
52	52	{
53	53	m_syntheticBoldOffset = m_platformData.syntheticBold() ? 1.0f : 0.f;
…	…
104	104	}
105	105
106		FloatRect ~~SimpleFontData~~::platformBoundsForGlyph(Glyph glyph) const
	106	FloatRect Font::platformBoundsForGlyph(Glyph glyph) const
107	107	{
108	108	if (!platformData().size())
…	…
123	123	}
124	124
125		float ~~SimpleFontData~~::platformWidthForGlyph(Glyph glyph) const
	125	float Font::platformWidthForGlyph(Glyph glyph) const
126	126	{
127	127	if (!platformData().size())

trunk/Source/WebCore/platform/graphics/win/SimpleFontDataCairoWin.cpp

r178510	r178940
28	28
29	29	#include "config.h"
30		#include "~~SimpleFontData~~.h"
	30	#include "Font.h"
31	31
32	32	#include <windows.h>
…	…
42	42	namespace WebCore {
43	43
44		void ~~SimpleFontData~~::platformInit()
	44	void Font::platformInit()
45	45	{
46	46	m_syntheticBoldOffset = m_platformData.syntheticBold() ? 1.0f : 0.f;
…	…
104	104	}
105	105
106		FloatRect ~~SimpleFontData~~::platformBoundsForGlyph(Glyph glyph) const
	106	FloatRect Font::platformBoundsForGlyph(Glyph glyph) const
107	107	{
108	108	if (m_platformData.useGDI())
…	…
112	112	}
113	113
114		float ~~SimpleFontData~~::platformWidthForGlyph(Glyph glyph) const
	114	float Font::platformWidthForGlyph(Glyph glyph) const
115	115	{
116	116	if (m_platformData.useGDI())

trunk/Source/WebCore/platform/graphics/win/SimpleFontDataWin.cpp

r178510	r178940
28	28
29	29	#include "config.h"
30		#include "~~SimpleFontData~~.h"
	30	#include "Font.h"
31	31
32	32	#include "FontCache.h"
…	…
44	44	static bool g_shouldApplyMacAscentHack;
45	45
46		void ~~SimpleFontData~~::setShouldApplyMacAscentHack(bool b)
	46	void Font::setShouldApplyMacAscentHack(bool b)
47	47	{
48	48	g_shouldApplyMacAscentHack = b;
49	49	}
50	50
51		bool ~~SimpleFontData~~::shouldApplyMacAscentHack()
	51	bool Font::shouldApplyMacAscentHack()
52	52	{
53	53	return g_shouldApplyMacAscentHack;
54	54	}
55	55
56		float ~~SimpleFontData~~::ascentConsideringMacAscentHack(const WCHAR* faceName, float ascent, float descent)
	56	float Font::ascentConsideringMacAscentHack(const WCHAR* faceName, float ascent, float descent)
57	57	{
58	58	if (!shouldApplyMacAscentHack())
…	…
72	72	}
73	73
74		void ~~SimpleFontData~~::initGDIFont()
	74	void Font::initGDIFont()
75	75	{
76	76	if (!m_platformData.size()) {
…	…
107	107	}
108	108
109		void ~~SimpleFontData~~::platformCharWidthInit()
	109	void Font::platformCharWidthInit()
110	110	{
111	111	// GDI Fonts init charwidths in initGDIFont.
…	…
117	117	}
118	118
119		void ~~SimpleFontData~~::platformDestroy()
	119	void Font::platformDestroy()
120	120	{
121	121	ScriptFreeCache(&m_scriptCache);
…	…
123	123	}
124	124
125		PassRefPtr<~~SimpleFontData> SimpleFontData::platformCreateScaledFontData~~(const FontDescription& fontDescription, float scaleFactor) const
	125	PassRefPtr<Font> Font::platformCreateScaledFont(const FontDescription& fontDescription, float scaleFactor) const
126	126	{
127	127	float scaledSize = scaleFactor * m_platformData.size();
…	…
129	129	FontPlatformData scaledFont(m_platformData);
130	130	scaledFont.setSize(scaledSize);
131		return ~~SimpleFontData~~::create(scaledFont, true, false);
	131	return Font::create(scaledFont, true, false);
132	132	}
133	133
…	…
136	136	winfont.lfHeight = -lroundf(scaledSize * (m_platformData.useGDI() ? 1 : 32));
137	137	auto hfont = adoptGDIObject(::CreateFontIndirect(&winfont));
138		return ~~SimpleFontData~~::create(FontPlatformData(WTF::move(hfont), scaledSize, m_platformData.syntheticBold(), m_platformData.syntheticOblique(), m_platformData.useGDI()), isCustomFont(), false);
139		}
140
141		void ~~SimpleFontData~~::determinePitch()
	138	return Font::create(FontPlatformData(WTF::move(hfont), scaledSize, m_platformData.syntheticBold(), m_platformData.syntheticOblique(), m_platformData.useGDI()), isCustomFont(), false);
	139	}
	140
	141	void Font::determinePitch()
142	142	{
143	143	if (isCustomFont()) {
…	…
160	160	}
161	161
162		FloatRect ~~SimpleFontData~~::boundsForGDIGlyph(Glyph glyph) const
	162	FloatRect Font::boundsForGDIGlyph(Glyph glyph) const
163	163	{
164	164	HWndDC hdc(0);
…	…
176	176	}
177	177
178		float ~~SimpleFontData~~::widthForGDIGlyph(Glyph glyph) const
	178	float Font::widthForGDIGlyph(Glyph glyph) const
179	179	{
180	180	HWndDC hdc(0);
…	…
192	192	}
193	193
194		SCRIPT_FONTPROPERTIES* ~~SimpleFontData~~::scriptFontProperties() const
	194	SCRIPT_FONTPROPERTIES* Font::scriptFontProperties() const
195	195	{
196	196	if (!m_scriptFontProperties) {

trunk/Source/WebCore/platform/graphics/win/UniscribeController.cpp

-              r178510
+              r178940
 #include "config.h"
 #include "UniscribeController.h"
+#include "Font.h"
 #include "FontCascade.h"
 #include "HWndDC.h"
-#include "SimpleFontData.h"
 #include "TextRun.h"
 #include <wtf/MathExtras.h>
 …
 // take the GlyphBuffer as an arg so that we don't have to populate the glyph buffer when
 // measuring.
 UniscribeController::UniscribeController(const FontCascade* font, const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts)
+UniscribeController::UniscribeController(const FontCascade* font, const TextRun& run, HashSet<const Font*>* fallbackFonts)
     : m_font(*font)
     , m_run(run)
 …
     const UChar* end = m_run.rtl() ? cp - 1 : cp + length;
     const SimpleFontData* fontData;
     const SimpleFontData* nextFontData = m_font.glyphDataForCharacter(*curr, false).fontData;
+    const Font* fontData;
+    const Font* nextFontData = m_font.glyphDataForCharacter(*curr, false).font;
     UChar newC = 0;
 …
         bool forceSmallCaps = isSmallCaps && (U_GET_GC_MASK(c) & U_GC_M_MASK);
         nextFontData = m_font.glyphDataForCharacter(*curr, false, forceSmallCaps ? SmallCapsVariant : AutoVariant).fontData;
+        nextFontData = m_font.glyphDataForCharacter(*curr, false, forceSmallCaps ? SmallCapsVariant : AutoVariant).font;
         if (m_font.isSmallCaps()) {
             nextIsSmallCaps = forceSmallCaps || (newC = u_toupper(c)) != c;
 …
+        }
         if (m_fallbackFonts && fontData && nextFontData != fontData && fontData != &m_font.primaryFontData())
+        if (m_fallbackFonts && fontData && nextFontData != fontData && fontData != &m_font.primaryFont())
             m_fallbackFonts->add(fontData);
 …
     int itemLength = m_run.rtl() ? indexOfFontTransition + 1 : length - indexOfFontTransition;
     if (itemLength) {
         if (m_fallbackFonts && nextFontData && nextFontData != &m_font.primaryFontData())
+        if (m_fallbackFonts && nextFontData && nextFontData != &m_font.primaryFont())
             m_fallbackFonts->add(nextFontData);
 …
+}
 void UniscribeController::itemizeShapeAndPlace(const UChar* cp, unsigned length, const SimpleFontData* fontData, GlyphBuffer* glyphBuffer)
+void UniscribeController::itemizeShapeAndPlace(const UChar* cp, unsigned length, const Font* fontData, GlyphBuffer* glyphBuffer)
+{
     // ScriptItemize (in Windows XP versions prior to SP2) can overflow by 1.  This is why there is an extra empty item
 …
+}
 bool UniscribeController::shapeAndPlaceItem(const UChar* cp, unsigned i, const SimpleFontData* fontData, GlyphBuffer* glyphBuffer)
+bool UniscribeController::shapeAndPlaceItem(const UChar* cp, unsigned i, const Font* fontData, GlyphBuffer* glyphBuffer)
+{
     // Determine the string for this item.
 …
+}
 bool UniscribeController::shape(const UChar* str, int len, SCRIPT_ITEM item, const SimpleFontData* fontData,
+bool UniscribeController::shape(const UChar* str, int len, SCRIPT_ITEM item, const Font* fontData,
                                 Vector<WORD>& glyphs, Vector<WORD>& clusters,
                                 Vector<SCRIPT_VISATTR>& visualAttributes)

trunk/Source/WebCore/platform/graphics/win/UniscribeController.h

-              r178510
+              r178940
 class UniscribeController {
 public:
     UniscribeController(const FontCascade*, const TextRun&, HashSet<const SimpleFontData*>* fallbackFonts = 0);
+    UniscribeController(const FontCascade*, const TextRun&, HashSet<const Font*>* fallbackFonts = 0);
     // Advance and measure/place up to the specified character.
 …
     void resetControlAndState();
     void itemizeShapeAndPlace(const UChar*, unsigned length, const SimpleFontData*, GlyphBuffer*);
     bool shapeAndPlaceItem(const UChar*, unsigned index, const SimpleFontData*, GlyphBuffer*);
     bool shape(const UChar* str, int len, SCRIPT_ITEM item, const SimpleFontData* fontData,
+    void itemizeShapeAndPlace(const UChar*, unsigned length, const Font*, GlyphBuffer*);
+    bool shapeAndPlaceItem(const UChar*, unsigned index, const Font*, GlyphBuffer*);
+    bool shape(const UChar* str, int len, SCRIPT_ITEM, const Font*,
                Vector<WORD>& glyphs, Vector<WORD>& clusters,
                Vector<SCRIPT_VISATTR>& visualAttributes);
 …
     const FontCascade& m_font;
     const TextRun& m_run;
     HashSet<const SimpleFontData*>* m_fallbackFonts;
+    HashSet<const Font*>* m_fallbackFonts;
     FloatPoint m_glyphOrigin;
     float m_minGlyphBoundingBoxX;

trunk/Source/WebCore/platform/win/PopupMenuWin.cpp

-              r178520
+              r178940
 #include "Document.h"
 #include "FloatRect.h"
+#include "Font.h"
 #include "FontSelector.h"
 #include "Frame.h"
 …
 #include "Scrollbar.h"
 #include "ScrollbarTheme.h"
-#include "SimpleFontData.h"
 #include "TextRun.h"
 #include "WebCoreInstanceHandle.h"

trunk/Source/WebCore/rendering/InlineFlowBox.cpp

-              r178510
+              r178940
     const RenderStyle& lineStyle = this->lineStyle();
     if (lineStyle.fontDescription().nonCJKGlyphOrientation() == NonCJKGlyphOrientationUpright
         || lineStyle.fontCascade().primaryFontData().hasVerticalGlyphs())
+        || lineStyle.fontCascade().primaryFont().hasVerticalGlyphs())
         return true;
 …
                 return true;
         } else {
             if (child->lineStyle().fontCascade().primaryFontData().hasVerticalGlyphs())
+            if (child->lineStyle().fontCascade().primaryFont().hasVerticalGlyphs())
                 return true;
             const Vector<const SimpleFontData*>* usedFonts = nullptr;
+            const Vector<const Font*>* usedFonts = nullptr;
             if (is<InlineTextBox>(*child)) {
                 GlyphOverflowAndFallbackFontsMap::const_iterator it = textBoxDataMap.find(downcast<InlineTextBox>(child));
 …
             if (usedFonts) {
                 for (const SimpleFontData* fontData : *usedFonts) {
                     if (fontData->hasVerticalGlyphs())
+                for (const Font* font : *usedFonts) {
+                    if (font->hasVerticalGlyphs())
                         return true;
+                }

trunk/Source/WebCore/rendering/InlineFlowBox.h

-              r176354
+              r178940
 class InlineTextBox;
 class RenderLineBoxList;
 class SimpleFontData;
+class Font;
 class VerticalPositionCache;
 struct GlyphOverflow;
 typedef HashMap<const InlineTextBox*, std::pair<Vector<const SimpleFontData*>, GlyphOverflow>> GlyphOverflowAndFallbackFontsMap;
+typedef HashMap<const InlineTextBox*, std::pair<Vector<const Font*>, GlyphOverflow>> GlyphOverflowAndFallbackFontsMap;
 class InlineFlowBox : public InlineBox {

trunk/Source/WebCore/rendering/InlineTextBox.cpp

r178510	r178940
1382	1382	TextRun run(string, textPos(), expansion(), expansionBehavior(), direction(), dirOverride() \|\| style.rtlOrdering() == VisualOrder, !renderer().canUseSimpleFontCodePath());
1383	1383	run.setTabSize(!style.collapseWhiteSpace(), style.tabSize());
1384		if (font.primaryFont~~Data~~().isSVGFont())
	1384	if (font.primaryFont().isSVGFont())
1385	1385	run.setRenderingContext(SVGTextRunRenderingContext::create(renderer()));
1386	1386

trunk/Source/WebCore/rendering/RenderBlock.cpp

-              r178822
+              r178940
     // FIXME: Should letter-spacing apply? This is complicated since it doesn't apply at the edge?
     float maxCharWidth = lineGrid->style().fontCascade().primaryFontData().maxCharWidth();
+    float maxCharWidth = lineGrid->style().fontCascade().primaryFont().maxCharWidth();
     if (!maxCharWidth)
         return left;
 …
     // FIXME: Should letter-spacing apply? This is complicated since it doesn't apply at the edge?
     float maxCharWidth = lineGrid->style().fontCascade().primaryFontData().maxCharWidth();
+    float maxCharWidth = lineGrid->style().fontCascade().primaryFont().maxCharWidth();
     if (!maxCharWidth)
         return right;
 …
     TextRun run(characters, length, 0, 0, expansion, textDirection, directionalOverride);
     if (font.primaryFontData().isSVGFont()) {
+    if (font.primaryFont().isSVGFont()) {
         ASSERT(context); // FIXME: Thread a RenderObject& to this point so we don't have to dereference anything.
         run.setRenderingContext(SVGTextRunRenderingContext::create(*context));
 …
+    }
     TextRun run(characters, length, 0, 0, expansion, textDirection, directionalOverride);
     if (font.primaryFontData().isSVGFont()) {
+    if (font.primaryFont().isSVGFont()) {
         ASSERT(context); // FIXME: Thread a RenderObject& to this point so we don't have to dereference anything.
         run.setRenderingContext(SVGTextRunRenderingContext::create(*context));

trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp

-              r178510
+              r178940
     GlyphOverflowAndFallbackFontsMap& textBoxDataMap, VerticalPositionCache& verticalPositionCache, WordMeasurements& wordMeasurements)
+{
     HashSet<const SimpleFontData*> fallbackFonts;
+    HashSet<const Font*> fallbackFonts;
     GlyphOverflow glyphOverflow;
 …
                 measuredWidth += wordMeasurement.width;
             if (!wordMeasurement.fallbackFonts.isEmpty()) {
                 HashSet<const SimpleFontData*>::const_iterator end = wordMeasurement.fallbackFonts.end();
                 for (HashSet<const SimpleFontData*>::const_iterator it = wordMeasurement.fallbackFonts.begin(); it != end; ++it)
+                HashSet<const Font*>::const_iterator end = wordMeasurement.fallbackFonts.end();
+                for (HashSet<const Font*>::const_iterator it = wordMeasurement.fallbackFonts.begin(); it != end; ++it)
                     fallbackFonts.add(*it);
+            }
 …
     if (!fallbackFonts.isEmpty()) {
         ASSERT(run->box()->behavesLikeText());
         GlyphOverflowAndFallbackFontsMap::iterator it = textBoxDataMap.add(downcast<InlineTextBox>(run->box()), std::make_pair(Vector<const SimpleFontData*>(), GlyphOverflow())).iterator;
+        GlyphOverflowAndFallbackFontsMap::iterator it = textBoxDataMap.add(downcast<InlineTextBox>(run->box()), std::make_pair(Vector<const Font*>(), GlyphOverflow())).iterator;
         ASSERT(it->value.first.isEmpty());
         copyToVector(fallbackFonts, it->value.first);
 …
     if (!glyphOverflow.isEmpty()) {
         ASSERT(run->box()->behavesLikeText());
         GlyphOverflowAndFallbackFontsMap::iterator it = textBoxDataMap.add(downcast<InlineTextBox>(run->box()), std::make_pair(Vector<const SimpleFontData*>(), GlyphOverflow())).iterator;
+        GlyphOverflowAndFallbackFontsMap::iterator it = textBoxDataMap.add(downcast<InlineTextBox>(run->box()), std::make_pair(Vector<const Font*>(), GlyphOverflow())).iterator;
         it->value.second = glyphOverflow;
         run->box()->clearKnownToHaveNoOverflow();

trunk/Source/WebCore/rendering/RenderCombineText.cpp

r178510	r178940
58	58	}
59	59
60		float RenderCombineText::width(unsigned from, unsigned length, const FontCascade& font, float xPosition, HashSet<const ~~SimpleFontData~~> fallbackFonts, GlyphOverflow* glyphOverflow) const
	60	float RenderCombineText::width(unsigned from, unsigned length, const FontCascade& font, float xPosition, HashSet<const Font> fallbackFonts, GlyphOverflow* glyphOverflow) const
61	61	{
62	62	if (m_isCombined)

trunk/Source/WebCore/rendering/RenderCombineText.h

r178510	r178940
47	47
48	48	virtual bool isCombineText() const override { return true; }
49		virtual float width(unsigned from, unsigned length, const FontCascade&, float xPosition, HashSet<const ~~SimpleFontData~~> fallbackFonts = 0, GlyphOverflow* = 0) const override;
	49	virtual float width(unsigned from, unsigned length, const FontCascade&, float xPosition, HashSet<const Font> fallbackFonts = 0, GlyphOverflow* = 0) const override;
50	50	virtual const char* renderName() const override { return "RenderCombineText"; }
51	51	virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;

trunk/Source/WebCore/rendering/RenderSearchField.cpp

-              r178510
+              r178940
 #include "CSSValueKeywords.h"
 #include "Chrome.h"
+#include "Font.h"
 #include "Frame.h"
 #include "FrameSelection.h"
 …
 #include "SearchPopupMenu.h"
 #include "Settings.h"
-#include "SimpleFontData.h"
 #include "StyleResolver.h"
 #include "TextControlInnerElements.h"

trunk/Source/WebCore/rendering/RenderText.cpp

r178510	r178940
452	452	}
453	453
454		ALWAYS_INLINE float RenderText::widthFromCache(const FontCascade& f, int start, int len, float xPos, HashSet<const ~~SimpleFontData~~> fallbackFonts, GlyphOverflow* glyphOverflow, const RenderStyle& style) const
	454	ALWAYS_INLINE float RenderText::widthFromCache(const FontCascade& f, int start, int len, float xPos, HashSet<const Font> fallbackFonts, GlyphOverflow* glyphOverflow, const RenderStyle& style) const
455	455	{
456	456	if (style.hasTextCombine() && is<RenderCombineText>(*this)) {
…	…
631	631	void RenderText::computePreferredLogicalWidths(float leadWidth)
632	632	{
633		HashSet<const ~~SimpleFontData~~*> fallbackFonts;
	633	HashSet<const Font*> fallbackFonts;
634	634	GlyphOverflow glyphOverflow;
635	635	computePreferredLogicalWidths(leadWidth, fallbackFonts, glyphOverflow);
…	…
644	644	}
645	645
646		static float maxWordFragmentWidth(RenderText* renderer, const RenderStyle& style, const FontCascade& font, StringView word, int minimumPrefixLength, unsigned minimumSuffixLength, int& suffixStart, HashSet<const ~~SimpleFontData~~*>& fallbackFonts, GlyphOverflow& glyphOverflow)
	646	static float maxWordFragmentWidth(RenderText* renderer, const RenderStyle& style, const FontCascade& font, StringView word, int minimumPrefixLength, unsigned minimumSuffixLength, int& suffixStart, HashSet<const Font*>& fallbackFonts, GlyphOverflow& glyphOverflow)
647	647	{
648	648	suffixStart = 0;
…	…
684	684	}
685	685
686		void RenderText::computePreferredLogicalWidths(float leadWidth, HashSet<const ~~SimpleFontData~~*>& fallbackFonts, GlyphOverflow& glyphOverflow)
	686	void RenderText::computePreferredLogicalWidths(float leadWidth, HashSet<const Font*>& fallbackFonts, GlyphOverflow& glyphOverflow)
687	687	{
688	688	ASSERT(m_hasTab \|\| preferredLogicalWidthsDirty() \|\| !m_knownToHaveNoOverflowAndNoFallbackFonts);
…	…
1207	1207	}
1208	1208
1209		float RenderText::width(unsigned from, unsigned len, float xPos, bool firstLine, HashSet<const ~~SimpleFontData~~> fallbackFonts, GlyphOverflow* glyphOverflow) const
	1209	float RenderText::width(unsigned from, unsigned len, float xPos, bool firstLine, HashSet<const Font> fallbackFonts, GlyphOverflow* glyphOverflow) const
1210	1210	{
1211	1211	if (from >= textLength())
…	…
1219	1219	}
1220	1220
1221		float RenderText::width(unsigned from, unsigned len, const FontCascade& f, float xPos, HashSet<const ~~SimpleFontData~~> fallbackFonts, GlyphOverflow* glyphOverflow) const
	1221	float RenderText::width(unsigned from, unsigned len, const FontCascade& f, float xPos, HashSet<const Font> fallbackFonts, GlyphOverflow* glyphOverflow) const
1222	1222	{
1223	1223	ASSERT(from + len <= textLength());

trunk/Source/WebCore/rendering/RenderText.h

-              r178510
+              r178940
     void positionLineBox(InlineTextBox&);
     virtual float width(unsigned from, unsigned len, const FontCascade&, float xPos, HashSet<const SimpleFontData*>* fallbackFonts = 0, GlyphOverflow* = 0) const;
     virtual float width(unsigned from, unsigned len, float xPos, bool firstLine = false, HashSet<const SimpleFontData*>* fallbackFonts = 0, GlyphOverflow* = 0) const;
+    virtual float width(unsigned from, unsigned len, const FontCascade&, float xPos, HashSet<const Font*>* fallbackFonts = 0, GlyphOverflow* = 0) const;
+    virtual float width(unsigned from, unsigned len, float xPos, bool firstLine = false, HashSet<const Font*>* fallbackFonts = 0, GlyphOverflow* = 0) const;
     float minLogicalWidth() const;
 …
     virtual bool canHaveChildren() const override final { return false; }
     void computePreferredLogicalWidths(float leadWidth, HashSet<const SimpleFontData*>& fallbackFonts, GlyphOverflow&);
+    void computePreferredLogicalWidths(float leadWidth, HashSet<const Font*>& fallbackFonts, GlyphOverflow&);
     bool computeCanUseSimpleFontCodePath() const;
 …
     bool containsOnlyWhitespace(unsigned from, unsigned len) const;
     float widthFromCache(const FontCascade&, int start, int len, float xPos, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow*, const RenderStyle&) const;
+    float widthFromCache(const FontCascade&, int start, int len, float xPos, HashSet<const Font*>* fallbackFonts, GlyphOverflow*, const RenderStyle&) const;
     bool isAllASCII() const { return m_isAllASCII; }
     bool computeUseBackslashAsYenSymbol() const;

trunk/Source/WebCore/rendering/RenderTextControlSingleLine.cpp

-              r178510
+              r178940
 #include "CSSValueKeywords.h"
 #include "Chrome.h"
+#include "Font.h"
 #include "Frame.h"
 #include "FrameSelection.h"
 …
 #include "RenderView.h"
 #include "Settings.h"
-#include "SimpleFontData.h"
 #include "StyleResolver.h"
 #include "TextControlInnerElements.h"
 …
         maxCharWidth = scaleEmToUnits(4027);
     else if (style().fontCascade().hasValidAverageCharWidth())
         maxCharWidth = roundf(style().fontCascade().primaryFontData().maxCharWidth());
+        maxCharWidth = roundf(style().fontCascade().primaryFont().maxCharWidth());
 #endif

trunk/Source/WebCore/rendering/RenderThemeIOS.mm

r178510	r178940
581	581
582	582	RenderObject* renderer = inputElement.renderer();
583		if (font.primaryFont~~Data~~().isSVGFont() && !renderer)
	583	if (font.primaryFont().isSVGFont() && !renderer)
584	584	return;
585	585

trunk/Source/WebCore/rendering/RootInlineBox.cpp

-              r178510
+              r178940
+    }
     Vector<const SimpleFontData*>* usedFonts = nullptr;
+    Vector<const Font*>* usedFonts = nullptr;
     GlyphOverflow* glyphOverflow = nullptr;
     if (is<InlineTextBox>(box)) {
 …
     const RenderStyle& boxLineStyle = box.lineStyle();
     if (usedFonts && !usedFonts->isEmpty() && (includeFont || (boxLineStyle.lineHeight().isNegative() && includeLeading))) {
         usedFonts->append(&boxLineStyle.fontCascade().primaryFontData());
+        usedFonts->append(&boxLineStyle.fontCascade().primaryFont());
         for (size_t i = 0; i < usedFonts->size(); ++i) {
             const FontMetrics& fontMetrics = usedFonts->at(i)->fontMetrics();

trunk/Source/WebCore/rendering/SimpleLineLayout.cpp

-              r178939
+              r178940
 template <typename CharacterType>
 static bool canUseForText(const CharacterType* text, unsigned length, const SimpleFontData& fontData)
+static bool canUseForText(const CharacterType* text, unsigned length, const Font& font)
+{
     // FIXME: <textarea maxlength=0> generates empty text node.
 …
             return false;
         if (!fontData.glyphForCharacter(character))
+        if (!font.glyphForCharacter(character))
             return false;
+    }
 …
+}
 static bool canUseForText(const RenderText& textRenderer, const SimpleFontData& fontData)
+static bool canUseForText(const RenderText& textRenderer, const Font& font)
+{
     if (textRenderer.is8Bit())
         return canUseForText(textRenderer.characters8(), textRenderer.textLength(), fontData);
     return canUseForText(textRenderer.characters16(), textRenderer.textLength(), fontData);
+        return canUseForText(textRenderer.characters8(), textRenderer.textLength(), font);
+    return canUseForText(textRenderer.characters16(), textRenderer.textLength(), font);
+}
 …
+        }
+    }
     if (style.fontCascade().primaryFontData().isSVGFont())
+    if (style.fontCascade().primaryFont().isSVGFont())
         return false;
     // We assume that all lines have metrics based purely on the primary font.
     auto& primaryFontData = style.fontCascade().primaryFontData();
     if (primaryFontData.isLoading())
+    auto& primaryFont = style.fontCascade().primaryFont();
+    if (primaryFont.isLoading())
         return false;
     for (const auto& textRenderer : childrenOfType<RenderText>(flow)) {
 …
         if (style.fontCascade().codePath(TextRun(textRenderer.text())) != FontCascade::Simple)
             return false;
         if (!canUseForText(textRenderer, primaryFontData))
+        if (!canUseForText(textRenderer, primaryFont))
             return false;
+    }

trunk/Source/WebCore/rendering/line/BreakingContextInlineHeaders.h

-              r178510
+              r178940
     int startOffset;
     int endOffset;
     HashSet<const SimpleFontData*> fallbackFonts;
+    HashSet<const Font*> fallbackFonts;
 };
 …
+}
 inline float measureHyphenWidth(RenderText* renderer, const FontCascade& font, HashSet<const SimpleFontData*>* fallbackFonts = 0)
+inline float measureHyphenWidth(RenderText* renderer, const FontCascade& font, HashSet<const Font*>* fallbackFonts = 0)
+{
     const RenderStyle& style = renderer->style();
 …
+}
 ALWAYS_INLINE float textWidth(RenderText* text, unsigned from, unsigned len, const FontCascade& font, float xPos, bool isFixedPitch, bool collapseWhiteSpace, HashSet<const SimpleFontData*>& fallbackFonts, TextLayout* layout = 0)
+ALWAYS_INLINE float textWidth(RenderText* text, unsigned from, unsigned len, const FontCascade& font, float xPos, bool isFixedPitch, bool collapseWhiteSpace, HashSet<const Font*>& fallbackFonts, TextLayout* layout = 0)
+{
     const RenderStyle& style = text->style();
 …
 #if !ASSERT_DISABLED
     HashSet<const SimpleFontData*> fallbackFonts;
+    HashSet<const Font*> fallbackFonts;
     float prefixWidth = hyphenWidth + textWidth(text, lastSpace, prefixLength, font, xPos, isFixedPitch, collapseWhiteSpace, fallbackFonts) + lastSpaceWordSpacing;
     ASSERT(xPos + prefixWidth <= availableWidth);
 …
     // Non-zero only when kerning is enabled and TextLayout isn't used, in which case we measure
     // words with their trailing space, then subtract its width.
     HashSet<const SimpleFontData*> fallbackFonts;
+    HashSet<const Font*> fallbackFonts;
     float wordTrailingSpaceWidth = (font.typesettingFeatures() & Kerning) && !textLayout ? font.width(RenderBlock::constructTextRun(&renderText, font, &space, 1, style), &fallbackFonts) + wordSpacing : 0;

trunk/Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp

-              r178510
+              r178940
 FloatRect RenderMathMLOperator::boundsForGlyph(const GlyphData& data) const
+{
     return data.fontData->boundsForGlyph(data.glyph);
+    return data.font->boundsForGlyph(data.glyph);
+}
 …
 float RenderMathMLOperator::advanceForGlyph(const GlyphData& data) const
+{
     return data.fontData->widthForGlyph(data.glyph);
+    return data.font->widthForGlyph(data.glyph);
+}
 …
         bottom.glyph = extension.glyph;
     top.fontData = &style().fontCascade().primaryFontData();
     extension.fontData = top.fontData;
     bottom.fontData = top.fontData;
+    top.font = &style().fontCascade().primaryFont();
+    extension.font = top.font;
+    bottom.font = top.font;
     if (middle.glyph)
         middle.fontData = top.fontData;
+        middle.font = top.font;
     stretchyData.setGlyphAssemblyMode(top, extension, bottom, middle);
 …
     ASSERT(m_isVertical && isLargeOperatorInDisplayStyle());
     const auto& primaryFontData = style().fontCascade().primaryFontData();
+    const auto& primaryFont = style().fontCascade().primaryFont();
     GlyphData baseGlyph = style().fontCascade().glyphDataForCharacter(character, !style().isLeftToRightDirection());
     if (!primaryFontData.mathData() || baseGlyph.fontData != &primaryFontData)
+    if (!primaryFont.mathData() || baseGlyph.font != &primaryFont)
         return data;
 …
     // The value of displayOperatorMinHeight is sometimes too small, so we ensure that it is at least \sqrt{2} times the size of the base glyph.
     float displayOperatorMinHeight = std::max(baseGlyph.fontData->boundsForGlyph(baseGlyph.glyph).height() * sqrtOfTwoFloat, primaryFontData.mathData()->getMathConstant(primaryFontData, OpenTypeMathData::DisplayOperatorMinHeight));
     primaryFontData.mathData()->getMathVariants(baseGlyph.glyph, true, sizeVariants, assemblyParts);
+    float displayOperatorMinHeight = std::max(baseGlyph.font->boundsForGlyph(baseGlyph.glyph).height() * sqrtOfTwoFloat, primaryFont.mathData()->getMathConstant(primaryFont, OpenTypeMathData::DisplayOperatorMinHeight));
+    primaryFont.mathData()->getMathVariants(baseGlyph.glyph, true, sizeVariants, assemblyParts);
     // We choose the first size variant that is larger than the expected displayOperatorMinHeight and otherwise fallback to the largest variant.
 …
         GlyphData sizeVariant;
         sizeVariant.glyph = variant;
         sizeVariant.fontData = &primaryFontData;
+        sizeVariant.font = &primaryFont;
         data.setSizeVariantMode(sizeVariant);
         if (boundsForGlyph(sizeVariant).height() >= displayOperatorMinHeight)
 …
     StretchyData assemblyData;
     const auto& primaryFontData = style().fontCascade().primaryFontData();
+    const auto& primaryFont = style().fontCascade().primaryFont();
     GlyphData baseGlyph = style().fontCascade().glyphDataForCharacter(character, !style().isLeftToRightDirection());
     if (primaryFontData.mathData() && baseGlyph.fontData == &primaryFontData) {
+    if (primaryFont.mathData() && baseGlyph.font == &primaryFont) {
         Vector<Glyph> sizeVariants;
         Vector<OpenTypeMathData::AssemblyPart> assemblyParts;
         primaryFontData.mathData()->getMathVariants(baseGlyph.glyph, m_isVertical, sizeVariants, assemblyParts);
+        primaryFont.mathData()->getMathVariants(baseGlyph.glyph, m_isVertical, sizeVariants, assemblyParts);
         // We verify the size variants.
         for (auto& variant : sizeVariants) {
             GlyphData sizeVariant;
             sizeVariant.glyph = variant;
             sizeVariant.fontData = &primaryFontData;
+            sizeVariant.font = &primaryFont;
             if (maximumGlyphWidth)
                 *maximumGlyphWidth = std::max(*maximumGlyphWidth, advanceForGlyph(sizeVariant));
 …
     GlyphBuffer buffer;
     buffer.add(data.glyph, data.fontData, advanceForGlyph(data));
     info.context->drawGlyphs(style().fontCascade(), *data.fontData, buffer, 0, 1, origin);
+    buffer.add(data.glyph, data.font, advanceForGlyph(data));
+    info.context->drawGlyphs(style().fontCascade(), *data.font, buffer, 0, 1, origin);
     return glyphPaintRect;
 …
         ASSERT(m_stretchyData.variant().glyph);
         GlyphBuffer buffer;
         buffer.add(m_stretchyData.variant().glyph, m_stretchyData.variant().fontData, advanceForGlyph(m_stretchyData.variant()));
+        buffer.add(m_stretchyData.variant().glyph, m_stretchyData.variant().font, advanceForGlyph(m_stretchyData.variant()));
         LayoutPoint operatorTopLeft = ceiledIntPoint(paintOffset + location());
         FloatRect glyphBounds = boundsForGlyph(m_stretchyData.variant());
         LayoutPoint operatorOrigin(operatorTopLeft.x(), operatorTopLeft.y() - glyphBounds.y());
         info.context->drawGlyphs(style().fontCascade(), *m_stretchyData.variant().fontData, buffer, 0, 1, operatorOrigin);
+        info.context->drawGlyphs(style().fontCascade(), *m_stretchyData.variant().font, buffer, 0, 1, operatorOrigin);
         return;
+    }
 …
 LayoutUnit RenderMathMLOperator::trailingSpaceError()
+{
     const auto& primaryFontData = style().fontCascade().primaryFontData();
     if (!primaryFontData.mathData())
+    const auto& primaryFont = style().fontCascade().primaryFont();
+    if (!primaryFont.mathData())
         return 0;

trunk/Source/WebCore/rendering/mathml/RenderMathMLOperator.h

-              r177259
+              r178940
 #if ENABLE(MATHML)
+#include "Font.h"
 #include "GlyphPage.h"
 #include "MathMLElement.h"
 #include "OpenTypeMathData.h"
 #include "RenderMathMLToken.h"
-#include "SimpleFontData.h"
 namespace WebCore {

trunk/Source/WebCore/rendering/mathml/RenderMathMLRadicalOperator.cpp

-              r178510
+              r178940
 void RenderMathMLRadicalOperator::stretchTo(LayoutUnit heightAboveBaseline, LayoutUnit depthBelowBaseline)
+{
     if (!style().fontCascade().primaryFontData().mathData()) {
+    if (!style().fontCascade().primaryFont().mathData()) {
         // If we do not have an OpenType MATH font, we always make the radical depth a bit larger than the target.
         depthBelowBaseline += gRadicalBottomPointLower;
 …
     ASSERT(preferredLogicalWidthsDirty());
     if (style().fontCascade().primaryFontData().mathData()) {
+    if (style().fontCascade().primaryFont().mathData()) {
         RenderMathMLOperator::computePreferredLogicalWidths();
         return;
 …
 void RenderMathMLRadicalOperator::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const
+{
     if (style().fontCascade().primaryFontData().mathData()) {
+    if (style().fontCascade().primaryFont().mathData()) {
         RenderMathMLOperator::computeLogicalHeight(logicalHeight, logicalTop, computedValues);
         return;
 …
         return;
     if (style().fontCascade().primaryFontData().mathData()) {
+    if (style().fontCascade().primaryFont().mathData()) {
         RenderMathMLOperator::paint(info, paintOffset);
         return;

trunk/Source/WebCore/rendering/mathml/RenderMathMLRoot.cpp

-              r178510
+              r178940
     m_degreeBottomRaisePercent = 0.6f;
     const auto& primaryFontData = style().fontCascade().primaryFontData();
     if (auto* mathData = style().fontCascade().primaryFontData().mathData()) {
+    const auto& primaryFont = style().fontCascade().primaryFont();
+    if (auto* mathData = style().fontCascade().primaryFont().mathData()) {
         // FIXME: m_verticalGap should use RadicalDisplayStyleVertical in display mode (https://bugs.webkit.org/show_bug.cgi?id=118737).
         m_verticalGap = mathData->getMathConstant(primaryFontData, OpenTypeMathData::RadicalVerticalGap);
         m_ruleThickness = mathData->getMathConstant(primaryFontData, OpenTypeMathData::RadicalRuleThickness);
         m_extraAscender = mathData->getMathConstant(primaryFontData, OpenTypeMathData::RadicalExtraAscender);
+        m_verticalGap = mathData->getMathConstant(primaryFont, OpenTypeMathData::RadicalVerticalGap);
+        m_ruleThickness = mathData->getMathConstant(primaryFont, OpenTypeMathData::RadicalRuleThickness);
+        m_extraAscender = mathData->getMathConstant(primaryFont, OpenTypeMathData::RadicalExtraAscender);
         if (!isRenderMathMLSquareRoot()) {
             kernBeforeDegree = mathData->getMathConstant(primaryFontData, OpenTypeMathData::RadicalKernBeforeDegree);
             kernAfterDegree = mathData->getMathConstant(primaryFontData, OpenTypeMathData::RadicalKernAfterDegree);
             m_degreeBottomRaisePercent = mathData->getMathConstant(primaryFontData, OpenTypeMathData::RadicalDegreeBottomRaisePercent);
+            kernBeforeDegree = mathData->getMathConstant(primaryFont, OpenTypeMathData::RadicalKernBeforeDegree);
+            kernAfterDegree = mathData->getMathConstant(primaryFont, OpenTypeMathData::RadicalKernAfterDegree);
+            m_degreeBottomRaisePercent = mathData->getMathConstant(primaryFont, OpenTypeMathData::RadicalDegreeBottomRaisePercent);
+        }
+    }

trunk/Source/WebCore/rendering/style/RenderStyle.cpp

r178510	r178940
1185	1185	DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, hyphenMinusString, (&hyphenMinus, 1));
1186	1186	DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, hyphenString, (&hyphen, 1));
1187		return fontCascade().primaryFont~~Data~~().glyphForCharacter(hyphen) ? hyphenString : hyphenMinusString;
	1187	return fontCascade().primaryFont().glyphForCharacter(hyphen) ? hyphenString : hyphenMinusString;
1188	1188	}
1189	1189

trunk/Source/WebCore/rendering/svg/RenderSVGText.cpp

-              r178250
+              r178940
 #include "FloatQuad.h"
+#include "Font.h"
 #include "GraphicsContext.h"
 #include "HitTestRequest.h"
 …
 #include "SVGTransformList.h"
 #include "SVGURIReference.h"
-#include "SimpleFontData.h"
 #include "TransformState.h"
 #include "VisiblePosition.h"

trunk/Source/WebCore/rendering/svg/SVGInlineTextBox.cpp

r178510	r178940
420	420	, dirOverride() \|\| style->rtlOrdering() == VisualOrder /* directionalOverride */);
421	421
422		if (style->fontCascade().primaryFont~~Data~~().isSVGFont())
	422	if (style->fontCascade().primaryFont().isSVGFont())
423	423	run.setRenderingContext(SVGTextRunRenderingContext::create(renderer()));
424	424

trunk/Source/WebCore/rendering/svg/SVGTextLayoutEngineSpacing.cpp

-              r178510
+              r178940
+{
 #if ENABLE(SVG_FONTS)
     const SimpleFontData& fontData = m_font.primaryFontData();
     if (!fontData.isSVGFont()) {
+    const Font& font = m_font.primaryFont();
+    if (!font.isSVGFont()) {
         m_lastGlyph.isValid = false;
         return 0;
+    }
     ASSERT(fontData.isCustomFont());
     ASSERT(fontData.isSVGFont());
+    ASSERT(font.isCustomFont());
+    ASSERT(font.isSVGFont());
     auto* svgFontData = static_cast<const SVGFontData*>(fontData.svgData());
+    auto* svgFontData = static_cast<const SVGFontData*>(font.svgData());
     SVGFontFaceElement* svgFontFace = svgFontData->svgFontFaceElement();
     ASSERT(svgFontFace);

trunk/Source/WebCore/rendering/svg/SVGTextMetrics.cpp

-              r178510
+              r178940
                 , isOverride(style.unicodeBidi()) /* directionalOverride */);
     if (style.fontCascade().primaryFontData().isSVGFont())
+    if (style.fontCascade().primaryFont().isSVGFont())
         run.setRenderingContext(SVGTextRunRenderingContext::create(text));
 …
 SVGTextMetrics::SVGTextMetrics(RenderSVGInlineText& text, unsigned position, unsigned length, float width, const String& glyphName)
+{
     bool needsContext = text.style().fontCascade().primaryFontData().isSVGFont();
+    bool needsContext = text.style().fontCascade().primaryFont().isSVGFont();
     float scalingFactor = text.scalingFactor();
     ASSERT(scalingFactor);

trunk/Source/WebCore/rendering/svg/SVGTextRunRenderingContext.cpp

-              r178510
+              r178940
 namespace WebCore {
 static inline const SVGFontData* svgFontAndFontFaceElementForFontData(const SimpleFontData* fontData, SVGFontFaceElement*& fontFace, SVGFontElement*& font)
+{
     ASSERT(fontData);
     ASSERT(fontData->isCustomFont());
     ASSERT(fontData->isSVGFont());
     auto* svgFontData = static_cast<const SVGFontData*>(fontData->svgData());
     fontFace = svgFontData->svgFontFaceElement();
     ASSERT(fontFace);
     font = fontFace->associatedFontElement();
+static inline const SVGFontData* svgFontAndFontFaceElementForFontData(const Font* font, SVGFontFaceElement*& svgFontFaceElement, SVGFontElement*& svgFontElement)
+{
+    ASSERT(font);
+    ASSERT(font->isCustomFont());
+    ASSERT(font->isSVGFont());
+    auto* svgFontData = static_cast<const SVGFontData*>(font->svgData());
+    svgFontFaceElement = svgFontData->svgFontFaceElement();
+    ASSERT(svgFontFaceElement);
+    svgFontElement = svgFontFaceElement->associatedFontElement();
     return svgFontData;
+}
 …
+}
 bool SVGTextRunRenderingContext::applySVGKerning(const SimpleFontData* fontData, WidthIterator& iterator, GlyphBuffer* glyphBuffer, int from) const
+bool SVGTextRunRenderingContext::applySVGKerning(const Font* font, WidthIterator& iterator, GlyphBuffer* glyphBuffer, int from) const
+{
     ASSERT(glyphBuffer);
 …
     SVGFontFaceElement* fontFaceElement = 0;
     svgFontAndFontFaceElementForFontData(fontData, fontFaceElement, fontElement);
+    svgFontAndFontFaceElementForFontData(font, fontFaceElement, fontElement);
     if (!fontElement || !fontFaceElement)
         return false;
 …
         return true;
     float scale = scaleEmToUnits(fontData->platformData().size(), fontFaceElement->unitsPerEm());
+    float scale = scaleEmToUnits(font->platformData().size(), fontFaceElement->unitsPerEm());
     String lastGlyphName;
 …
         ++m_index;
         if (m_index >= m_stoppingPoint || !m_glyphBuffer.fontDataAt(m_index)->isSVGFont())
+        if (m_index >= m_stoppingPoint || !m_glyphBuffer.fontAt(m_index)->isSVGFont())
             break;
         m_glyph = m_glyphBuffer.glyphAt(m_index);
 …
 };
 std::unique_ptr<GlyphToPathTranslator> SVGTextRunRenderingContext::createGlyphToPathTranslator(const SimpleFontData& fontData, const TextRun* textRun, const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& point) const
+std::unique_ptr<GlyphToPathTranslator> SVGTextRunRenderingContext::createGlyphToPathTranslator(const Font& font, const TextRun* textRun, const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& point) const
+{
     SVGFontElement* fontElement = nullptr;
     SVGFontFaceElement* fontFaceElement = nullptr;
     const SVGFontData* svgFontData = svgFontAndFontFaceElementForFontData(&fontData, fontFaceElement, fontElement);
+    const SVGFontData* svgFontData = svgFontAndFontFaceElementForFontData(&font, fontFaceElement, fontElement);
     if (!fontElement || !fontFaceElement)
         return std::make_unique<DummyGlyphToPathTranslator>();
 …
     bool isVerticalText = style.svgStyle().isVerticalWritingMode();
     float scale = scaleEmToUnits(fontData.platformData().size(), fontFaceElement->unitsPerEm());
+    float scale = scaleEmToUnits(font.platformData().size(), fontFaceElement->unitsPerEm());
     return std::make_unique<SVGGlyphToPathTranslator>(textRun, glyphBuffer, point, *svgFontData, *fontElement, from, numGlyphs, scale, isVerticalText);
+}
 void SVGTextRunRenderingContext::drawSVGGlyphs(GraphicsContext* context, const SimpleFontData* fontData, const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& point) const
+void SVGTextRunRenderingContext::drawSVGGlyphs(GraphicsContext* context, const Font* font, const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& point) const
+{
     auto activePaintingResource = this->activePaintingResource();
 …
     RenderSVGResourceMode resourceMode = context->textDrawingMode() == TextModeStroke ? ApplyToStrokeMode : ApplyToFillMode;
     for (auto translator = createGlyphToPathTranslator(*fontData, nullptr, glyphBuffer, from, numGlyphs, point); translator->containsMorePaths(); translator->advance()) {
+    for (auto translator = createGlyphToPathTranslator(*font, nullptr, glyphBuffer, from, numGlyphs, point); translator->containsMorePaths(); translator->advance()) {
         Path glyphPath = translator->path();
         if (activePaintingResource->applyResource(elementRenderer, style, context, resourceMode)) {
 …
 static GlyphData missingGlyphForFont(const FontCascade& font)
+{
     const SimpleFontData& primaryFontData = font.primaryFontData();
     if (!primaryFontData.isSVGFont())
+    const Font& primaryFont = font.primaryFont();
+    if (!primaryFont.isSVGFont())
         return GlyphData();
     SVGFontElement* fontElement;
     SVGFontFaceElement* fontFaceElement;
     svgFontAndFontFaceElementForFontData(&primaryFontData, fontFaceElement, fontElement);
     return GlyphData(fontElement->missingGlyph(), &primaryFontData);
+    svgFontAndFontFaceElementForFontData(&primaryFont, fontFaceElement, fontElement);
+    return GlyphData(fontElement->missingGlyph(), &primaryFont);
+}
 …
         return missingGlyphForFont(font);
     ASSERT(glyphData.fontData);
+    ASSERT(glyphData.font);
     // Characters enclosed by an <altGlyph> element, may not be registered in the GlyphPage.
     if (!glyphData.fontData->isSVGFont()) {
+    if (!glyphData.font->isSVGFont()) {
         auto& elementRenderer = is<RenderElement>(renderer()) ? downcast<RenderElement>(renderer()) : *renderer().parent();
         if (Element* parentRendererElement = elementRenderer.element()) {
             if (is<SVGAltGlyphElement>(*parentRendererElement))
                 glyphData.fontData = &font.primaryFontData();
+                glyphData.font = &font.primaryFont();
+        }
+    }
     if (!glyphData.fontData->isSVGFont())
+    if (!glyphData.font->isSVGFont())
         return glyphData;
     SVGFontElement* fontElement = nullptr;
     SVGFontFaceElement* fontFaceElement = nullptr;
     const SVGFontData* svgFontData = svgFontAndFontFaceElementForFontData(glyphData.fontData, fontFaceElement, fontElement);
+    const SVGFontData* svgFontData = svgFontAndFontFaceElementForFontData(glyphData.font, fontFaceElement, fontElement);
     if (!svgFontData)
         return glyphData;

trunk/Source/WebCore/rendering/svg/SVGTextRunRenderingContext.h

-              r178510
+              r178940
     virtual GlyphData glyphDataForCharacter(const FontCascade&, WidthIterator&, UChar32 character, bool mirror, int currentCharacter, unsigned& advanceLength, String& normalizedSpacesStringCache) override;
     virtual void drawSVGGlyphs(GraphicsContext*, const SimpleFontData*, const GlyphBuffer&, int from, int to, const FloatPoint&) const override;
+    virtual void drawSVGGlyphs(GraphicsContext*, const Font*, const GlyphBuffer&, int from, int to, const FloatPoint&) const override;
     virtual float floatWidthUsingSVGFont(const FontCascade&, const TextRun&, int& charsConsumed, String& glyphName) const override;
     virtual bool applySVGKerning(const SimpleFontData*, WidthIterator&, GlyphBuffer*, int from) const override;
+    virtual bool applySVGKerning(const Font*, WidthIterator&, GlyphBuffer*, int from) const override;
 #endif
 …
 #if ENABLE(SVG_FONTS)
     virtual std::unique_ptr<GlyphToPathTranslator> createGlyphToPathTranslator(const SimpleFontData&, const TextRun*, const GlyphBuffer&, int from, int numGlyphs, const FloatPoint&) const override;
+    virtual std::unique_ptr<GlyphToPathTranslator> createGlyphToPathTranslator(const Font&, const TextRun*, const GlyphBuffer&, int from, int numGlyphs, const FloatPoint&) const override;
 #endif

trunk/Source/WebCore/svg/SVGFontData.cpp

-              r178510
+              r178940
+}
 void SVGFontData::initializeFontData(SimpleFontData* fontData, float fontSize)
+{
     ASSERT(fontData);
+void SVGFontData::initializeFont(Font* font, float fontSize)
+{
+    ASSERT(font);
     SVGFontFaceElement* svgFontFaceElement = this->svgFontFaceElement();
     ASSERT(svgFontFaceElement);
     fontData->setZeroWidthSpaceGlyph(0);
     fontData->determinePitch();
+    font->setZeroWidthSpaceGlyph(0);
+    font->determinePitch();
     unsigned unitsPerEm = svgFontFaceElement->unitsPerEm();
 …
     float lineGap = 0.1f * fontSize;
     const GlyphPage* glyphPageZero = fontData->glyphPage(0);
+    const GlyphPage* glyphPageZero = font->glyphPage(0);
     if (!xHeight && glyphPageZero) {
         // Fallback if x_heightAttr is not specified for the font element.
         Glyph letterXGlyph = glyphPageZero->glyphDataForCharacter('x').glyph;
         xHeight = letterXGlyph ? fontData->widthForGlyph(letterXGlyph) : 2 * ascent / 3;
+    }
     FontMetrics& fontMetrics = fontData->fontMetrics();
+        xHeight = letterXGlyph ? font->widthForGlyph(letterXGlyph) : 2 * ascent / 3;
+    }
+    FontMetrics& fontMetrics = font->fontMetrics();
     fontMetrics.setUnitsPerEm(unitsPerEm);
     fontMetrics.setAscent(ascent);
 …
     if (!glyphPageZero) {
         fontData->setSpaceGlyph(0);
         fontData->setSpaceWidths(0);
         fontData->setAvgCharWidth(0);
         fontData->setMaxCharWidth(ascent);
+        font->setSpaceGlyph(0);
+        font->setSpaceWidths(0);
+        font->setAvgCharWidth(0);
+        font->setMaxCharWidth(ascent);
         return;
+    }
 …
     // Calculate space width.
     Glyph spaceGlyph = glyphPageZero->glyphDataForCharacter(' ').glyph;
     fontData->setSpaceGlyph(spaceGlyph);
     fontData->setSpaceWidths(fontData->widthForGlyph(spaceGlyph));
+    font->setSpaceGlyph(spaceGlyph);
+    font->setSpaceWidths(font->widthForGlyph(spaceGlyph));
     // Estimate average character width.
     Glyph numeralZeroGlyph = glyphPageZero->glyphDataForCharacter('0').glyph;
     fontData->setAvgCharWidth(numeralZeroGlyph ? fontData->widthForGlyph(numeralZeroGlyph) : fontData->spaceWidth());
+    font->setAvgCharWidth(numeralZeroGlyph ? font->widthForGlyph(numeralZeroGlyph) : font->spaceWidth());
     // Estimate maximum character width.
     Glyph letterWGlyph = glyphPageZero->glyphDataForCharacter('W').glyph;
     fontData->setMaxCharWidth(letterWGlyph ? fontData->widthForGlyph(letterWGlyph) : ascent);
+    font->setMaxCharWidth(letterWGlyph ? font->widthForGlyph(letterWGlyph) : ascent);
+}
 …
+}
 bool SVGFontData::fillSVGGlyphPage(GlyphPage* pageToFill, unsigned offset, unsigned length, UChar* buffer, unsigned bufferLength, const SimpleFontData* fontData) const
+{
     ASSERT(fontData->isCustomFont());
     ASSERT(fontData->isSVGFont());
+bool SVGFontData::fillSVGGlyphPage(GlyphPage* pageToFill, unsigned offset, unsigned length, UChar* buffer, unsigned bufferLength, const Font* font) const
+{
+    ASSERT(font->isCustomFont());
+    ASSERT(font->isSVGFont());
     SVGFontFaceElement* fontFaceElement = this->svgFontFaceElement();
 …
     if (bufferLength == length)
         return fillBMPGlyphs(fontElement, pageToFill, offset, length, buffer, fontData);
+        return fillBMPGlyphs(fontElement, pageToFill, offset, length, buffer, font);
     ASSERT(bufferLength == 2 * length);
     return fillNonBMPGlyphs(fontElement, pageToFill, offset, length, buffer, fontData);
+}
 bool SVGFontData::fillBMPGlyphs(SVGFontElement* fontElement, GlyphPage* pageToFill, unsigned offset, unsigned length, UChar* buffer, const SimpleFontData* fontData) const
+    return fillNonBMPGlyphs(fontElement, pageToFill, offset, length, buffer, font);
+}
+bool SVGFontData::fillBMPGlyphs(SVGFontElement* fontElement, GlyphPage* pageToFill, unsigned offset, unsigned length, UChar* buffer, const Font* font) const
+{
     bool haveGlyphs = false;
 …
         // only possible within the context of a string (eg. arabic form matching).
         haveGlyphs = true;
         pageToFill->setGlyphDataForIndex(offset + i, glyphs.first().tableEntry, fontData);
+        pageToFill->setGlyphDataForIndex(offset + i, glyphs.first().tableEntry, font);
         glyphs.clear();
+    }
 …
+}
 bool SVGFontData::fillNonBMPGlyphs(SVGFontElement* fontElement, GlyphPage* pageToFill, unsigned offset, unsigned length, UChar* buffer, const SimpleFontData* fontData) const
+bool SVGFontData::fillNonBMPGlyphs(SVGFontElement* fontElement, GlyphPage* pageToFill, unsigned offset, unsigned length, UChar* buffer, const Font* font) const
+{
     bool haveGlyphs = false;
 …
         // only possible within the context of a string (eg. arabic form matching).
         haveGlyphs = true;
         pageToFill->setGlyphDataForIndex(offset + i, glyphs.first().tableEntry, fontData);
+        pageToFill->setGlyphDataForIndex(offset + i, glyphs.first().tableEntry, font);
         glyphs.clear();
+    }

trunk/Source/WebCore/svg/SVGFontData.h

-              r177975
+              r178940
 #if ENABLE(SVG_FONTS)
 #include "SimpleFontData.h"
+#include "Font.h"
 namespace WebCore {
 …
 class SVGFontFaceElement;
 class SVGFontData : public SimpleFontData::SVGData {
+class SVGFontData : public Font::SVGData {
 public:
     explicit SVGFontData(SVGFontFaceElement*);
     virtual ~SVGFontData() { }
     virtual void initializeFontData(SimpleFontData*, float fontSize) override;
+    virtual void initializeFont(Font*, float fontSize) override;
     virtual float widthForSVGGlyph(Glyph, float fontSize) const override;
     virtual bool fillSVGGlyphPage(GlyphPage*, unsigned offset, unsigned length, UChar* buffer, unsigned bufferLength, const SimpleFontData*) const override;
+    virtual bool fillSVGGlyphPage(GlyphPage*, unsigned offset, unsigned length, UChar* buffer, unsigned bufferLength, const Font*) const override;
     bool applySVGGlyphSelection(WidthIterator&, GlyphData&, bool mirror, int currentCharacter, unsigned& advanceLength, String& normalizedSpacesStringCache) const;
 …
 private:
     bool fillBMPGlyphs(SVGFontElement*, GlyphPage* , unsigned offset, unsigned length, UChar* buffer, const SimpleFontData*) const;
     bool fillNonBMPGlyphs(SVGFontElement*, GlyphPage* , unsigned offset, unsigned length, UChar* buffer, const SimpleFontData*) const;
+    bool fillBMPGlyphs(SVGFontElement*, GlyphPage* , unsigned offset, unsigned length, UChar* buffer, const Font*) const;
+    bool fillNonBMPGlyphs(SVGFontElement*, GlyphPage* , unsigned offset, unsigned length, UChar* buffer, const Font*) const;
     bool applyTransforms(GlyphBufferGlyph*, GlyphBufferAdvance*, size_t, TypesettingFeatures) const = delete;

trunk/Source/WebCore/svg/SVGFontElement.h

r178048	r178940
77	77	float verticalKerningForPairOfStringsAndGlyphs(const String& u1, const String& g1, const String& u2, const String& g2) const;
78	78
79		// Used by ~~SimpleFontData~~/WidthIterator.
	79	// Used by Font/WidthIterator.
80	80	SVGGlyph svgGlyphForGlyph(Glyph);
81	81	Glyph missingGlyph();

trunk/Source/WebKit/ios/Misc/EmojiFallbackFontSelector.cpp

-              r178394
+              r178940
 #include "EmojiFallbackFontSelector.h"
+#include <WebCore/Font.h>
 #include <WebCore/FontCache.h>
-#include <WebCore/SimpleFontData.h>
 #include <wtf/Assertions.h>
 #include <wtf/text/AtomicString.h>
 …
 using namespace WebCore;
 PassRefPtr<SimpleFontData> EmojiFallbackFontSelector::fallbackFontDataAt(const FontDescription& fontDescription, size_t)
+PassRefPtr<Font> EmojiFallbackFontSelector::fallbackFontAt(const FontDescription& fontDescription, size_t)
+{
     DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, appleColorEmoji, ("Apple Color Emoji"));
     RefPtr<SimpleFontData> fontData = fontCache().fontForFamily(fontDescription, appleColorEmoji);
+    RefPtr<Font> fontData = fontCache().fontForFamily(fontDescription, appleColorEmoji);
     if (!fontData) {
         LOG_ERROR("Failed to get \"Apple Color Emoji\" from the font cache. Using the last resort fallback font instead.");

trunk/Source/WebKit/ios/Misc/EmojiFallbackFontSelector.h

-              r178394
+              r178940
     virtual WebCore::FontRanges fontRangesForFamily(const WebCore::FontDescription&, const AtomicString&) override { ASSERT_NOT_REACHED(); return WebCore::FontRanges(); }
     virtual bool resolvesFamilyFor(const WebCore::FontDescription&) const override { ASSERT_NOT_REACHED(); return false; }
     virtual size_t fallbackFontDataCount() override { return 1; };
     virtual PassRefPtr<WebCore::SimpleFontData> fallbackFontDataAt(const WebCore::FontDescription&, size_t) override;
+    virtual size_t fallbackFontCount() override { return 1; };
+    virtual PassRefPtr<WebCore::Font> fallbackFontAt(const WebCore::FontDescription&, size_t) override;
     virtual void registerForInvalidationCallbacks(WebCore::FontSelectorClient*) override { }

trunk/Source/WebKit/mac/Misc/WebCoreStatistics.mm

r177876	r178940
148	148	+ (size_t)cachedFontDataCount
149	149	{
150		return fontCache().font~~Data~~Count();
	150	return fontCache().fontCount();
151	151	}
152	152
153	153	+ (size_t)cachedFontDataInactiveCount
154	154	{
155		return fontCache().inactiveFont~~Data~~Count();
	155	return fontCache().inactiveFontCount();
156	156	}
157	157

trunk/Source/WebKit/mac/WebCoreSupport/PopupMenuMac.mm

-              r178510
+              r178940
 #import <WebCore/ChromeClient.h>
 #import <WebCore/EventHandler.h>
+#import <WebCore/Font.h>
 #import <WebCore/Frame.h>
 #import <WebCore/FrameView.h>
 #import <WebCore/Page.h>
 #import <WebCore/PopupMenuClient.h>
-#import <WebCore/SimpleFontData.h>
 #import <WebCore/WebCoreSystemInterface.h>
 …
         RetainPtr<NSMutableDictionary> attributes = adoptNS([[NSMutableDictionary alloc] init]);
         if (style.font() != FontCascade()) {
             NSFont *font = style.font().primaryFontData().getNSFont();
+            NSFont *font = style.font().primaryFont().getNSFont();
             if (!font) {
                 CGFloat size = style.font().primaryFontData().platformData().size();
+                CGFloat size = style.font().primaryFont().platformData().size();
                 font = style.font().weight() < FontWeightBold ? [NSFont systemFontOfSize:size] : [NSFont boldSystemFontOfSize:size];
+            }
 …
     NSPoint location;
     NSFont* font = m_client->menuStyle().font().primaryFontData().getNSFont();
+    NSFont* font = m_client->menuStyle().font().primaryFont().getNSFont();
     // These values were borrowed from AppKit to match their placement of the menu.

trunk/Source/WebKit/mac/WebView/WebFrame.mm

-              r178575
+              r178940
 #import <WebCore/EditorClient.h>
 #import <WebCore/FocusController.h>
+#import <WebCore/Font.h>
 #import <WebCore/FrameSelection.h>
 #import <WebCore/HistoryController.h>
 #import <WebCore/NodeTraversal.h>
 #import <WebCore/RenderLayer.h>
-#import <WebCore/SimpleFontData.h>
 #import <WebCore/TextResourceDecoder.h>
 #import <WebCore/WAKScrollView.h>
 …
     CTFontRef font = nil;
     if (_private->coreFrame) {
+        const SimpleFontData* fd = _private->coreFrame->editor().fontForSelection(multipleFonts);
+        const Font
+        * fd = _private->coreFrame->editor().fontForSelection(multipleFonts);
         if (fd)
             font = fd->getCTFont();

trunk/Source/WebKit/mac/WebView/WebHTMLView.mm

-              r178434
+              r178940
 #import <WebCore/FloatRect.h>
 #import <WebCore/FocusController.h>
+#import <WebCore/Font.h>
 #import <WebCore/FontCache.h>
 #import <WebCore/Frame.h>
 …
 #import <WebCore/RuntimeApplicationChecks.h>
 #import <WebCore/SharedBuffer.h>
-#import <WebCore/SimpleFontData.h>
 #import <WebCore/StyleProperties.h>
 #import <WebCore/Text.h>
 …
     fontDescription.setWeight(bold ? FontWeight900 : FontWeight500);
     fontDescription.setSpecifiedSize(pointSize);
     RefPtr<SimpleFontData> simpleFontData = fontCache().fontForFamily(fontDescription, familyName);
     return [simpleFontData->platformData().nsFont() fontName];
+    RefPtr<Font> font = fontCache().fontForFamily(fontDescription, familyName);
+    return [font->platformData().nsFont() fontName];
+}
 …
     NSFont *font = nil;
     if (Frame* coreFrame = core([self _frame])) {
         if (const SimpleFontData* fd = coreFrame->editor().fontForSelection(multipleFonts))
+        if (const Font* fd = coreFrame->editor().fontForSelection(multipleFonts))
             font = fd->getNSFont();
+    }

trunk/Source/WebKit/win/DOMCoreClasses.cpp

-              r178525
+              r178940
 #include <WebCore/DragImage.h>
 #include <WebCore/Element.h>
+#include <WebCore/Font.h>
 #include <WebCore/FontCascade.h>
 #include <WebCore/Frame.h>
 …
 #include <WebCore/RenderElement.h>
 #include <WebCore/RenderTreeAsText.h>
-#include <WebCore/SimpleFontData.h>
 #include <initguid.h>

trunk/Source/WebKit/win/WebCoreStatistics.cpp

-              r177876
+              r178940
     if (!count)
         return E_POINTER;
     *count = (UINT) fontCache().fontDataCount();
+    *count = (UINT) fontCache().fontCount();
     return S_OK;
+}
 …
     if (!count)
         return E_POINTER;
     *count = (UINT) fontCache().inactiveFontDataCount();
+    *count = (UINT) fontCache().inactiveFontCount();
     return S_OK;
+}

trunk/Source/WebKit/win/WebView.cpp

-              r178849
+              r178940
 #include <WebCore/FloatQuad.h>
 #include <WebCore/FocusController.h>
+#include <WebCore/Font.h>
 #include <WebCore/FrameLoader.h>
 #include <WebCore/FrameSelection.h>
 …
 #include <WebCore/SecurityPolicy.h>
 #include <WebCore/Settings.h>
-#include <WebCore/SimpleFontData.h>
 #include <WebCore/SystemInfo.h>
 #include <WebCore/WindowMessageBroadcaster.h>
 …
 HRESULT WebView::setShouldApplyMacFontAscentHack(BOOL b)
+{
     SimpleFontData::setShouldApplyMacAscentHack(b);
+    Font::setShouldApplyMacAscentHack(b);
     return S_OK;
+}

trunk/Source/WebKit2/WebProcess/WebCoreSupport/mac/WebPopupMenuMac.mm

r177955	r178940
40	40	#if USE(APPKIT)
41	41	// FIXME: font will be nil here for custom fonts, we should fix that.
42		NSFont *font = m_popupClient->menuStyle().font().primaryFont~~Data~~().getNSFont();
	42	NSFont *font = m_popupClient->menuStyle().font().primaryFont().getNSFont();
43	43	if (!font)
44	44	return;

trunk/Source/WebKit2/WebProcess/WebPage/WebPage.cpp

r178889	r178940
805	805	Node* nodeToRemove;
806	806	if (RenderStyle* style = Editor::styleForSelectionStart(&frame, nodeToRemove)) {
807		CTFontRef font = style->fontCascade().primaryFont~~Data~~().getCTFont();
	807	CTFontRef font = style->fontCascade().primaryFont().getCTFont();
808	808	CTFontSymbolicTraits traits = font ? CTFontGetSymbolicTraits(font) : 0;
809	809

trunk/Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm

-              r178820
+              r178940
     bool multipleFonts = false;
     CTFontRef font = nil;
     if (const SimpleFontData* fontData = frame.editor().fontForSelection(multipleFonts))
         font = fontData->getCTFont();
+    if (auto* coreFont = frame.editor().fontForSelection(multipleFonts))
+        font = coreFont->getCTFont();
     CGFloat fontSize = CTFontGetSize(font);

trunk/Source/WebKit2/WebProcess/WebProcess.cpp

-              r178634
+              r178940
     // Gather font statistics.
     data.statisticsNumbers.set(ASCIILiteral("CachedFontDataCount"), fontCache().fontDataCount());
     data.statisticsNumbers.set(ASCIILiteral("CachedFontDataInactiveCount"), fontCache().inactiveFontDataCount());
+    data.statisticsNumbers.set(ASCIILiteral("CachedFontDataCount"), fontCache().fontCount());
+    data.statisticsNumbers.set(ASCIILiteral("CachedFontDataInactiveCount"), fontCache().inactiveFontCount());
     // Gather glyph page statistics.

Context Navigation

Changeset 178940 in webkit

Legend:

Download in other formats: