Changeset 26484 in webkit

Timestamp:

Oct 12, 2007, 7:55:24 AM (17 years ago)

Author:

oliver

Message:

Land support for the CSS @font-face rule. This patch allows custom fonts
to be downloaded from the Web and rendered in Web pages. Right now only
TrueType fonts are supported. Proprietary formats like .eot are not
supported.

Reviewed by Eric Seidel

Many tests will be coming in a future landing.

• WebCore.base.exp: Expose some more stuff for WebKit, caused by font restructuring.

• WebCore.xcodeproj/project.pbxproj: Add all the new font face files.

• css/CSSComputedStyleDeclaration.cpp: (WebCore::CSSComputedStyleDeclaration::getPropertyCSSValue): Make sure to ignore the 'src' property of @font-face rules.

• css/CSSFontFace.cpp: Added. (WebCore::CSSFontFace::CSSFontFace): (WebCore::CSSFontFace::~CSSFontFace): (WebCore::CSSFontFace::isLoaded): (WebCore::CSSFontFace::isValid): (WebCore::CSSFontFace::addSource): (WebCore::CSSFontFace::fontLoaded): (WebCore::CSSFontFace::getFontData):
• css/CSSFontFace.h: Added. A CSSFontFace is a composite object. It consists of multiple font-face sources, where each source represents either a remote or local file in a @font-face rule's src list.

• css/CSSFontFaceRule.cpp: (WebCore::CSSFontFaceRule::setDeclaration): (WebCore::CSSFontFaceRule::cssText):
• css/CSSFontFaceRule.h: The implementation of the @font-face rule itself in the CSS sheet back end.

• css/CSSFontFaceSource.cpp: Added. (WebCore::CSSFontFaceSource::CSSFontFaceSource): (WebCore::CSSFontFaceSource::~CSSFontFaceSource): (WebCore::CSSFontFaceSource::pruneTable): (WebCore::CSSFontFaceSource::isLoaded): (WebCore::CSSFontFaceSource::isValid): (WebCore::CSSFontFaceSource::fontLoaded): (WebCore::CSSFontFaceSource::getFontData):
• css/CSSFontFaceSource.h: Added. (WebCore::CSSFontFaceSource::string): (WebCore::CSSFontFaceSource::setFontFace): A font face source represents a single remote or local font. If it represents a remote font than it wraps a CachedFont.

• css/CSSFontFaceSrcValue.cpp: Added. (WebCore::CSSFontFaceSrcValue::isSupportedFormat): (WebCore::CSSFontFaceSrcValue::cssText):
• css/CSSFontFaceSrcValue.h: Added. (WebCore::CSSFontFaceSrcValue::m_isLocal): (WebCore::CSSFontFaceSrcValue::~CSSFontFaceSrcValue): (WebCore::CSSFontFaceSrcValue::resource): (WebCore::CSSFontFaceSrcValue::format): (WebCore::CSSFontFaceSrcValue::isLocal): (WebCore::CSSFontFaceSrcValue::setFormat): Used in parsing. Represents the parsed form of the src value that can then be used to build up a CSSFontFace.

• css/CSSFontSelector.cpp: Added. (WebCore::CSSFontSelector::CSSFontSelector): (WebCore::CSSFontSelector::~CSSFontSelector): (WebCore::CSSFontSelector::isEmpty): (WebCore::CSSFontSelector::docLoader): (WebCore::hashForFont): (WebCore::CSSFontSelector::addFontFaceRule): (WebCore::CSSFontSelector::fontLoaded): (WebCore::CSSFontSelector::getFontData):
• css/CSSFontSelector.h: Added. The CSS font selector is the object that selects the correct font given a specified font family. It builds up a database of CSSFontFaces that can then be handed back.

• css/CSSGrammar.y:
• css/CSSParser.cpp: (WebCore::CSSParser::parseValue): (WebCore::CSSParser::parseFontFaceSrc): (WebCore::CSSParser::createFontFaceRule):
• css/CSSParser.h: Modify the CSS grammar to now understand @font-face rules.

• css/CSSPropertyNames.in: Add the src property.

• css/CSSStyleSelector.cpp: (WebCore::CSSStyleSelector::CSSStyleSelector): (WebCore::CSSStyleSelector::styleForElement): (WebCore::CSSStyleSelector::updateFont): (WebCore::CSSRuleSet::addRulesFromSheet): (WebCore::CSSStyleSelector::applyProperty): (WebCore::CSSStyleSelector::ensureFontSelector):
• css/CSSStyleSelector.h: (WebCore::CSSStyleSelector::fontSelector): The style selector now creates a font selector object and feeds it the appropriate information when @font-face rules are encountered.

• dom/Document.cpp: (WebCore::Document::recalcStyle): Patch the update method now that it takes a font selector argument.

• loader/Cache.cpp: (WebCore::createResource): (WebCore::Cache::getStatistics):
• loader/Cache.h: Teach the Cache about CachedFonts.

• loader/CachedFont.cpp: Added. (WebCore::CachedFont::CachedFont): (WebCore::CachedFont::~CachedFont): (WebCore::CachedFont::ref): (WebCore::CachedFont::data): (WebCore::CachedFont::beginLoadIfNeeded): (WebCore::CachedFont::ensureCustomFontData): (WebCore::CachedFont::platformDataFromCustomData): (WebCore::CachedFont::allReferencesRemoved): (WebCore::CachedFont::checkNotify): (WebCore::CachedFont::error):
• loader/CachedFont.h: Added. (WebCore::CachedFont::schedule): The implementation of CachedFont. This represents the downloaded resource and has all the raw font data.

• loader/CachedResource.h: (WebCore::CachedResource::):
• loader/CachedResourceClient.h: (WebCore::CachedResourceClient::fontLoaded): Add a new fontLoaded method for clients of cached resources to track when fonts finish downloading.

• loader/DocLoader.cpp: (WebCore::DocLoader::requestFont):
• loader/DocLoader.h: Add the ability to request a font.

• platform/Font.cpp: (WebCore::Font::operator==): (WebCore::Font::update): (WebCore::Font::drawText):
• platform/Font.h:
• platform/FontCache.cpp: (WebCore::FontCache::getFontData):
• platform/FontCache.h:
• platform/FontData.cpp: (WebCore::FontData::FontData):
• platform/FontData.h: (WebCore::FontData::isCustomFont): (WebCore::FontData::isLoading):
• platform/FontFallbackList.cpp: (WebCore::FontFallbackList::FontFallbackList): (WebCore::FontFallbackList::invalidate): (WebCore::FontFallbackList::fontDataAt):
• platform/FontFallbackList.h: (WebCore::FontFallbackList::loadingCustomFonts): (WebCore::FontFallbackList::fontSelector):
• platform/FontSelector.h: Added. (WebCore::FontSelector::~FontSelector):
• platform/GlyphPageTreeNode.cpp: (WebCore::GlyphPageTreeNode::getRoot): (WebCore::GlyphPageTreeNode::pruneTreeCustomFontData): (WebCore::GlyphPageTreeNode::~GlyphPageTreeNode): (WebCore::GlyphPageTreeNode::initializePage): (WebCore::GlyphPageTreeNode::getChild): (WebCore::GlyphPageTreeNode::pruneCustomFontData):
• platform/GlyphPageTreeNode.h: (WebCore::GlyphPageTreeNode::GlyphPageTreeNode): (WebCore::GlyphPageTreeNode::page):
• platform/PopupMenuClient.h:
• platform/mac/FontCacheMac.mm: (WebCore::FontCache::getFontDataForCharacters): (WebCore::FontCache::getLastResortFallbackFont): (WebCore::FontCache::fontExists): (WebCore::FontCache::createFontPlatformData):
• platform/mac/FontCustomPlatformData.cpp: Added. (WebCore::FontCustomPlatformData::~FontCustomPlatformData): (WebCore::FontCustomPlatformData::fontPlatformData): (WebCore::createFontCustomPlatformData):
• platform/mac/FontCustomPlatformData.h: Added. (WebCore::FontCustomPlatformData::FontCustomPlatformData):
• platform/mac/FontDataMac.mm: (WebCore::initFontData): (WebCore::FontData::platformInit): (WebCore::FontData::smallCapsFontData): (WebCore::FontData::platformWidthForGlyph): (WebCore::FontData::checkShapesArabic):
• platform/mac/FontMac.mm: (WebCore::initializeATSUStyle): (WebCore::Font::drawGlyphs):
• platform/mac/FontPlatformData.h: (WebCore::FontPlatformData::FontPlatformData): (WebCore::FontPlatformData::hash): (WebCore::FontPlatformData::operator==):
• platform/mac/FontPlatformDataMac.mm: Added. (WebCore::FontPlatformData::FontPlatformData): (WebCore::~FontPlatformData): (WebCore::FontPlatformData::setFont):
• platform/mac/WebCoreSystemInterface.h:
• platform/mac/WebCoreSystemInterface.mm:
• platform/win/FontCacheWin.cpp: (WebCore::FontCache::getLastResortFallbackFont): (WebCore::FontCache::fontExists):
• platform/win/FontCustomPlatformData.cpp: Added. (WebCore::FontCustomPlatformData::~FontCustomPlatformData): (WebCore::FontCustomPlatformData::fontPlatformData): (WebCore::getData): (WebCore::releaseData): (WebCore::getBytesWithOffset): (WebCore::createFontCustomPlatformData):
• platform/win/FontCustomPlatformData.h: Added. (WebCore::FontCustomPlatformData::FontCustomPlatformData):
• platform/win/FontDataWin.cpp: (WebCore::FontData::platformInit): (WebCore::FontData::platformDestroy): (WebCore::FontData::smallCapsFontData): (WebCore::FontData::containsCharacters): (WebCore::FontData::determinePitch):
• platform/win/FontPlatformData.h: (WebCore::FontPlatformData::FontPlatformData): (WebCore::FontPlatformData::hash): (WebCore::FontPlatformData::operator==):
• platform/win/FontPlatformDataWin.cpp: (WebCore::FontPlatformData::FontPlatformData):
• platform/win/PopupMenuWin.cpp: (WebCore::PopupMenu::paint): Changes to platform to support rendering of custom fonts. Too large to go into, but for ports, the relevant object to implement is FontCustomPlatformData (to get the data loaded into your native font format), and then you have to patch your other font objects to know how to use the font.

• rendering/RenderListBox.cpp: (WebCore::RenderListBox::updateFromElement): (WebCore::RenderListBox::paintItemForeground):
• rendering/RenderMenuList.cpp: (WebCore::RenderMenuList::fontSelector):
• rendering/RenderMenuList.h:
• rendering/RenderTextControl.cpp: (WebCore::RenderTextControl::fontSelector):
• rendering/RenderTextControl.h:
• rendering/RenderThemeMac.mm: (WebCore::RenderThemeMac::setFontFromControlSize):
• rendering/RenderThemeSafari.cpp: (WebCore::RenderThemeSafari::setFontFromControlSize): Patches for update now taking a font selector argument.

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• WebCore.base.exp (modified) (2 diffs)
• WebCore.xcodeproj/project.pbxproj (modified) (8 diffs)
• css/CSSComputedStyleDeclaration.cpp (modified) (1 diff)
• css/CSSFontFace.cpp (added)
• css/CSSFontFace.h (added)
• css/CSSFontFaceRule.cpp (modified) (1 diff)
• css/CSSFontFaceRule.h (modified) (2 diffs)
• css/CSSFontFaceSource.cpp (added)
• css/CSSFontFaceSource.h (added)
• css/CSSFontFaceSrcValue.cpp (added)
• css/CSSFontFaceSrcValue.h (added)
• css/CSSFontSelector.cpp (added)
• css/CSSFontSelector.h (added)
• css/CSSGrammar.y (modified) (2 diffs)
• css/CSSParser.cpp (modified) (4 diffs)
• css/CSSParser.h (modified) (2 diffs)
• css/CSSPropertyNames.in (modified) (1 diff)
• css/CSSStyleSelector.cpp (modified) (14 diffs)
• css/CSSStyleSelector.h (modified) (6 diffs)
• dom/Document.cpp (modified) (1 diff)
• loader/Cache.cpp (modified) (3 diffs)
• loader/Cache.h (modified) (1 diff)
• loader/CachedFont.cpp (added)
• loader/CachedFont.h (added)
• loader/CachedResource.h (modified) (1 diff)
• loader/CachedResourceClient.h (modified) (2 diffs)
• loader/DocLoader.cpp (modified) (2 diffs)
• loader/DocLoader.h (modified) (2 diffs)
• platform/Font.cpp (modified) (4 diffs)
• platform/Font.h (modified) (4 diffs)
• platform/FontCache.cpp (modified) (4 diffs)
• platform/FontCache.h (modified) (2 diffs)
• platform/FontData.cpp (modified) (2 diffs)
• platform/FontData.h (modified) (5 diffs)
• platform/FontFallbackList.cpp (modified) (2 diffs)
• platform/FontFallbackList.h (modified) (4 diffs)
• platform/FontSelector.h (added)
• platform/GlyphPageTreeNode.cpp (modified) (7 diffs)
• platform/GlyphPageTreeNode.h (modified) (7 diffs)
• platform/PopupMenuClient.h (modified) (2 diffs)
• platform/mac/FontCacheMac.mm (modified) (6 diffs)
• platform/mac/FontCustomPlatformData.cpp (added)
• platform/mac/FontCustomPlatformData.h (added)
• platform/mac/FontDataMac.mm (modified) (8 diffs)
• platform/mac/FontMac.mm (modified) (2 diffs)
• platform/mac/FontPlatformData.h (modified) (3 diffs)
• platform/mac/FontPlatformDataMac.mm (added)
• platform/mac/WebCoreSystemInterface.h (modified) (1 diff)
• platform/mac/WebCoreSystemInterface.mm (modified) (1 diff)
• platform/win/FontCacheWin.cpp (modified) (2 diffs)
• platform/win/FontCustomPlatformData.cpp (added)
• platform/win/FontCustomPlatformData.h (copied) (copied from trunk/WebCore/css/CSSFontFaceRule.cpp ) (2 diffs)
• platform/win/FontDataWin.cpp (modified) (7 diffs)
• platform/win/FontPlatformData.h (modified) (4 diffs)
• platform/win/FontPlatformDataWin.cpp (modified) (1 diff)
• platform/win/PopupMenuWin.cpp (modified) (2 diffs)
• rendering/RenderListBox.cpp (modified) (3 diffs)
• rendering/RenderMenuList.cpp (modified) (2 diffs)
• rendering/RenderMenuList.h (modified) (1 diff)
• rendering/RenderTextControl.cpp (modified) (3 diffs)
• rendering/RenderTextControl.h (modified) (2 diffs)
• rendering/RenderThemeMac.mm (modified) (1 diff)
• rendering/RenderThemeSafari.cpp (modified) (1 diff)

trunk/WebCore/ChangeLog

@@ +1 @@
+2007-10-03  David Hyatt  <hyatt@apple.com>
+
+        Land support for the CSS @font-face rule.  This patch allows custom fonts
+        to be downloaded from the Web and rendered in Web pages.  Right now only
+        TrueType fonts are supported.  Proprietary formats like .eot are not
+        supported.
+
+        Reviewed by Eric Seidel
+
+        Many tests will be coming in a future landing.
+
+        * WebCore.base.exp:
+        Expose some more stuff for WebKit, caused by font restructuring.
+
+        * WebCore.xcodeproj/project.pbxproj:
+        Add all the new font face files.
+
+        * css/CSSComputedStyleDeclaration.cpp:
+        (WebCore::CSSComputedStyleDeclaration::getPropertyCSSValue):
+        Make sure to ignore the 'src' property of @font-face rules.
+
+        * css/CSSFontFace.cpp: Added.
+        (WebCore::CSSFontFace::CSSFontFace):
+        (WebCore::CSSFontFace::~CSSFontFace):
+        (WebCore::CSSFontFace::isLoaded):
+        (WebCore::CSSFontFace::isValid):
+        (WebCore::CSSFontFace::addSource):
+        (WebCore::CSSFontFace::fontLoaded):
+        (WebCore::CSSFontFace::getFontData):
+        * css/CSSFontFace.h: Added.
+        A CSSFontFace is a composite object.  It consists of multiple font-face sources, where each source represents either a remote or local
+        file in a @font-face rule's src list.
+
+        * css/CSSFontFaceRule.cpp:
+        (WebCore::CSSFontFaceRule::setDeclaration):
+        (WebCore::CSSFontFaceRule::cssText):
+        * css/CSSFontFaceRule.h:
+        The implementation of the @font-face rule itself in the CSS sheet back end.
+        
+        * css/CSSFontFaceSource.cpp: Added.
+        (WebCore::CSSFontFaceSource::CSSFontFaceSource):
+        (WebCore::CSSFontFaceSource::~CSSFontFaceSource):
+        (WebCore::CSSFontFaceSource::pruneTable):
+        (WebCore::CSSFontFaceSource::isLoaded):
+        (WebCore::CSSFontFaceSource::isValid):
+        (WebCore::CSSFontFaceSource::fontLoaded):
+        (WebCore::CSSFontFaceSource::getFontData):
+        * css/CSSFontFaceSource.h: Added.
+        (WebCore::CSSFontFaceSource::string):
+        (WebCore::CSSFontFaceSource::setFontFace):
+        A font face source represents a single remote or local font.  If it represents a remote font than it wraps a CachedFont.
+        
+        * css/CSSFontFaceSrcValue.cpp: Added.
+        (WebCore::CSSFontFaceSrcValue::isSupportedFormat):
+        (WebCore::CSSFontFaceSrcValue::cssText):
+        * css/CSSFontFaceSrcValue.h: Added.
+        (WebCore::CSSFontFaceSrcValue::m_isLocal):
+        (WebCore::CSSFontFaceSrcValue::~CSSFontFaceSrcValue):
+        (WebCore::CSSFontFaceSrcValue::resource):
+        (WebCore::CSSFontFaceSrcValue::format):
+        (WebCore::CSSFontFaceSrcValue::isLocal):
+        (WebCore::CSSFontFaceSrcValue::setFormat):
+        Used in parsing.  Represents the parsed form of the src value that can then be used to build up a CSSFontFace.
+
+        * css/CSSFontSelector.cpp: Added.
+        (WebCore::CSSFontSelector::CSSFontSelector):
+        (WebCore::CSSFontSelector::~CSSFontSelector):
+        (WebCore::CSSFontSelector::isEmpty):
+        (WebCore::CSSFontSelector::docLoader):
+        (WebCore::hashForFont):
+        (WebCore::CSSFontSelector::addFontFaceRule):
+        (WebCore::CSSFontSelector::fontLoaded):
+        (WebCore::CSSFontSelector::getFontData):
+        * css/CSSFontSelector.h: Added.
+        The CSS font selector is the object that selects the correct font given a specified font family.  It builds up a database of CSSFontFaces that can then be handed
+        back.
+
+        * css/CSSGrammar.y:
+        * css/CSSParser.cpp:
+        (WebCore::CSSParser::parseValue):
+        (WebCore::CSSParser::parseFontFaceSrc):
+        (WebCore::CSSParser::createFontFaceRule):
+        * css/CSSParser.h:
+        Modify the CSS grammar to now understand @font-face rules.
+
+        * css/CSSPropertyNames.in:
+        Add the src property.
+
+        * css/CSSStyleSelector.cpp:
+        (WebCore::CSSStyleSelector::CSSStyleSelector):
+        (WebCore::CSSStyleSelector::styleForElement):
+        (WebCore::CSSStyleSelector::updateFont):
+        (WebCore::CSSRuleSet::addRulesFromSheet):
+        (WebCore::CSSStyleSelector::applyProperty):
+        (WebCore::CSSStyleSelector::ensureFontSelector):
+        * css/CSSStyleSelector.h:
+        (WebCore::CSSStyleSelector::fontSelector):
+        The style selector now creates a font selector object and feeds it the appropriate information when @font-face rules are encountered.
+    
+        * dom/Document.cpp:
+        (WebCore::Document::recalcStyle):
+        Patch the update method now that it takes a font selector argument.
+    
+        * loader/Cache.cpp:
+        (WebCore::createResource):
+        (WebCore::Cache::getStatistics):
+        * loader/Cache.h:
+        Teach the Cache about CachedFonts.
+
+        * loader/CachedFont.cpp: Added.
+        (WebCore::CachedFont::CachedFont):
+        (WebCore::CachedFont::~CachedFont):
+        (WebCore::CachedFont::ref):
+        (WebCore::CachedFont::data):
+        (WebCore::CachedFont::beginLoadIfNeeded):
+        (WebCore::CachedFont::ensureCustomFontData):
+        (WebCore::CachedFont::platformDataFromCustomData):
+        (WebCore::CachedFont::allReferencesRemoved):
+        (WebCore::CachedFont::checkNotify):
+        (WebCore::CachedFont::error):
+        * loader/CachedFont.h: Added.
+        (WebCore::CachedFont::schedule):
+        The implementation of CachedFont.  This represents the downloaded resource and has all the raw font data.
+
+        * loader/CachedResource.h:
+        (WebCore::CachedResource::):
+        * loader/CachedResourceClient.h:
+        (WebCore::CachedResourceClient::fontLoaded):
+        Add a new fontLoaded method for clients of cached resources to track when fonts finish downloading.
+    
+        * loader/DocLoader.cpp:
+        (WebCore::DocLoader::requestFont):
+        * loader/DocLoader.h:
+         Add the ability to request a font.
+
+        * platform/Font.cpp:
+        (WebCore::Font::operator==):
+        (WebCore::Font::update):
+        (WebCore::Font::drawText):
+        * platform/Font.h:
+        * platform/FontCache.cpp:
+        (WebCore::FontCache::getFontData):
+        * platform/FontCache.h:
+        * platform/FontData.cpp:
+        (WebCore::FontData::FontData):
+        * platform/FontData.h:
+        (WebCore::FontData::isCustomFont):
+        (WebCore::FontData::isLoading):
+        * platform/FontFallbackList.cpp:
+        (WebCore::FontFallbackList::FontFallbackList):
+        (WebCore::FontFallbackList::invalidate):
+        (WebCore::FontFallbackList::fontDataAt):
+        * platform/FontFallbackList.h:
+        (WebCore::FontFallbackList::loadingCustomFonts):
+        (WebCore::FontFallbackList::fontSelector):
+        * platform/FontSelector.h: Added.
+        (WebCore::FontSelector::~FontSelector):
+        * platform/GlyphPageTreeNode.cpp:
+        (WebCore::GlyphPageTreeNode::getRoot):
+        (WebCore::GlyphPageTreeNode::pruneTreeCustomFontData):
+        (WebCore::GlyphPageTreeNode::~GlyphPageTreeNode):
+        (WebCore::GlyphPageTreeNode::initializePage):
+        (WebCore::GlyphPageTreeNode::getChild):
+        (WebCore::GlyphPageTreeNode::pruneCustomFontData):
+        * platform/GlyphPageTreeNode.h:
+        (WebCore::GlyphPageTreeNode::GlyphPageTreeNode):
+        (WebCore::GlyphPageTreeNode::page):
+        * platform/PopupMenuClient.h:
+        * platform/mac/FontCacheMac.mm:
+        (WebCore::FontCache::getFontDataForCharacters):
+        (WebCore::FontCache::getLastResortFallbackFont):
+        (WebCore::FontCache::fontExists):
+        (WebCore::FontCache::createFontPlatformData):
+        * platform/mac/FontCustomPlatformData.cpp: Added.
+        (WebCore::FontCustomPlatformData::~FontCustomPlatformData):
+        (WebCore::FontCustomPlatformData::fontPlatformData):
+        (WebCore::createFontCustomPlatformData):
+        * platform/mac/FontCustomPlatformData.h: Added.
+        (WebCore::FontCustomPlatformData::FontCustomPlatformData):
+        * platform/mac/FontDataMac.mm:
+        (WebCore::initFontData):
+        (WebCore::FontData::platformInit):
+        (WebCore::FontData::smallCapsFontData):
+        (WebCore::FontData::platformWidthForGlyph):
+        (WebCore::FontData::checkShapesArabic):
+        * platform/mac/FontMac.mm:
+        (WebCore::initializeATSUStyle):
+        (WebCore::Font::drawGlyphs):
+        * platform/mac/FontPlatformData.h:
+        (WebCore::FontPlatformData::FontPlatformData):
+        (WebCore::FontPlatformData::hash):
+        (WebCore::FontPlatformData::operator==):
+        * platform/mac/FontPlatformDataMac.mm: Added.
+        (WebCore::FontPlatformData::FontPlatformData):
+        (WebCore::~FontPlatformData):
+        (WebCore::FontPlatformData::setFont):
+        * platform/mac/WebCoreSystemInterface.h:
+        * platform/mac/WebCoreSystemInterface.mm:
+        * platform/win/FontCacheWin.cpp:
+        (WebCore::FontCache::getLastResortFallbackFont):
+        (WebCore::FontCache::fontExists):
+        * platform/win/FontCustomPlatformData.cpp: Added.
+        (WebCore::FontCustomPlatformData::~FontCustomPlatformData):
+        (WebCore::FontCustomPlatformData::fontPlatformData):
+        (WebCore::getData):
+        (WebCore::releaseData):
+        (WebCore::getBytesWithOffset):
+        (WebCore::createFontCustomPlatformData):
+        * platform/win/FontCustomPlatformData.h: Added.
+        (WebCore::FontCustomPlatformData::FontCustomPlatformData):
+        * platform/win/FontDataWin.cpp:
+        (WebCore::FontData::platformInit):
+        (WebCore::FontData::platformDestroy):
+        (WebCore::FontData::smallCapsFontData):
+        (WebCore::FontData::containsCharacters):
+        (WebCore::FontData::determinePitch):
+        * platform/win/FontPlatformData.h:
+        (WebCore::FontPlatformData::FontPlatformData):
+        (WebCore::FontPlatformData::hash):
+        (WebCore::FontPlatformData::operator==):
+        * platform/win/FontPlatformDataWin.cpp:
+        (WebCore::FontPlatformData::FontPlatformData):
+        * platform/win/PopupMenuWin.cpp:
+        (WebCore::PopupMenu::paint):
+        Changes to platform to support rendering of custom fonts.  Too large to go into, but for ports, the relevant object to implement is
+        FontCustomPlatformData (to get the data loaded into your native font format), and then you have to patch your other font objects to know
+        how to use the font.
+
+        * rendering/RenderListBox.cpp:
+        (WebCore::RenderListBox::updateFromElement):
+        (WebCore::RenderListBox::paintItemForeground):
+        * rendering/RenderMenuList.cpp:
+        (WebCore::RenderMenuList::fontSelector):
+        * rendering/RenderMenuList.h:
+        * rendering/RenderTextControl.cpp:
+        (WebCore::RenderTextControl::fontSelector):
+        * rendering/RenderTextControl.h:
+        * rendering/RenderThemeMac.mm:
+        (WebCore::RenderThemeMac::setFontFromControlSize):
+        * rendering/RenderThemeSafari.cpp:
+        (WebCore::RenderThemeSafari::setFontFromControlSize):
+        Patches for update now taking a font selector argument.
+    
 2007-10-03  Rob Buis  <buis@kde.org>
 

trunk/WebCore/WebCore.base.exp

@@ -347 +347 @@
 __ZN7WebCore4FontD1Ev
 __ZN7WebCore4FontaSERKS0_
+__ZN7WebCore16FontPlatformDataC1EP6NSFontbb
+__ZN7WebCore16FontPlatformDataD1Ev
 __ZN7WebCore4KURL13decode_stringERKNS_16DeprecatedStringE
 __ZN7WebCore4KURLC1EP5NSURL
@@ -705 +707 @@
 _wkGetATSStyleGroup
 _wkGetCGFontFromNSFont
-_wkGetDefaultGlyphForChar
 _wkGetExtensionsForMIMEType
 _wkGetFontInLanguageForCharacter

trunk/WebCore/WebCore.xcodeproj/project.pbxproj

@@ -3292 +3292 @@
                 BC5A86B50C3367E800EEA649 /* JSDOMSelection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BC5A86B30C3367E800EEA649 /* JSDOMSelection.cpp */; };
                 BC5A86B60C3367E800EEA649 /* JSDOMSelection.h in Headers */ = {isa = PBXBuildFile; fileRef = BC5A86B40C3367E800EEA649 /* JSDOMSelection.h */; };
+                BC64B4B90CB428C7005F2B62 /* FontSelector.h in Headers */ = {isa = PBXBuildFile; fileRef = BC64B4B80CB428C7005F2B62 /* FontSelector.h */; };
+                BC64B4BD0CB42929005F2B62 /* FontCustomPlatformData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BC64B4BA0CB42929005F2B62 /* FontCustomPlatformData.cpp */; };
+                BC64B4BE0CB42929005F2B62 /* FontCustomPlatformData.h in Headers */ = {isa = PBXBuildFile; fileRef = BC64B4BB0CB42929005F2B62 /* FontCustomPlatformData.h */; };
+                BC64B4BF0CB42929005F2B62 /* FontPlatformDataMac.mm in Sources */ = {isa = PBXBuildFile; fileRef = BC64B4BC0CB42929005F2B62 /* FontPlatformDataMac.mm */; };
+                BC64B4CB0CB4295D005F2B62 /* CachedFont.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BC64B4C90CB4295D005F2B62 /* CachedFont.cpp */; };
+                BC64B4CC0CB4295D005F2B62 /* CachedFont.h in Headers */ = {isa = PBXBuildFile; fileRef = BC64B4CA0CB4295D005F2B62 /* CachedFont.h */; };
+                BC64B4D50CB4298A005F2B62 /* CSSFontFace.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BC64B4CD0CB4298A005F2B62 /* CSSFontFace.cpp */; };
+                BC64B4D60CB4298A005F2B62 /* CSSFontFace.h in Headers */ = {isa = PBXBuildFile; fileRef = BC64B4CE0CB4298A005F2B62 /* CSSFontFace.h */; };
+                BC64B4D70CB4298A005F2B62 /* CSSFontFaceSource.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BC64B4CF0CB4298A005F2B62 /* CSSFontFaceSource.cpp */; };
+                BC64B4D80CB4298A005F2B62 /* CSSFontFaceSource.h in Headers */ = {isa = PBXBuildFile; fileRef = BC64B4D00CB4298A005F2B62 /* CSSFontFaceSource.h */; };
+                BC64B4D90CB4298A005F2B62 /* CSSFontFaceSrcValue.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BC64B4D10CB4298A005F2B62 /* CSSFontFaceSrcValue.cpp */; };
+                BC64B4DA0CB4298A005F2B62 /* CSSFontFaceSrcValue.h in Headers */ = {isa = PBXBuildFile; fileRef = BC64B4D20CB4298A005F2B62 /* CSSFontFaceSrcValue.h */; };
+                BC64B4DB0CB4298A005F2B62 /* CSSFontSelector.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BC64B4D30CB4298A005F2B62 /* CSSFontSelector.cpp */; };
+                BC64B4DC0CB4298A005F2B62 /* CSSFontSelector.h in Headers */ = {isa = PBXBuildFile; fileRef = BC64B4D40CB4298A005F2B62 /* CSSFontSelector.h */; };
                 BC6D44BE0C07EFB60072D2C9 /* JSHTMLEmbedElementCustom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BC6D44BD0C07EFB60072D2C9 /* JSHTMLEmbedElementCustom.cpp */; };
                 BC6D44EC0C07F2ED0072D2C9 /* JSHTMLEmbedElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BC6D44EA0C07F2ED0072D2C9 /* JSHTMLEmbedElement.cpp */; };
@@ -7111 +7125 @@
                 BC5A86B40C3367E800EEA649 /* JSDOMSelection.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JSDOMSelection.h; sourceTree = "<group>"; };
                 BC5EC1760A507E3E006007F5 /* view-source.css */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text; path = "view-source.css"; sourceTree = "<group>"; };
+                BC64B4B80CB428C7005F2B62 /* FontSelector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FontSelector.h; sourceTree = "<group>"; };
+                BC64B4BA0CB42929005F2B62 /* FontCustomPlatformData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FontCustomPlatformData.cpp; sourceTree = "<group>"; };
+                BC64B4BB0CB42929005F2B62 /* FontCustomPlatformData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FontCustomPlatformData.h; sourceTree = "<group>"; };
+                BC64B4BC0CB42929005F2B62 /* FontPlatformDataMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = FontPlatformDataMac.mm; sourceTree = "<group>"; };
+                BC64B4C90CB4295D005F2B62 /* CachedFont.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CachedFont.cpp; sourceTree = "<group>"; };
+                BC64B4CA0CB4295D005F2B62 /* CachedFont.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CachedFont.h; sourceTree = "<group>"; };
+                BC64B4CD0CB4298A005F2B62 /* CSSFontFace.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSFontFace.cpp; sourceTree = "<group>"; };
+                BC64B4CE0CB4298A005F2B62 /* CSSFontFace.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSFontFace.h; sourceTree = "<group>"; };
+                BC64B4CF0CB4298A005F2B62 /* CSSFontFaceSource.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSFontFaceSource.cpp; sourceTree = "<group>"; };
+                BC64B4D00CB4298A005F2B62 /* CSSFontFaceSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSFontFaceSource.h; sourceTree = "<group>"; };
+                BC64B4D10CB4298A005F2B62 /* CSSFontFaceSrcValue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSFontFaceSrcValue.cpp; sourceTree = "<group>"; };
+                BC64B4D20CB4298A005F2B62 /* CSSFontFaceSrcValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSFontFaceSrcValue.h; sourceTree = "<group>"; };
+                BC64B4D30CB4298A005F2B62 /* CSSFontSelector.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSFontSelector.cpp; sourceTree = "<group>"; };
+                BC64B4D40CB4298A005F2B62 /* CSSFontSelector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSFontSelector.h; sourceTree = "<group>"; };
                 BC6D44BD0C07EFB60072D2C9 /* JSHTMLEmbedElementCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSHTMLEmbedElementCustom.cpp; sourceTree = "<group>"; };
                 BC6D44EA0C07F2ED0072D2C9 /* JSHTMLEmbedElement.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JSHTMLEmbedElement.cpp; sourceTree = "<group>"; };
@@ -8177 +8205 @@
                         isa = PBXGroup;
                         children = (
+                                BC64B4BA0CB42929005F2B62 /* FontCustomPlatformData.cpp */,
+                                BC64B4BB0CB42929005F2B62 /* FontCustomPlatformData.h */,
+                                BC64B4BC0CB42929005F2B62 /* FontPlatformDataMac.mm */,
                                 51E1ECAD0C91C54600DC255B /* AutodrainedPool.mm */,
                                 65A640F00533BB1F0085E777 /* BlockExceptions.h */,
@@ -10688 +10719 @@
                                 BCB16C000979C3BD00467741 /* CachedCSSStyleSheet.cpp */,
                                 BCB16C010979C3BD00467741 /* CachedCSSStyleSheet.h */,
+                                BC64B4C90CB4295D005F2B62 /* CachedFont.cpp */,
+                                BC64B4CA0CB4295D005F2B62 /* CachedFont.h */,
                                 BCB16C020979C3BD00467741 /* CachedImage.cpp */,
                                 BCB16C030979C3BD00467741 /* CachedImage.h */,
@@ -10810 +10843 @@
                                 BCC47E2409A3D6F100ADB771 /* FontFamily.cpp */,
                                 BCC47E2509A3D6F100ADB771 /* FontFamily.h */,
+                                BC64B4B80CB428C7005F2B62 /* FontSelector.h */,
                                 BCC71A120A0FF94D0014EE6E /* GlyphBuffer.h */,
                                 BC6DB4730A1A90FB00E5CD14 /* GlyphPageTreeNode.cpp */,
@@ -10966 +11000 @@
                         isa = PBXGroup;
                         children = (
+                                BC64B4CD0CB4298A005F2B62 /* CSSFontFace.cpp */,
+                                BC64B4CE0CB4298A005F2B62 /* CSSFontFace.h */,
+                                BC64B4CF0CB4298A005F2B62 /* CSSFontFaceSource.cpp */,
+                                BC64B4D00CB4298A005F2B62 /* CSSFontFaceSource.h */,
+                                BC64B4D10CB4298A005F2B62 /* CSSFontFaceSrcValue.cpp */,
+                                BC64B4D20CB4298A005F2B62 /* CSSFontFaceSrcValue.h */,
+                                BC64B4D30CB4298A005F2B62 /* CSSFontSelector.cpp */,
+                                BC64B4D40CB4298A005F2B62 /* CSSFontSelector.h */,
                                 A80E6CDA0A1989CA007FB8C5 /* Counter.h */,
                                 930705C709E0C95F00B17FE4 /* Counter.idl */,
@@ -13165 +13207 @@
                                 A8E545C00CA9D1C20097D09B /* DOMSVGDocument.h in Headers */,
                                 A8E545C10CA9D1C20097D09B /* DOMSVGDescElementInternal.h in Headers */,
+                                BC64B4B90CB428C7005F2B62 /* FontSelector.h in Headers */,
+                                BC64B4BE0CB42929005F2B62 /* FontCustomPlatformData.h in Headers */,
+                                BC64B4CC0CB4295D005F2B62 /* CachedFont.h in Headers */,
+                                BC64B4D60CB4298A005F2B62 /* CSSFontFace.h in Headers */,
+                                BC64B4D80CB4298A005F2B62 /* CSSFontFaceSource.h in Headers */,
+                                BC64B4DA0CB4298A005F2B62 /* CSSFontFaceSrcValue.h in Headers */,
+                                BC64B4DC0CB4298A005F2B62 /* CSSFontSelector.h in Headers */,
                         );
                         runOnlyForDeploymentPostprocessing = 0;
@@ -14639 +14688 @@
                                 AA4038900C4C0D8B00DB56DC /* SVGViewSpec.cpp in Sources */,
                                 B2CCEC470C6CA9F1006A5424 /* RenderSVGViewportContainer.cpp in Sources */,
+                                BC64B4BD0CB42929005F2B62 /* FontCustomPlatformData.cpp in Sources */,
+                                BC64B4BF0CB42929005F2B62 /* FontPlatformDataMac.mm in Sources */,
+                                BC64B4CB0CB4295D005F2B62 /* CachedFont.cpp in Sources */,
+                                BC64B4D50CB4298A005F2B62 /* CSSFontFace.cpp in Sources */,
+                                BC64B4D70CB4298A005F2B62 /* CSSFontFaceSource.cpp in Sources */,
+                                BC64B4D90CB4298A005F2B62 /* CSSFontFaceSrcValue.cpp in Sources */,
+                                BC64B4DB0CB4298A005F2B62 /* CSSFontSelector.cpp in Sources */,
                         );
                         runOnlyForDeploymentPostprocessing = 0;

trunk/WebCore/css/CSSComputedStyleDeclaration.cpp

@@ -1625 +1625 @@
         case CSS_PROP_SCROLLBAR_SHADOW_COLOR:
         case CSS_PROP_SCROLLBAR_TRACK_COLOR:
+        case CSS_PROP_SRC: // Only used in @font-face rules.
         case CSS_PROP_SIZE:
         case CSS_PROP_TEXT_LINE_THROUGH:

trunk/WebCore/css/CSSFontFaceRule.cpp

@@ -38 +38 @@
 }
 
+void CSSFontFaceRule::setDeclaration(PassRefPtr<CSSMutableStyleDeclaration> style)
+{
+    m_style = style;
+}
+
 String CSSFontFaceRule::cssText() const
 {
-    // FIXME: Implement!
-    return String();
+    String result("@font-face");
+    result += " { ";
+    result += m_style->cssText();
+    result += "}";
+    return result;
 }
 

trunk/WebCore/css/CSSFontFaceRule.h

@@ -26 +26 @@
 
 #include "CSSRule.h"
+#include <wtf/PassRefPtr.h>
 #include <wtf/RefPtr.h>
 
@@ -46 +47 @@
     virtual String cssText() const;
 
+    void setDeclaration(PassRefPtr<CSSMutableStyleDeclaration>);
+
 protected:
     RefPtr<CSSMutableStyleDeclaration> m_style;

trunk/WebCore/css/CSSGrammar.y

@@ -552 +552 @@
   : ':' IDENT
   ;
-
-font_face
-  : FONT_FACE_SYM maybe_space
-    '{' maybe_space declaration [ ';' maybe_space declaration ]* '}' maybe_space
-  ;
 */
 
@@ -569 +564 @@
 
 font_face:
-    FONT_FACE_SYM error invalid_block {
+    FONT_FACE_SYM maybe_space
+    '{' maybe_space declaration_list '}'  maybe_space {
+        $$ = static_cast<CSSParser*>(parser)->createFontFaceRule();
+    }
+    | FONT_FACE_SYM error invalid_block {
       $$ = 0;
     }
-  | FONT_FACE_SYM error ';' {
+    | FONT_FACE_SYM error ';' {
       $$ = 0;
     }

trunk/WebCore/css/CSSParser.cpp

@@ -30 +30 @@
 #include "CSSHelper.h"
 #include "CSSImageValue.h"
+#include "CSSFontFaceRule.h"
+#include "CSSFontFaceSrcValue.h"
 #include "CSSImportRule.h"
 #include "CSSInheritedValue.h"
@@ -1063 +1065 @@
             valid_primitive = true;
         break;
+
+    case CSS_PROP_SRC:  // Only used within @font-face, so cannot use inherit | initial or be !important.  This is a list of urls or local references.
+        return parseFontFaceSrc();
 
     /* CSS3 properties */
@@ -2462 +2467 @@
 }
 
+bool CSSParser::parseFontFaceSrc()
+{
+    CSSValueList* values = new CSSValueList();
+    Value* val;
+    bool expectComma = false;
+    bool allowFormat = false;
+    bool failed = false;
+    CSSFontFaceSrcValue* parsedValue = 0;
+    CSSFontFaceSrcValue* uriValue = 0;
+    while ((val = valueList->current())) {
+        parsedValue = 0;
+        if (val->unit == CSSPrimitiveValue::CSS_URI && !expectComma) {
+            String value = parseURL(domString(val->string));
+            parsedValue = new CSSFontFaceSrcValue(String(KURL(styleElement->baseURL().deprecatedString(), value.deprecatedString()).url()), false);
+            uriValue = parsedValue;
+            allowFormat = true;
+        } else if (val->unit == Value::Function) {
+            // There are two allowed functions: local() and format().             
+            String fname = domString(val->function->name).lower();
+            ValueList* args = val->function->args;
+            if (args && args->size() == 1) {
+                if (fname == "local(" && !expectComma) {
+                    // Parse it.
+                    expectComma = true;
+                    allowFormat = false;
+                    Value* a = args->current();
+                    uriValue = 0;
+                    parsedValue = new CSSFontFaceSrcValue(domString(a->string), true);
+                } else if (fname == "format(" && allowFormat && uriValue) {
+                    allowFormat = false;
+                    uriValue->setFormat(domString(args->current()->string));
+                    uriValue = 0;
+                    valueList->next();
+                    continue;
+                }
+            }
+        } else if (val->unit == Value::Operator && val->iValue == ',' && expectComma) {
+            expectComma = false;
+            allowFormat = false;
+            uriValue = 0;
+            valueList->next();
+            continue;
+        }
+    
+        if (parsedValue)
+            values->append(parsedValue);
+        else {
+            failed = true;
+            break;
+        }
+        valueList->next();
+    }
+    
+    if (values->length() && !failed) {
+        addProperty(CSS_PROP_SRC, values, important);
+        valueList->next();
+        return true;
+    }
+    
+    delete values;
+    return false;
+}
+
 bool CSSParser::parseColor(const String &name, RGBA32& rgb, bool strict)
 {
@@ -3325 +3393 @@
 }
 
+CSSRule* CSSParser::createFontFaceRule()
+{
+    CSSFontFaceRule* rule = new CSSFontFaceRule(styleElement);
+    m_parsedStyleObjects.append(rule);
+    rule->setDeclaration(new CSSMutableStyleDeclaration(rule, parsedProperties, numParsedProperties));
+    clearProperties();
+    return rule;
+}
+
 DeprecatedString deprecatedString(const ParseString& ps)
 {

trunk/WebCore/css/CSSParser.h

@@ -164 +164 @@
         static bool parseColor(const String&, RGBA32& rgb, bool strict);
 
+        bool parseFontFaceSrc();
+
 #if ENABLE(SVG)
         bool parseSVGValue(int propId, bool important);
@@ -194 +196 @@
         CSSRuleList* createRuleList();
         CSSRule* createStyleRule(CSSSelector*);
+        CSSRule* createFontFaceRule();
 
         MediaQueryExp* createFloatingMediaQueryExp(const AtomicString&, ValueList*);

trunk/WebCore/css/CSSPropertyNames.in

@@ -107 +107 @@
 scrollbar-track-color
 size
+src
 table-layout
 text-align

trunk/WebCore/css/CSSStyleSelector.cpp

@@ -28 +28 @@
 #include "CSSBorderImageValue.h"
 #include "CSSCursorImageValue.h"
+#include "CSSFontFace.h"
+#include "CSSFontFaceSource.h"
+#include "CSSFontFaceRule.h"
 #include "CSSImageValue.h"
 #include "CSSImportRule.h"
@@ -183 +186 @@
     typedef HashMap<AtomicStringImpl*, CSSRuleDataList*> AtomRuleMap;
     
-    void addRulesFromSheet(CSSStyleSheet* sheet, MediaQueryEvaluator* medium);
+    void addRulesFromSheet(CSSStyleSheet*, MediaQueryEvaluator*, CSSStyleSelector* = 0);
     
     void addRule(CSSStyleRule* rule, CSSSelector* sel);
@@ -199 +202 @@
     AtomRuleMap m_tagRules;
     CSSRuleDataList* m_universalRules;
-    
     unsigned m_ruleCount;
 };
@@ -260 +262 @@
 
         m_userStyle = new CSSRuleSet();
-        m_userStyle->addRulesFromSheet(m_userSheet.get(), m_medium);
+        m_userStyle->addRulesFromSheet(m_userSheet.get(), m_medium, this);
     }
 
@@ -269 +271 @@
     for (; it.current(); ++it)
         if (it.current()->isCSSStyleSheet() && !it.current()->disabled())
-            m_authorStyle->addRulesFromSheet(static_cast<CSSStyleSheet*>(it.current()), m_medium);
-
-}
-
-CSSStyleSelector::CSSStyleSelector(CSSStyleSheet *sheet)
-{
-    init();
-
-    if (!defaultStyle)
-        loadDefaultStyle();
-    FrameView *view = sheet->doc()->view();
-
-    if (view)
-        m_medium = new MediaQueryEvaluator(view->mediaType());
-    else
-        m_medium = new MediaQueryEvaluator("all");
-
-    Element* root = sheet->doc()->documentElement();
-    if (root)
-        m_rootDefaultStyle = styleForElement(root, 0, false, true);
-
-    if (m_rootDefaultStyle && view) {
-        delete m_medium;
-        m_medium = new MediaQueryEvaluator(view->mediaType(), view->frame()->page(), m_rootDefaultStyle);
-    }
-
-    m_authorStyle = new CSSRuleSet();
-    m_authorStyle->addRulesFromSheet(sheet, m_medium);
+            m_authorStyle->addRulesFromSheet(static_cast<CSSStyleSheet*>(it.current()), m_medium, this);
+
+    // Just delete our font selector if we end up with nothing but invalid @font-face rules.
+    if (m_fontSelector && m_fontSelector->isEmpty())
+        m_fontSelector = 0;
 }
 
@@ -791 +770 @@
             styleNotYetAvailable->ref();
             styleNotYetAvailable->setDisplay(NONE);
-            styleNotYetAvailable->font().update();
+            styleNotYetAvailable->font().update(m_fontSelector);
         }
         styleNotYetAvailable->ref();
@@ -1172 +1151 @@
     checkForTextSizeAdjust();
     checkForGenericFamilyChange(style, parentStyle);
-    style->font().update();
+    style->font().update(m_fontSelector);
     fontDirty = false;
 }
@@ -1686 +1665 @@
 }
 
-void CSSRuleSet::addRulesFromSheet(CSSStyleSheet* sheet,  MediaQueryEvaluator* medium)
+void CSSRuleSet::addRulesFromSheet(CSSStyleSheet* sheet,  MediaQueryEvaluator* medium, CSSStyleSelector* styleSelector)
 {
     if (!sheet || !sheet->isCSSStyleSheet())
@@ -1708 +1687 @@
             CSSImportRule* import = static_cast<CSSImportRule*>(item);
             if (!import->media() || medium->eval(import->media()))
-                addRulesFromSheet(import->styleSheet(), medium);
+                addRulesFromSheet(import->styleSheet(), medium, styleSelector);
         }
         else if(item->isMediaRule()) {
@@ -1723 +1702 @@
                         for (CSSSelector* s = rule->selector(); s; s = s->next())
                             addRule(rule, s);
-                        
+                    } else if (item->isFontFaceRule() && styleSelector) {
+                        // Add this font face to our set.
+                        const CSSFontFaceRule* fontFaceRule = static_cast<CSSFontFaceRule*>(item);
+                        styleSelector->ensureFontSelector()->addFontFaceRule(fontFaceRule);
                     }
                 }   // for rules
             }   // if rules
+        } else if (item->isFontFaceRule() && styleSelector) {
+            // Add this font face to our set.
+            const CSSFontFaceRule* fontFaceRule = static_cast<CSSFontFaceRule*>(item);
+            styleSelector->ensureFontSelector()->addFontFaceRule(fontFaceRule);
         }
     }
@@ -3343 +3329 @@
                         break;
                     case CSS_VAL_SERIF:
-                        face = settings->serifFontFamily();
+                        face = m_fontSelector ? "-webkit-serif" : settings->serifFontFamily();
                         fontDescription.setGenericFamily(FontDescription::SerifFamily);
                         break;
                     case CSS_VAL_SANS_SERIF:
-                        face = settings->sansSerifFontFamily();
+                        face = m_fontSelector ? "-webkit-sans-serif" : settings->sansSerifFontFamily();
                         fontDescription.setGenericFamily(FontDescription::SansSerifFamily);
                         break;
                     case CSS_VAL_CURSIVE:
-                        face = settings->cursiveFontFamily();
+                        face = m_fontSelector ? "-webkit-cursive" : settings->cursiveFontFamily();
                         fontDescription.setGenericFamily(FontDescription::CursiveFamily);
                         break;
                     case CSS_VAL_FANTASY:
-                        face = settings->fantasyFontFamily();
+                        face = m_fontSelector ? "-webkit-fantasy" : settings->fantasyFontFamily();
                         fontDescription.setGenericFamily(FontDescription::FantasyFamily);
                         break;
                     case CSS_VAL_MONOSPACE:
-                        face = settings->fixedFontFamily();
+                        face = m_fontSelector ? "-webkit-monospace" : settings->fixedFontFamily();
                         fontDescription.setGenericFamily(FontDescription::MonospaceFamily);
                         break;
@@ -3579 +3565 @@
 
             m_lineHeightValue = font->lineHeight.get();
+
             applyProperty(CSS_PROP_FONT_FAMILY, font->family.get());
         }
@@ -3849 +3836 @@
                 return;
         }
-        return;        
+        return;
+    case CSS_PROP_SRC: // Only used in @font-face rules.
+        return;
     case CSS_PROP__WEBKIT_BOX_DIRECTION:
         HANDLE_INHERIT_AND_INITIAL(boxDirection, BoxDirection)
@@ -4920 +4909 @@
 }
 
+CSSFontSelector* CSSStyleSelector::ensureFontSelector()
+{
+    if (!m_fontSelector.get())
+        m_fontSelector = new CSSFontSelector(m_document);
+    return m_fontSelector.get();
+}
+
 } // namespace WebCore

trunk/WebCore/css/CSSStyleSelector.h

@@ -25 +25 @@
 #define CSSStyleSelector_h
 
+#include "CSSFontSelector.h"
 #include "DeprecatedString.h"
 #include "RenderStyle.h"
 #include <wtf/HashSet.h>
 #include <wtf/Vector.h>
+#include <wtf/RefPtr.h>
 
 namespace WebCore {
@@ -35 +37 @@
 class CSSPrimitiveValue;
 class CSSProperty;
+class CSSFontFace;
+class CSSFontFaceRule;
 class CSSRuleData;
 class CSSRuleDataList;
@@ -79 +83 @@
     {
     public:
-        /**
-         * creates a new StyleSelector for a Document.
-         * goes through all StyleSheets defined in the document and
-         * creates a list of rules it needs to apply to objects
-         */
         CSSStyleSelector(Document*, const String& userStyleSheet, StyleSheetList *styleSheets, bool strictParsing);
-        /**
-         * same as above but for a single stylesheet.
-         */
-        CSSStyleSelector(CSSStyleSheet *sheet);
         ~CSSStyleSelector();
 
@@ -133 +128 @@
         bool hasSelectorForAttribute(const AtomicString &attrname);
  
+        CSSFontSelector* fontSelector() { return m_fontSelector.get(); }
+        CSSFontSelector* ensureFontSelector();
+
     protected:
 
@@ -227 +225 @@
         bool fontDirty;
         bool isXMLDoc;
-
-        HashSet<AtomicStringImpl *> m_selectorAttrs;
+        
+        RefPtr<CSSFontSelector> m_fontSelector;
+
+        HashSet<AtomicStringImpl*> m_selectorAttrs;
         
         void applyProperty(int id, CSSValue *value);
@@ -234 +234 @@
         void applySVGProperty(int id, CSSValue *value);
 #endif
+
+        friend class CSSRuleSet;
     };
 

trunk/WebCore/dom/Document.cpp

@@ -1024 +1024 @@
 
         _style->setFontDescription(fontDescription);
-        _style->font().update();
+        _style->font().update(0);
         if (inCompatMode())
             _style->setHtmlHacks(true); // enable html specific rendering tricks

trunk/WebCore/loader/Cache.cpp

@@ -25 +25 @@
 
 #include "CachedCSSStyleSheet.h"
+#include "CachedFont.h"
 #include "CachedImage.h"
 #include "CachedScript.h"
@@ -71 +72 @@
     case CachedResource::Script:
         return new CachedScript(docLoader, url.url(), *charset);
+    case CachedResource::FontResource:
+        return new CachedFont(docLoader, url.url());
 #if ENABLE(XSLT)
     case CachedResource::XSLStyleSheet:
@@ -557 +560 @@
                 break;
 #endif
+            case CachedResource::FontResource:
+                stats.fonts.count++;
+                stats.fonts.size += o->size();
+                stats.fonts.liveSize += o->referenced() ? o->size() : 0;
+                stats.fonts.decodedSize += o->decodedSize();
+                break;
 #if ENABLE(XBL)
             case CachedResource::XBL:

trunk/WebCore/loader/Cache.h

@@ -87 +87 @@
         TypeStatistic xblDocs;
 #endif
+        TypeStatistic fonts;
     };
 

trunk/WebCore/loader/CachedResource.h

@@ -48 +48 @@
         ImageResource,
         CSSStyleSheet,
-        Script
+        Script,
+        FontResource
 #if ENABLE(XSLT)
         , XSLStyleSheet

trunk/WebCore/loader/CachedResourceClient.h

@@ -36 +36 @@
 namespace WebCore {
 
+    class CachedFont;
     class CachedResource;
     class CachedImage;
@@ -67 +68 @@
         virtual void setXSLStyleSheet(const String& /*URL*/, const String& /*sheet*/) { }
 
+        virtual void fontLoaded(CachedFont*) {};
+
 #if ENABLE(XBL)
         virtual void setXBLDocument(const String& /*URL*/, XBL::XBLDocument*) { }

trunk/WebCore/loader/DocLoader.cpp

@@ -31 +31 @@
 #include "Cache.h"
 #include "CachedCSSStyleSheet.h"
+#include "CachedFont.h"
 #include "CachedImage.h"
 #include "CachedScript.h"
@@ -94 +95 @@
 }
 
+CachedFont* DocLoader::requestFont(const String& url)
+{
+    return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, url));
+}
+
 CachedCSSStyleSheet* DocLoader::requestCSSStyleSheet(const String& url, const String& charset, bool isUserStyleSheet)
 {

trunk/WebCore/loader/DocLoader.h

@@ -35 +35 @@
 
 class CachedCSSStyleSheet;
+class CachedFont;
 class CachedImage;
 class CachedScript;
@@ -57 +58 @@
     CachedCSSStyleSheet* requestUserCSSStyleSheet(const String& url, const String& charset);
     CachedScript* requestScript(const String& url, const String& charset);
+    CachedFont* requestFont(const String& url);
 
 #if ENABLE(XSLT)

trunk/WebCore/platform/Font.cpp

@@ -334 +334 @@
 }
 
+bool Font::operator==(const Font& other) const
+{
+    // Our FontData don't have to be checked, since checking the font description will be fine.
+    // FIXME: This does not work if the font was made with the FontPlatformData constructor.
+    if ((m_fontList && m_fontList->loadingCustomFonts()) ||
+        (other.m_fontList && other.m_fontList->loadingCustomFonts()))
+        return false;
+    
+    FontSelector* first = m_fontList ? m_fontList->fontSelector() : 0;
+    FontSelector* second = other.m_fontList ? other.m_fontList->fontSelector() : 0;
+    
+    return first == second
+           && m_fontDescription == other.m_fontDescription
+           && m_letterSpacing == other.m_letterSpacing
+           && m_wordSpacing == other.m_wordSpacing;
+}
+    
 // FIXME: It is unfortunate that this function needs to be passed the original cluster.
 // It is only required for the platform's FontCache::getFontDataForCharacters(), and it means
@@ -464 +481 @@
 }
 
-void Font::update() const
+void Font::update(PassRefPtr<FontSelector> fontSelector) const
 {
     // FIXME: It is pretty crazy that we are willing to just poke into a RefPtr, but it ends up 
@@ -472 +489 @@
     // and could eventually be rectified by using RefPtrs for Fonts themselves.
     if (!m_fontList)
-        m_fontList = new FontFallbackList;
-    m_fontList->invalidate();
+        m_fontList = new FontFallbackList();
+    m_fontList->invalidate(fontSelector);
     m_pageZero = 0;
     m_pages.clear();
@@ -651 +668 @@
 void Font::drawText(GraphicsContext* context, const TextRun& run, const TextStyle& style, const FloatPoint& point, int from, int to) const
 {
+    // Don't draw anything while we are using custom fonts that are in the process of loading.
+    if (m_fontList && m_fontList->loadingCustomFonts())
+        return;
+    
     to = (to == -1 ? run.length() : to);
     if (canUseGlyphCache(run))

trunk/WebCore/platform/Font.h

@@ -5 +5 @@
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2003, 2006 Apple Computer, Inc.
+ * Copyright (C) 2003, 2006, 2007 Apple Computer, Inc.
  *
  * This library is free software; you can redistribute it and/or
@@ -42 +42 @@
 class FontFallbackList;
 class FontPlatformData;
+class FontSelector;
 class GlyphBuffer;
 class GlyphPageTreeNode;
@@ -83 +84 @@
     Font& operator=(const Font&);
 
-    bool operator==(const Font& other) const
-    {
-        // Our FontData doesn't have to be checked, since checking the font description will be fine.
-        // FIXME: This does not work if the font was made with the FontPlatformData constructor.
-        return m_fontDescription == other.m_fontDescription
-            && m_letterSpacing == other.m_letterSpacing
-            && m_wordSpacing == other.m_wordSpacing;
-    }
-
+    bool operator==(const Font& other) const;
     bool operator!=(const Font& other) const {
         return !(*this == other);
@@ -101 +94 @@
     float size() const { return fontDescription().computedSize(); }
     
-    void update() const;
+    void update(PassRefPtr<FontSelector>) const;
 
     void drawText(GraphicsContext*, const TextRun&, const TextStyle&, const FloatPoint&, int from = 0, int to = -1) const;

trunk/WebCore/platform/FontCache.cpp

@@ -33 +33 @@
 #include "FontFallbackList.h"
 #include "FontPlatformData.h"
+#include "FontSelector.h"
 #include "StringHash.h"
 #include <wtf/HashMap.h>
@@ -213 +214 @@
 }
 
-const FontData* FontCache::getFontData(const Font& font, int& familyIndex)
+const FontData* FontCache::getFontData(const Font& font, int& familyIndex, FontSelector* fontSelector)
 {
     FontPlatformData* result = 0;
@@ -224 +225 @@
     while (currFamily && !result) {
         familyIndex++;
-        if (currFamily->family().length())
+        if (currFamily->family().length()) {
+            if (fontSelector) {
+                FontData* data = fontSelector->getFontData(font.fontDescription(), currFamily->family());
+                if (data)
+                    return data;
+            }
             result = getCachedFontPlatformData(font.fontDescription(), currFamily->family());
+        }
         currFamily = currFamily->next();
     }
@@ -241 +248 @@
         // We still don't have a result.  Hand back our last resort fallback font.  We only do the last resort fallback
         // when trying to find the primary font.  Otherwise our fallback will rely on the actual characters used.
-        result = getLastResortFallbackFont(font);
+        result = getLastResortFallbackFont(font.fontDescription());
 
     // Now that we have a result, we need to go from FontPlatformData -> FontData.

trunk/WebCore/platform/FontCache.h

@@ -44 +44 @@
 class Font;
 class FontDescription;
+class FontSelector;
 
 class FontCache {
 public:
-    static const FontData* getFontData(const Font&, int& familyIndex);
+    static const FontData* getFontData(const Font&, int& familyIndex, FontSelector*);
     
     // This method is implemented by the platform.
@@ -59 +60 @@
 #endif
 
-private:
+    static bool fontExists(const FontDescription&, const AtomicString& family);
+
     static FontPlatformData* getCachedFontPlatformData(const FontDescription&, const AtomicString& family, bool checkingAlternateName = false);
     static FontData* getCachedFontData(const FontPlatformData*);
+    static FontPlatformData* getLastResortFallbackFont(const FontDescription&);
     
-    // These three methods are implemented by each platform.
+private:
+    // These methods are implemented by each platform.
     static FontPlatformData* getSimilarFontPlatformData(const Font&);
-    static FontPlatformData* getLastResortFallbackFont(const Font&);
     static FontPlatformData* createFontPlatformData(const FontDescription&, const AtomicString& family);
 

trunk/WebCore/platform/FontData.cpp

@@ -35 +35 @@
 namespace WebCore {
 
-FontData::FontData(const FontPlatformData& f)
+FontData::FontData(const FontPlatformData& f, bool customFont, bool loading)
     : m_font(f)
     , m_treatAsFixedPitch(false)
+    , m_isCustomFont(customFont)
+    , m_isLoading(loading)
     , m_smallCapsFontData(0)
 {    
@@ -53 +55 @@
         return;
     }
+
     // 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 

trunk/WebCore/platform/FontData.h

@@ -43 +43 @@
 class FontDescription;
 class FontPlatformData;
+class SharedBuffer;
 class WidthMap;
 
@@ -49 +50 @@
 class FontData : Noncopyable {
 public:
-    FontData(const FontPlatformData&);
+    FontData(const FontPlatformData&, bool customFont = false, bool loading = false);
     ~FontData();
 
@@ -71 +72 @@
     void determinePitch();
     Pitch pitch() const { return m_treatAsFixedPitch ? FixedPitch : VariablePitch; }
+
+    bool isCustomFont() const { return m_isCustomFont; }
+    bool isLoading() const { return m_isLoading; }
 
     const GlyphData& missingGlyphData() const { return m_missingGlyphData; }
@@ -98 +102 @@
     void platformInit();
     void platformDestroy();
+    
+    void commonInit();
 
 public:
@@ -108 +114 @@
 
     FontPlatformData m_font;
+
     mutable GlyphWidthMap m_glyphToWidthMap;
 
     bool m_treatAsFixedPitch;
+
+    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.
+
     Glyph m_spaceGlyph;
     float m_spaceWidth;

trunk/WebCore/platform/FontFallbackList.cpp

@@ -36 +36 @@
 
 FontFallbackList::FontFallbackList()
-    : m_familyIndex(0), m_pitch(UnknownPitch)
+: m_familyIndex(0)
+, m_pitch(UnknownPitch)
+, m_loadingCustomFonts(false)
+, m_fontSelector(0)
 {
 }
 
-void FontFallbackList::invalidate()
+void FontFallbackList::invalidate(PassRefPtr<FontSelector> fontSelector)
 {
     m_fontList.clear();
     m_familyIndex = 0;    
     m_pitch = UnknownPitch;
+    m_loadingCustomFonts = false;
+    m_fontSelector = fontSelector;
 }
 
@@ -67 +72 @@
     // in |m_familyIndex|, so that we never scan the same spot in the list twice.  getFontData will adjust our
     // |m_familyIndex| as it scans for the right font to make.
-    const FontData* result = FontCache::getFontData(*font, m_familyIndex);
-    if (result)
+    const FontData* result = FontCache::getFontData(*font, m_familyIndex, m_fontSelector.get());
+    if (result) {
         m_fontList.append(result);
+        if (result->isLoading())
+            m_loadingCustomFonts = true;
+    }
     return result;
 }

trunk/WebCore/platform/FontFallbackList.h

@@ -27 +27 @@
 #include "FontData.h"
 #include "Shared.h"
+#include "FontSelector.h"
 #include <wtf/Vector.h>
 
@@ -36 +37 @@
 class FontDescription;
 class FontPlatformData;
+class FontSelector;
 
 const int cAllFamiliesScanned = -1;
@@ -43 +45 @@
     FontFallbackList();
 
-    void invalidate();
+    void invalidate(PassRefPtr<FontSelector>);
     
     bool isFixedPitch(const Font* f) const { if (m_pitch == UnknownPitch) determinePitch(f); return m_pitch == FixedPitch; };
     void determinePitch(const Font*) const;
+
+    bool loadingCustomFonts() const { return m_loadingCustomFonts; }
+
+    FontSelector* fontSelector() const { return m_fontSelector.get(); }
 
 private:
@@ -58 +64 @@
     mutable int m_familyIndex;
     mutable Pitch m_pitch;
-   
+    mutable bool m_loadingCustomFonts;
+    RefPtr<FontSelector> m_fontSelector;
+
     friend class Font;
 };

trunk/WebCore/platform/GlyphPageTreeNode.cpp

@@ -36 +36 @@
 namespace WebCore {
 
+HashMap<int, GlyphPageTreeNode*>* GlyphPageTreeNode::roots = 0;
+GlyphPageTreeNode* GlyphPageTreeNode::pageZeroRoot = 0;
+
 GlyphPageTreeNode* GlyphPageTreeNode::getRoot(unsigned pageNumber)
 {
-    static HashMap<int, GlyphPageTreeNode*> roots;
-    static GlyphPageTreeNode* pageZeroRoot;
-    GlyphPageTreeNode* node = pageNumber ? roots.get(pageNumber) : pageZeroRoot;
+    static bool initialized;
+    if (!initialized) {
+        initialized = true;
+        roots = new HashMap<int, GlyphPageTreeNode*>;
+        pageZeroRoot = new GlyphPageTreeNode;
+    }
+
+    GlyphPageTreeNode* node = pageNumber ? roots->get(pageNumber) : pageZeroRoot;
     if (!node) {
         node = new GlyphPageTreeNode;
@@ -47 +55 @@
 #endif
         if (pageNumber)
-            roots.set(pageNumber, node);
+            roots->set(pageNumber, node);
         else
             pageZeroRoot = node;
     }
     return node;
+}
+
+void GlyphPageTreeNode::pruneTreeCustomFontData(const FontData* fontData)
+{
+    // Enumerate all the roots and prune any tree that contains our custom font data.
+    if (roots) {
+        HashMap<int, GlyphPageTreeNode*>::iterator end = roots->end();
+        for (HashMap<int, GlyphPageTreeNode*>::iterator it = roots->begin(); it != end; ++it)
+            it->second->pruneCustomFontData(fontData);
+    }
+    
+    if (pageZeroRoot)
+        pageZeroRoot->pruneCustomFontData(fontData);
+}
+
+GlyphPageTreeNode::~GlyphPageTreeNode()
+{
+    deleteAllValues(m_children);
+    delete m_systemFallbackChild;
 }
 
@@ -64 +91 @@
     // The parent's page will be 0 if we are level one or the parent's font data
     // did not contain any glyphs for that page.
-    GlyphPage* parentPage = m_parent->m_page;
+    GlyphPage* parentPage = m_parent->page();
 
     // NULL FontData means we're being asked for the system fallback font.
@@ -120 +147 @@
             bool haveGlyphs = m_page->fill(buffer, bufferLength, fontData);
 
-            if (!haveGlyphs) {
-                delete m_page;
+            if (!haveGlyphs)
                 m_page = 0;
-            }
         } else if (parentPage && parentPage->owner() != m_parent) {
             // The page we're overriding may not be owned by our parent node.
@@ -169 +194 @@
                 }
 
-                if (!newGlyphs) {
+                if (!newGlyphs)
                     // We didn't override anything, so our override is just the parent page.
-                    delete m_page;
                     m_page = parentPage;
-                }
             }
         }
@@ -202 +225 @@
         child->m_parent = this;
         child->m_level = m_level + 1;
+        if (fontData && fontData->isCustomFont()) {
+            for (GlyphPageTreeNode* curr = this; curr; curr = curr->m_parent)
+                curr->m_customFontCount++;
+        }
+
 #ifndef NDEBUG
         child->m_pageNumber = m_pageNumber;
@@ -216 +244 @@
 }
 
-}
+void GlyphPageTreeNode::pruneCustomFontData(const FontData* fontData)
+{
+    if (!fontData || !m_customFontCount)
+        return;
+        
+    // Prune any branch that contains this FontData.
+    GlyphPageTreeNode* node = m_children.get(fontData);
+    if (node) {
+        m_children.remove(fontData);
+        unsigned fontCount = node->m_customFontCount + 1;
+        delete node;
+        for (GlyphPageTreeNode* curr = this; curr; curr = curr->m_parent)
+            curr->m_customFontCount -= fontCount;
+    }
+    
+    // Check any branches that remain that still have custom fonts underneath them.
+    if (!m_customFontCount)
+        return;
+    HashMap<const FontData*, GlyphPageTreeNode*>::iterator end = m_children.end();
+    for (HashMap<const FontData*, GlyphPageTreeNode*>::iterator it = m_children.begin(); it != end; ++it)
+        it->second->pruneCustomFontData(fontData);
+}
+
+}

trunk/WebCore/platform/GlyphPageTreeNode.h

@@ -1 +1 @@
 /*
- * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
+ * Copyright (C) 2006, 2007 Apple Computer, Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30 +30 @@
 #define GlyphPageTreeNode_h
 
+#include "Shared.h"
 #include <wtf/unicode/Unicode.h>
 #include <wtf/Noncopyable.h>
@@ -56 +57 @@
 // although multiple nodes may reference it as their "page" if they are supposed
 // to be overriding the parent's node, but provide no additional information.
-struct GlyphPage {
+struct GlyphPage : public Shared<GlyphPage> {
     GlyphPage()
         : m_owner(0)
@@ -110 +111 @@
     GlyphPageTreeNode()
         : m_parent(0)
-        , m_page(0)
         , m_level(0)
         , m_isSystemFallback(false)
         , m_systemFallbackChild(0)
+        , m_customFontCount(0)
 #ifndef NDEBUG
         , m_pageNumber(0)
@@ -120 +121 @@
     }
 
+    ~GlyphPageTreeNode();
+
+    static HashMap<int, GlyphPageTreeNode*>* roots;
+    static GlyphPageTreeNode* pageZeroRoot;
+
     static GlyphPageTreeNode* getRootChild(const FontData* fontData, unsigned pageNumber)
     {
@@ -125 +131 @@
     }
 
+    static void pruneTreeCustomFontData(const FontData*);
+
+    void pruneCustomFontData(const FontData*);
+
     GlyphPageTreeNode* parent() const { return m_parent; }
     GlyphPageTreeNode* getChild(const FontData*, unsigned pageNumber);
 
     // Returns a page of glyphs (or NULL if there are no glyphs in this page's character range).
-    GlyphPage* page() const { return m_page; }
+    GlyphPage* page() const { return m_page.get(); }
 
     // Returns the level of this node. See class-level comment.
@@ -142 +152 @@
 
     GlyphPageTreeNode* m_parent;
-    GlyphPage* m_page;
+    RefPtr<GlyphPage> m_page;
     unsigned m_level;
     bool m_isSystemFallback;
     HashMap<const FontData*, GlyphPageTreeNode*> m_children;
     GlyphPageTreeNode* m_systemFallbackChild;
+    unsigned m_customFontCount;
+
 #ifndef NDEBUG
     unsigned m_pageNumber;

trunk/WebCore/platform/PopupMenuClient.h

@@ -26 +26 @@
 class Color;
 class Document;
+class FontSelector;
 class String;
 class RenderStyle;
@@ -51 +52 @@
     virtual bool valueShouldChangeOnHotTrack() const = 0;
     virtual void setTextFromItem(unsigned listIndex) = 0;
+    virtual FontSelector* fontSelector() const = 0;
 };
 

trunk/WebCore/platform/mac/FontCacheMac.mm

@@ -142 +142 @@
 
     NSFontTraitMask traits = [manager traitsOfFont:nsFont];
-    if (platformData.syntheticBold)
+    if (platformData.m_syntheticBold)
         traits |= NSBoldFontMask;
-    if (platformData.syntheticOblique)
+    if (platformData.m_syntheticOblique)
         traits |= NSItalicFontMask;
 
@@ -186 +186 @@
 }
 
-FontPlatformData* FontCache::getLastResortFallbackFont(const Font& font)
+FontPlatformData* FontCache::getLastResortFallbackFont(const FontDescription& fontDescription)
 {
     static AtomicString timesStr("Times");
@@ -193 +193 @@
     // 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.
-    FontPlatformData* platformFont = getCachedFontPlatformData(font.fontDescription(), timesStr);
+    FontPlatformData* platformFont = getCachedFontPlatformData(fontDescription, timesStr);
     if (!platformFont)
         // The Times fallback will almost always work, but in the highly unusual case where
@@ -199 +199 @@
         // guaranteed to be there, according to Nathan Taylor. This is good enough
         // to avoid a crash at least.
-        platformFont = getCachedFontPlatformData(font.fontDescription(), lucidaGrandeStr);
+        platformFont = getCachedFontPlatformData(fontDescription, lucidaGrandeStr);
 
     return platformFont;
 }
 
-FontPlatformData* FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family)
+bool FontCache::fontExists(const FontDescription& fontDescription, const AtomicString& family)
 {
     NSFontTraitMask traits = 0;
@@ -214 +214 @@
     
     NSFont* nsFont = [WebFontCache fontWithFamily:family traits:traits size:size];
+    return nsFont != 0;
+}
+
+FontPlatformData* FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family)
+{
+    NSFontTraitMask traits = 0;
+    if (fontDescription.italic())
+        traits |= NSItalicFontMask;
+    if (fontDescription.bold())
+        traits |= NSBoldFontMask;
+    float size = fontDescription.computedPixelSize();
+    
+    NSFont* nsFont = [WebFontCache fontWithFamily:family traits:traits size:size];
     if (!nsFont)
         return 0;
@@ -225 +238 @@
     // Use the correct font for print vs. screen.
     result->setFont(fontDescription.usePrinterFont() ? [nsFont printerFont] : [nsFont screenFont]);
-    result->syntheticBold = (traits & NSBoldFontMask) && !(actualTraits & NSBoldFontMask);
-    result->syntheticOblique = (traits & NSItalicFontMask) && !(actualTraits & NSItalicFontMask);
+    result->m_syntheticBold = (traits & NSBoldFontMask) && !(actualTraits & NSBoldFontMask);
+    result->m_syntheticOblique = (traits & NSItalicFontMask) && !(actualTraits & NSItalicFontMask);
     return result;
 }

trunk/WebCore/platform/mac/FontDataMac.mm

@@ -36 +36 @@
 #import "FontCache.h"
 #import "FontDescription.h"
+#import "SharedBuffer.h"
 #import "WebCoreSystemInterface.h"
 #import <ApplicationServices/ApplicationServices.h>
@@ -55 +56 @@
 bool initFontData(FontData* fontData)
 {
+    if (!fontData->m_font.m_cgFont)
+        return false;
+
     ATSUStyle fontStyle;
     if (ATSUCreateStyle(&fontStyle) != noErr)
         return false;
     
-    ATSUFontID fontId = wkGetNSFontATSUFontId(fontData->m_font.font());
+    ATSUFontID fontId = fontData->m_font.m_atsuFontID;
     if (!fontId) {
         ATSUDisposeStyle(fontStyle);
@@ -99 +103 @@
     m_checkedShapesArabic = false;
     m_shapesArabic = false;
-    
-    m_syntheticBoldOffset = m_font.syntheticBold ? 1.0f : 0.f;
+
+    m_syntheticBoldOffset = m_font.m_syntheticBold ? 1.0f : 0.f;
     
     bool failedSetup = false;
@@ -161 +165 @@
     int iDescent;
     int iLineGap;
-    wkGetFontMetrics(wkGetCGFontFromNSFont(m_font.font()), &iAscent, &iDescent, &iLineGap, &m_unitsPerEm); 
-    float pointSize = [m_font.font() pointSize];
+    wkGetFontMetrics(m_font.m_cgFont, &iAscent, &iDescent, &iLineGap, &m_unitsPerEm); 
+    float pointSize = m_font.m_size;
     float fAscent = scaleEmToUnits(iAscent, m_unitsPerEm) * pointSize;
     float fDescent = -scaleEmToUnits(iDescent, m_unitsPerEm) * pointSize;
@@ -215 +219 @@
 {
     if (!m_smallCapsFontData) {
-        NS_DURING
+        if (isCustomFont()) {
+            FontPlatformData smallCapsFontData(m_font);
+            smallCapsFontData.m_size = smallCapsFontData.m_size * smallCapsFontSizeMultiplier;
+            m_smallCapsFontData = new FontData(smallCapsFontData, true, false);
+        } else {
+            NS_DURING
             float size = [m_font.font() pointSize] * smallCapsFontSizeMultiplier;
             FontPlatformData smallCapsFont([[NSFontManager sharedFontManager] convertFont:m_font.font() toSize:size]);
@@ -227 +236 @@
                 NSFontTraitMask fontTraits = [fontManager traitsOfFont:m_font.font()];
 
-                if (m_font.syntheticBold)
+                if (m_font.m_syntheticBold)
                     fontTraits |= NSBoldFontMask;
-                if (m_font.syntheticOblique)
+                if (m_font.m_syntheticOblique)
                     fontTraits |= NSItalicFontMask;
 
                 NSFontTraitMask smallCapsFontTraits = [fontManager traitsOfFont:smallCapsFont.font()];
-                smallCapsFont.syntheticBold = (fontTraits & NSBoldFontMask) && !(smallCapsFontTraits & NSBoldFontMask);
-                smallCapsFont.syntheticOblique = (fontTraits & NSItalicFontMask) && !(smallCapsFontTraits & NSItalicFontMask);
+                smallCapsFont.m_syntheticBold = (fontTraits & NSBoldFontMask) && !(smallCapsFontTraits & NSBoldFontMask);
+                smallCapsFont.m_syntheticOblique = (fontTraits & NSItalicFontMask) && !(smallCapsFontTraits & NSItalicFontMask);
 
                 m_smallCapsFontData = FontCache::getCachedFontData(&smallCapsFont);
             }
-        NS_HANDLER
+
+            NS_HANDLER
             NSLog(@"uncaught exception selecting font for small caps: %@", localException);
-        NS_ENDHANDLER
+            NS_ENDHANDLER
+        }
     }
     return m_smallCapsFontData;
@@ -278 +289 @@
 float FontData::platformWidthForGlyph(Glyph glyph) const
 {
-    NSFont *font = m_font.font();
-    float pointSize = [font pointSize];
+    NSFont* font = m_font.font();
+    float pointSize = m_font.m_size;
     CGAffineTransform m = CGAffineTransformMakeScale(pointSize, pointSize);
     CGSize advance;
-    if (!wkGetGlyphTransformedAdvances(wkGetCGFontFromNSFont(font), font, &m, &glyph, &advance)) {
+    if (!wkGetGlyphTransformedAdvances(m_font.m_cgFont, font, &m, &glyph, &advance)) {
         LOG_ERROR("Unable to cache glyph widths for %@ %f", [font displayName], pointSize);
         advance.width = 0;
@@ -295 +306 @@
     m_checkedShapesArabic = true;
     
-    ATSUFontID fontID = wkGetNSFontATSUFontId(m_font.font());
+    ATSUFontID fontID = m_font.m_atsuFontID;
     if (!fontID) {
         LOG_ERROR("unable to get ATSUFontID for %@", m_font.font());

trunk/WebCore/platform/mac/FontMac.mm

@@ -116 +116 @@
         
         CGAffineTransform transform = CGAffineTransformMakeScale(1, -1);
-        if (fontData->m_font.syntheticOblique)
+        if (fontData->m_font.m_syntheticOblique)
             transform = CGAffineTransformConcat(transform, CGAffineTransformMake(1, 0, -tanf(SYNTHETIC_OBLIQUE_ANGLE * acosf(0) / 90), 1, 0, 0)); 
         Fixed fontSize = FloatToFixed([fontData->m_font.font() pointSize]);
@@ -625 +625 @@
     }
     
-    CGContextSetFont(cgContext, wkGetCGFontFromNSFont(drawFont));
-
-    CGAffineTransform matrix;
-    memcpy(&matrix, [drawFont matrix], sizeof(matrix));
+    CGContextSetFont(cgContext, platformData.m_cgFont);
+
+    CGAffineTransform matrix = CGAffineTransformIdentity;
+    if (drawFont)
+        memcpy(&matrix, [drawFont matrix], sizeof(matrix));
     matrix.b = -matrix.b;
     matrix.d = -matrix.d;
-    if (platformData.syntheticOblique)
+    if (platformData.m_syntheticOblique)
         matrix = CGAffineTransformConcat(matrix, CGAffineTransformMake(1, 0, -tanf(SYNTHETIC_OBLIQUE_ANGLE * acosf(0) / 90), 1, 0, 0)); 
     CGContextSetTextMatrix(cgContext, matrix);
 
-    wkSetCGFontRenderingMode(cgContext, drawFont);
-    CGContextSetFontSize(cgContext, 1.0f);
-
+    if (drawFont) {
+        wkSetCGFontRenderingMode(cgContext, drawFont);
+        CGContextSetFontSize(cgContext, 1.0f);
+    } else
+        CGContextSetFontSize(cgContext, platformData.m_size);
+    
     CGContextSetTextPosition(cgContext, point.x(), point.y());
     CGContextShowGlyphsWithAdvances(cgContext, glyphBuffer.glyphs(from), glyphBuffer.advances(from), numGlyphs);

trunk/WebCore/platform/mac/FontPlatformData.h

@@ -33 +33 @@
 #endif
 
+typedef struct CGFont* CGFontRef;
+typedef UInt32 ATSUFontID;
+
 #include <CoreFoundation/CFBase.h>
 #include <objc/objc-auto.h>
@@ -42 +45 @@
 
     FontPlatformData(Deleted)
-    : syntheticBold(false), syntheticOblique(false), m_font((NSFont*)-1)
+    : m_syntheticBold(false), m_syntheticOblique(false), m_cgFont(0), m_atsuFontID(0), m_size(0), m_font((NSFont*)-1)
     {}
 
-    FontPlatformData(NSFont* f = 0, bool b = false, bool o = false)
-    : syntheticBold(b), syntheticOblique(o), m_font(f)
+    FontPlatformData(NSFont* f = 0, bool b = false, bool o = false);
+    
+    FontPlatformData(CGFontRef f, ATSUFontID fontID, float s, bool b , bool o)
+    : m_syntheticBold(b), m_syntheticOblique(o), m_cgFont(f), m_atsuFontID(fontID), m_size(s), m_font(0)
     {
-        if (f) 
-            CFRetain(f);
     }
 
-    FontPlatformData(const FontPlatformData& f)
-    {
-        m_font = (f.m_font && f.m_font != (NSFont*)-1) ? (NSFont*)CFRetain(f.m_font) : f.m_font;
-        syntheticBold = f.syntheticBold;
-        syntheticOblique = f.syntheticOblique;
-    }
+    FontPlatformData(const FontPlatformData& f);
+    
+    ~FontPlatformData();
 
-    ~FontPlatformData()
-    {
-        if (m_font && m_font != (NSFont*)-1)
-            CFRelease(m_font);
-    }
-
-    bool syntheticBold;
-    bool syntheticOblique;
+    bool m_syntheticBold;
+    bool m_syntheticOblique;
+    
+    CGFontRef m_cgFont; // It is not necessary to refcount this, since either an NSFont owns it or some CachedFont has it referenced.
+    ATSUFontID m_atsuFontID;
+    float m_size;
 
     unsigned hash() const
-    { 
-        uintptr_t hashCodes[2] = { (uintptr_t)m_font, syntheticBold << 1 | syntheticOblique };
+    {
+        ASSERT(m_font != 0 || m_cgFont == 0);
+        uintptr_t hashCodes[2] = { (uintptr_t)m_font, m_syntheticBold << 1 | m_syntheticOblique };
         return StringImpl::computeHash(reinterpret_cast<UChar*>(hashCodes), sizeof(hashCodes) / sizeof(UChar));
     }
@@ -76 +75 @@
     bool operator==(const FontPlatformData& other) const
     { 
-        return m_font == other.m_font && syntheticBold == other.syntheticBold && syntheticOblique == other.syntheticOblique;
+        return m_font == other.m_font && m_syntheticBold == other.m_syntheticBold && m_syntheticOblique == other.m_syntheticOblique && 
+               m_cgFont == other.m_cgFont && m_size == other.m_size && m_atsuFontID == other.m_atsuFontID;
     }
+
     NSFont *font() const { return m_font; }
-    void setFont(NSFont* font) {
-        if (m_font == font)
-            return;
-        if (font && font != (NSFont*)-1)
-            CFRetain(font);
-        if (m_font && m_font != (NSFont*)-1)
-            CFRelease(m_font);
-        m_font = font;
-    }
+    void setFont(NSFont* font);
+
 private:
     NSFont *m_font;

trunk/WebCore/platform/mac/WebCoreSystemInterface.h

@@ -90 +90 @@
 extern OSStatus (*wkGetATSStyleGroup)(ATSUStyle, void** styleGroup);
 extern CGFontRef (*wkGetCGFontFromNSFont)(NSFont*);
-extern ATSGlyphRef (*wkGetDefaultGlyphForChar)(NSFont*, UniChar);
 extern NSFont* (*wkGetFontInLanguageForRange)(NSFont*, NSString*, NSRange);
 extern NSFont* (*wkGetFontInLanguageForCharacter)(NSFont*, UniChar);

trunk/WebCore/platform/mac/WebCoreSystemInterface.mm

@@ -39 +39 @@
 OSStatus (*wkGetATSStyleGroup)(ATSUStyle, void** styleGroup);
 CGFontRef (*wkGetCGFontFromNSFont)(NSFont*);
-ATSGlyphRef (*wkGetDefaultGlyphForChar)(NSFont*, UniChar);
 NSFont* (*wkGetFontInLanguageForRange)(NSFont*, NSString*, NSRange);
 NSFont* (*wkGetFontInLanguageForCharacter)(NSFont*, UniChar);

trunk/WebCore/platform/win/FontCacheWin.cpp

@@ -118 +118 @@
 }
 
-FontPlatformData* FontCache::getLastResortFallbackFont(const Font& font)
+FontPlatformData* FontCache::getLastResortFallbackFont(const FontDescription& fontDescription)
 {
     // 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.
     static AtomicString timesStr("Times New Roman");
-    return getCachedFontPlatformData(font.fontDescription(), timesStr);
-}
-
-FontPlatformData* FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family)
+    return getCachedFontPlatformData(fontDescription, timesStr);
+}
+
+bool FontCache::fontExists(const FontDescription& fontDescription, const AtomicString& family)
 {
     LOGFONT winfont;
@@ -172 +172 @@
     ReleaseDC(0, dc);
 
+    DeleteObject(hfont);
+
+    return !wcsicmp(winfont.lfFaceName, name);
+}
+
+FontPlatformData* FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family)
+{
+    LOGFONT winfont;
+
+    // The size here looks unusual.  The negative number is intentional.  The logical size constant is 32.
+    winfont.lfHeight = -fontDescription.computedPixelSize() * 32;
+    winfont.lfWidth = 0;
+    winfont.lfEscapement = 0;
+    winfont.lfOrientation = 0;
+    winfont.lfUnderline = false;
+    winfont.lfStrikeOut = false;
+    winfont.lfCharSet = DEFAULT_CHARSET;
+#if PLATFORM(CG)
+    winfont.lfOutPrecision = OUT_TT_ONLY_PRECIS;
+#else
+    winfont.lfOutPrecision = OUT_TT_PRECIS;
+#endif
+    winfont.lfQuality = 5; // Force cleartype.
+    winfont.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
+    winfont.lfItalic = fontDescription.italic();
+
+    // FIXME: Support weights for real.  Do our own enumeration of the available weights.
+    // We can't rely on Windows here, since we need to follow the CSS2 algorithm for how to fill in
+    // gaps in the weight list.
+    // FIXME: Hardcoding Lucida Grande for now.  It uses different weights than typical Win32 fonts
+    // (500/600 instead of 400/700).
+    static AtomicString lucidaStr("Lucida Grande");
+    if (equalIgnoringCase(family, lucidaStr))
+        winfont.lfWeight = fontDescription.bold() ? 600 : 500;
+    else
+        winfont.lfWeight = fontDescription.bold() ? 700 : 400;
+    int len = min(family.length(), (unsigned int)LF_FACESIZE - 1);
+    memcpy(winfont.lfFaceName, family.characters(), len * sizeof(WORD));
+    winfont.lfFaceName[len] = '\0';
+
+    HFONT hfont = CreateFontIndirect(&winfont);
+    // Windows will always give us a valid pointer here, even if the face name is non-existent.  We have to double-check
+    // and see if the family name was really used.
+    HDC dc = GetDC((HWND)0);
+    SaveDC(dc);
+    SelectObject(dc, hfont);
+    WCHAR name[LF_FACESIZE];
+    GetTextFace(dc, LF_FACESIZE, name);
+    RestoreDC(dc, -1);
+    ReleaseDC(0, dc);
+
     if (_wcsicmp(winfont.lfFaceName, name)) {
         DeleteObject(hfont);

trunk/WebCore/platform/win/FontCustomPlatformData.h

@@ -1 @@
-/**
- * This file is part of the DOM implementation for KDE.
- *
- * (C) 1999-2003 Lars Knoll (knoll@kde.org)
- * (C) 2002-2003 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2002, 2005, 2006 Apple Computer, Inc.
+/*
+ * Copyright (C) 2007 Apple Computer, Inc.
  *
  * This library is free software; you can redistribute it and/or
@@ -18 +14 @@
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
+ * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
  */
 
-#include "config.h"
-#include "CSSFontFaceRule.h"
+#ifndef FontCustomPlatformData_h
+#define FontCustomPlatformData_h
 
-#include "CSSMutableStyleDeclaration.h"
+#include <wtf/Noncopyable.h>
+
+typedef struct CGFont* CGFontRef;
 
 namespace WebCore {
 
-CSSFontFaceRule::CSSFontFaceRule(StyleBase* parent)
-    : CSSRule(parent)
-{
+class FontPlatformData;
+class SharedBuffer;
+
+struct FontCustomPlatformData : Noncopyable {
+    FontCustomPlatformData(CGFontRef cgFont)
+    : m_cgFont(cgFont)
+    {}
+    ~FontCustomPlatformData();
+
+    FontPlatformData fontPlatformData(int size, bool bold, bool italic);
+
+    CGFontRef m_cgFont;
+};
+
+FontCustomPlatformData* createFontCustomPlatformData(SharedBuffer* buffer);
+
 }
 
-CSSFontFaceRule::~CSSFontFaceRule()
-{
-}
-
-String CSSFontFaceRule::cssText() const
-{
-    // FIXME: Implement!
-    return String();
-}
-
-} // namespace WebCore
+#endif

trunk/WebCore/platform/win/FontDataWin.cpp

@@ -46 +46 @@
 using std::max;
 
+const float cSmallCapsFontSizeMultiplier = 0.7f;
+
 static inline float scaleEmToUnits(float x, unsigned unitsPerEm) { return unitsPerEm ? x / (float)unitsPerEm : x; }
 
 void FontData::platformInit()
 {    
-    HDC dc = GetDC(0);
-    SaveDC(dc);
-
-    SelectObject(dc, m_font.hfont());
-
-    int faceLength = GetTextFace(dc, 0, 0);
-    Vector<TCHAR> faceName(faceLength);
-    GetTextFace(dc, faceLength, faceName.data());
-
     m_syntheticBoldOffset = m_font.syntheticBold() ? 1.0f : 0.f;
 
@@ -65 +58 @@
     int iDescent = CGFontGetDescent(font);
     int iLineGap = CGFontGetLeading(font);
-    unsigned unitsPerEm = CGFontGetUnitsPerEm(font);
+    m_unitsPerEm = CGFontGetUnitsPerEm(font);
     float pointSize = m_font.size();
-    float fAscent = scaleEmToUnits(iAscent, unitsPerEm) * pointSize;
-    float fDescent = -scaleEmToUnits(iDescent, unitsPerEm) * pointSize;
-    float fLineGap = scaleEmToUnits(iLineGap, unitsPerEm) * pointSize;
-
-    m_isSystemFont = !_tcscmp(faceName.data(), _T("Lucida Grande"));
-    
-    // We need to adjust Times, Helvetica, and Courier to closely match the
-    // vertical metrics of their Microsoft counterparts that are the de facto
-    // web standard. The AppKit adjustment of 20% is too big and is
-    // incorrectly added to line spacing, so we use a 15% adjustment instead
-    // and add it to the ascent.
-    if (!_tcscmp(faceName.data(), _T("Times")) || !_tcscmp(faceName.data(), _T("Helvetica")) || !_tcscmp(faceName.data(), _T("Courier")))
-        fAscent += floorf(((fAscent + fDescent) * 0.15f) + 0.5f);
-
-    m_unitsPerEm = 1; // FIXME!
+    float fAscent = scaleEmToUnits(iAscent, m_unitsPerEm) * pointSize;
+    float fDescent = -scaleEmToUnits(iDescent, m_unitsPerEm) * pointSize;
+    float fLineGap = scaleEmToUnits(iLineGap, m_unitsPerEm) * pointSize;
+
+    m_isSystemFont = false;
+    if (!isCustomFont()) {
+        HDC dc = GetDC(0);
+        HGDIOBJ oldFont = SelectObject(dc, m_font.hfont());
+        int faceLength = GetTextFace(dc, 0, 0);
+        Vector<TCHAR> faceName(faceLength);
+        GetTextFace(dc, faceLength, faceName.data());
+        m_isSystemFont = !_tcscmp(faceName.data(), _T("Lucida Grande"));
+        SelectObject(dc, oldFont);
+        ReleaseDC(0, dc);
+
+        // We need to adjust Times, Helvetica, and Courier to closely match the
+        // vertical metrics of their Microsoft counterparts that are the de facto
+        // web standard. The AppKit adjustment of 20% is too big and is
+        // incorrectly added to line spacing, so we use a 15% adjustment instead
+        // and add it to the ascent.
+        if (!_tcscmp(faceName.data(), _T("Times")) || !_tcscmp(faceName.data(), _T("Helvetica")) || !_tcscmp(faceName.data(), _T("Courier")))
+            fAscent += floorf(((fAscent + fDescent) * 0.15f) + 0.5f);
+    }
 
     m_ascent = lroundf(fAscent);
@@ -98 +99 @@
         // poorly if we return an accurate height. Classic case is Times 13 point,
         // which has an "x" that is 7x6 pixels.
-        m_xHeight = scaleEmToUnits(max(CGRectGetMaxX(xBox), CGRectGetMaxY(xBox)), unitsPerEm) * pointSize;
+        m_xHeight = scaleEmToUnits(max(CGRectGetMaxX(xBox), CGRectGetMaxY(xBox)), m_unitsPerEm) * pointSize;
     } else {
         int iXHeight = CGFontGetXHeight(font);
-        m_xHeight = scaleEmToUnits(iXHeight, unitsPerEm) * pointSize;
-    }
-
-    RestoreDC(dc, -1);
-    ReleaseDC(0, dc);
+        m_xHeight = scaleEmToUnits(iXHeight, m_unitsPerEm) * pointSize;
+    }
 
     m_scriptCache = 0;
@@ -113 +111 @@
 void FontData::platformDestroy()
 {
-    CGFontRelease(m_font.cgFont());
-    DeleteObject(m_font.hfont());
+    if (!isCustomFont()) {
+        DeleteObject(m_font.hfont());
+        CGFontRelease(m_font.cgFont());
+    }
 
     // We don't hash this on Win32, so it's effectively owned by us.
@@ -126 +126 @@
 {
     if (!m_smallCapsFontData) {
-        LOGFONT winfont;
-        GetObject(m_font.hfont(), sizeof(LOGFONT), &winfont);
-        int smallCapsHeight = lroundf(0.70f * fontDescription.computedSize());
-        winfont.lfHeight = -smallCapsHeight * 32;
-        HFONT hfont = CreateFontIndirect(&winfont);
-        m_smallCapsFontData = new FontData(FontPlatformData(hfont, smallCapsHeight, fontDescription.bold(), fontDescription.italic()));
+        int smallCapsHeight = lroundf(cSmallCapsFontSizeMultiplier * m_font.m_size);
+        if (isCustomFont()) {
+            FontPlatformData smallCapsFontData(m_font);
+            smallCapsFontData.m_size = smallCapsHeight;
+            m_smallCapsFontData = new FontData(smallCapsFontData, true, false);
+        } else {
+            LOGFONT winfont;
+            GetObject(m_font.hfont(), sizeof(LOGFONT), &winfont);
+            winfont.lfHeight = -smallCapsHeight * 32;
+            HFONT hfont = CreateFontIndirect(&winfont);
+            m_smallCapsFontData = new FontData(FontPlatformData(hfont, smallCapsHeight, fontDescription.bold(), fontDescription.italic()));
+        }
     }
     return m_smallCapsFontData;
@@ -138 +144 @@
 bool FontData::containsCharacters(const UChar* characters, int length) const
 {
+    // FIXME: Support custom fonts.
+    if (isCustomFont())
+        return false;
+
     // FIXME: Microsoft documentation seems to imply that characters can be output using a given font and DC
     // merely by testing code page intersection.  This seems suspect though.  Can't a font only partially
@@ -170 +180 @@
 void FontData::determinePitch()
 {
+    if (isCustomFont()) {
+        m_treatAsFixedPitch = false;
+        return;
+    }
+
     // TEXTMETRICS have this.  Set m_treatAsFixedPitch based off that.
     HDC dc = GetDC((HWND)0);

trunk/WebCore/platform/win/FontPlatformData.h

@@ -44 +44 @@
     , m_cgFont(NULL)
     , m_size(0)
+    , m_syntheticBold(false)
+    , m_syntheticOblique(false)
     {}
 
@@ -50 +52 @@
     , m_cgFont(NULL)
     , m_size(0)
+    , m_syntheticBold(false)
+    , m_syntheticOblique(false)
     {}
 
     FontPlatformData(HFONT, int size, bool bold, bool oblique);
+    FontPlatformData(CGFontRef, int size, bool bold, bool oblique);
     ~FontPlatformData();
 
@@ -63 +68 @@
 
     unsigned hash() const
-    { 
+    {
         return StringImpl::computeHash((UChar*)(&m_font), sizeof(HFONT) / sizeof(UChar));
     }
@@ -69 +74 @@
     bool operator==(const FontPlatformData& other) const
     { 
-        return m_font == other.m_font
-              && m_cgFont ==other.m_cgFont
-              && m_size == other.m_size;
+        return m_font == other.m_font && m_cgFont ==other.m_cgFont && m_size == other.m_size &&
+               m_syntheticBold == other.m_syntheticBold && m_syntheticOblique == other.m_syntheticOblique;
     }
 

trunk/WebCore/platform/win/FontPlatformDataWin.cpp

@@ -197 +197 @@
 }
 
+FontPlatformData::FontPlatformData(CGFontRef font, int size, bool bold, bool oblique)
+    : m_font(0)
+    , m_size(size)
+    , m_cgFont(font)
+    , m_syntheticBold(bold)
+    , m_syntheticOblique(oblique)
+{
+}
+
 FontPlatformData::~FontPlatformData()
 {

trunk/WebCore/platform/win/PopupMenuWin.cpp

@@ -25 +25 @@
 #include "FloatRect.h"
 #include "FontData.h"
+#include "FontSelector.h"
 #include "Frame.h"
 #include "FrameView.h"
@@ -512 +513 @@
             d.setBold(true);
             itemFont = Font(d, itemFont.letterSpacing(), itemFont.wordSpacing());
-            itemFont.update();
+            itemFont.update(m_popupClient->fontSelector());
         }
         context.setFont(itemFont);

trunk/WebCore/rendering/RenderListBox.cpp

@@ -32 +32 @@
 #include "RenderListBox.h"
 
+#include "CSSStyleSelector.h"
 #include "Document.h"
 #include "EventHandler.h"
@@ -109 +110 @@
                 d.setBold(true);
                 itemFont = Font(d, itemFont.letterSpacing(), itemFont.wordSpacing());
-                itemFont.update();
+                itemFont.update(document()->styleSelector()->fontSelector());
             }
                 
@@ -325 +326 @@
         d.setBold(true);
         itemFont = Font(d, itemFont.letterSpacing(), itemFont.wordSpacing());
-        itemFont.update();
+        itemFont.update(document()->styleSelector()->fontSelector());
     }
     paintInfo.context->setFont(itemFont);

trunk/WebCore/rendering/RenderMenuList.cpp

@@ -24 +24 @@
 #include "RenderMenuList.h"
 
+#include "CSSStyleSelector.h"
 #include "Document.h"
+#include "FontSelector.h"
 #include "FrameView.h"
 #include "GraphicsContext.h"
@@ -394 +396 @@
 }
 
-}
+FontSelector* RenderMenuList::fontSelector() const
+{
+    return document()->styleSelector()->fontSelector();
+}
+
+}

trunk/WebCore/rendering/RenderMenuList.h

@@ -87 +87 @@
     virtual bool shouldPopOver() const { return !POPUP_MENU_PULLS_DOWN; }
     virtual void valueChanged(unsigned listIndex, bool fireOnChange = true);
+    virtual FontSelector* fontSelector() const;
 
     virtual bool hasLineIfEmpty() const { return true; }

trunk/WebCore/rendering/RenderTextControl.cpp

@@ -23 +23 @@
 
 #include "CharacterNames.h"
+#include "CSSStyleSelector.h"
 #include "Document.h"
 #include "Editor.h"
@@ -28 +29 @@
 #include "Event.h"
 #include "EventNames.h"
+#include "FontSelector.h"
 #include "Frame.h"
 #include "HTMLBRElement.h"
@@ -1187 +1189 @@
 }
 
+FontSelector* RenderTextControl::fontSelector() const
+{
+    return document()->styleSelector()->fontSelector();
+}
+
 } // namespace WebCore

trunk/WebCore/rendering/RenderTextControl.h

@@ -28 +28 @@
 namespace WebCore {
 
+class FontSelector;
 class HTMLTextFieldInnerElement;
 class HTMLTextFieldInnerTextElement;
@@ -122 +123 @@
     virtual bool shouldPopOver() const { return false; }
     virtual bool valueShouldChangeOnHotTrack() const { return false; }
-    
+    virtual FontSelector* fontSelector() const;
+
     RenderStyle* createInnerBlockStyle(RenderStyle* startStyle);
     RenderStyle* createInnerTextStyle(RenderStyle* startStyle);

trunk/WebCore/rendering/RenderThemeMac.mm

@@ -393 +393 @@
 
     if (style->setFontDescription(fontDescription))
-        style->font().update();
+        style->font().update(0);
 }
 

trunk/WebCore/rendering/RenderThemeSafari.cpp

@@ -335 +335 @@
 
     if (style->setFontDescription(fontDescription))
-        style->font().update();
+        style->font().update(selector->fontSelector());
 }