Diff
Modified: trunk/Source/WebCore/CMakeLists.txt (196509 => 196510)
--- trunk/Source/WebCore/CMakeLists.txt 2016-02-12 22:17:30 UTC (rev 196509)
+++ trunk/Source/WebCore/CMakeLists.txt 2016-02-12 22:22:20 UTC (rev 196510)
@@ -1299,6 +1299,7 @@
css/CSSCursorImageValue.cpp
css/CSSDefaultStyleSheets.cpp
css/CSSFilterImageValue.cpp
+ css/FontFace.cpp
css/CSSFontFace.cpp
css/CSSFontFaceLoadEvent.cpp
css/CSSFontFaceRule.cpp
@@ -1355,6 +1356,7 @@
css/DocumentRuleSets.cpp
css/ElementRuleCollector.cpp
css/FontLoader.cpp
+ css/FontVariantBuilder.cpp
css/InspectorCSSOMWrappers.cpp
css/LengthFunctions.cpp
css/MediaFeatureNames.cpp
Modified: trunk/Source/WebCore/ChangeLog (196509 => 196510)
--- trunk/Source/WebCore/ChangeLog 2016-02-12 22:17:30 UTC (rev 196509)
+++ trunk/Source/WebCore/ChangeLog 2016-02-12 22:22:20 UTC (rev 196510)
@@ -1,3 +1,121 @@
+2016-02-12 Myles C. Maxfield <[email protected]>
+
+ [CSS Font Loading] Implement CSSFontFace Boilerplate
+ https://bugs.webkit.org/show_bug.cgi?id=154145
+
+ Reviewed by Dean Jackson.
+
+ The CSS Font Loading spec[1] dictates that the FontFace object needs to have string
+ accessors and mutators for a bunch of properties. Our CSSFontFace object currently
+ contains this parsed information, but it isn't accessible via string-based methods.
+ This patch adds the necessary accessors and mutators, and migrates CSSFontSelector
+ to use these mutators where necessary.
+
+ There is more work to come on CSSFontFace; the next step is to create an .idl file
+ and hook it up to our CSSFontFace object. In this patch I have left some
+ unimplemented pieces (for example: where the spec dictates that some operation should
+ throw a _javascript_ exception) which will be implemented in a follow-up patch. This
+ patch does not have any visible behavior change; I'm separating out the boilerplate
+ into this patch in order to ease reviewing burden.
+
+ This patch separates the externally-facing _javascript_ API into a new class, FontFace.
+ This class owns a CSSFontFace, which provides the backing implementation. There will
+ be a system of shared ownership of these objects once FontFaceSet is implemented.
+
+ No new tests because there is no behavior change.
+
+ * CMakeLists.txt: Add new files to CMake builds.
+ * WebCore.vcxproj/WebCore.vcxproj: Ditto for Windows.
+ * WebCore.vcxproj/WebCore.vcxproj.filters: Ditto.
+ * WebCore.xcodeproj/project.pbxproj: Ditto for Cocoa.
+ * css/CSSAllInOne.cpp: Ditto for All-In-One builds.
+ * css/CSSFontFace.cpp: Move shared code from CSSFontSelector into CSSFontFace.
+ (WebCore::CSSFontFace::CSSFontFace):
+ (WebCore::CSSFontFace::~CSSFontFace):
+ (WebCore::CSSFontFace::setFamilies):
+ (WebCore::CSSFontFace::setStyle):
+ (WebCore::CSSFontFace::setWeight):
+ (WebCore::CSSFontFace::setUnicodeRange):
+ (WebCore::CSSFontFace::setVariantLigatures):
+ (WebCore::CSSFontFace::setVariantPosition):
+ (WebCore::CSSFontFace::setVariantCaps):
+ (WebCore::CSSFontFace::setVariantNumeric):
+ (WebCore::CSSFontFace::setVariantAlternates):
+ (WebCore::CSSFontFace::setVariantEastAsian):
+ (WebCore::CSSFontFace::setFeatureSettings):
+ * css/CSSFontFace.h: Clean up.
+ (WebCore::CSSFontFace::create):
+ (WebCore::CSSFontFace::families):
+ (WebCore::CSSFontFace::traitsMask):
+ (WebCore::CSSFontFace::featureSettings):
+ (WebCore::CSSFontFace::variantSettings):
+ (WebCore::CSSFontFace::setVariantSettings):
+ (WebCore::CSSFontFace::setTraitsMask):
+ (WebCore::CSSFontFace::isLocalFallback):
+ (WebCore::CSSFontFace::addRange): Deleted.
+ (WebCore::CSSFontFace::insertFeature): Deleted.
+ (WebCore::CSSFontFace::setVariantCommonLigatures): Deleted.
+ (WebCore::CSSFontFace::setVariantDiscretionaryLigatures): Deleted.
+ (WebCore::CSSFontFace::setVariantHistoricalLigatures): Deleted.
+ (WebCore::CSSFontFace::setVariantContextualAlternates): Deleted.
+ (WebCore::CSSFontFace::setVariantPosition): Deleted.
+ (WebCore::CSSFontFace::setVariantCaps): Deleted.
+ (WebCore::CSSFontFace::setVariantNumericFigure): Deleted.
+ (WebCore::CSSFontFace::setVariantNumericSpacing): Deleted.
+ (WebCore::CSSFontFace::setVariantNumericFraction): Deleted.
+ (WebCore::CSSFontFace::setVariantNumericOrdinal): Deleted.
+ (WebCore::CSSFontFace::setVariantNumericSlashedZero): Deleted.
+ (WebCore::CSSFontFace::setVariantAlternates): Deleted.
+ (WebCore::CSSFontFace::setVariantEastAsianVariant): Deleted.
+ (WebCore::CSSFontFace::setVariantEastAsianWidth): Deleted.
+ (WebCore::CSSFontFace::setVariantEastAsianRuby): Deleted.
+ (WebCore::CSSFontFace::CSSFontFace): Deleted.
+ * css/CSSFontSelector.cpp: Migrate shared code into CSSFontFace, and udpate
+ to use the new API.
+ (WebCore::appendSources):
+ (WebCore::registerLocalFontFacesForFamily):
+ (WebCore::CSSFontSelector::addFontFaceRule):
+ (WebCore::computeTraitsMask): Deleted.
+ (WebCore::createFontFace): Deleted.
+ * css/FontFace.cpp: Added. External _javascript_ API. Owns a CSSFontFace.
+ (WebCore::FontFace::FontFace):
+ (WebCore::FontFace::~FontFace):
+ (WebCore::parseString):
+ (WebCore::FontFace::setFamily):
+ (WebCore::FontFace::setStyle):
+ (WebCore::FontFace::setWeight):
+ (WebCore::FontFace::setStretch):
+ (WebCore::FontFace::setUnicodeRange):
+ (WebCore::FontFace::setVariant):
+ (WebCore::FontFace::setFeatureSettings):
+ (WebCore::FontFace::family):
+ (WebCore::FontFace::style):
+ (WebCore::FontFace::weight):
+ (WebCore::FontFace::stretch):
+ (WebCore::FontFace::unicodeRange):
+ (WebCore::FontFace::variant):
+ (WebCore::FontFace::featureSettings):
+ * css/FontFace.h: Added. Ditto.
+ (WebCore::FontFace::create):
+ * css/FontVariantBuilder.cpp: Added. Moved code here from FontVariantBuilder.h.
+ Refactored to support a new client (CSSFontFace).
+ (WebCore::extractFontVariantLigatures):
+ (WebCore::extractFontVariantNumeric):
+ (WebCore::extractFontVariantEastAsian):
+ (WebCore::computeFontVariant):
+ * css/FontVariantBuilder.h: Moved code from here into FontVariantBuilder.cpp.
+ (WebCore::applyValueFontVariantLigatures): Deleted.
+ (WebCore::applyValueFontVariantNumeric): Deleted.
+ (WebCore::applyValueFontVariantEastAsian): Deleted.
+ * css/StyleBuilderCustom.h: Update for new FontVariantBuilder API.
+ (WebCore::StyleBuilderCustom::applyValueFontVariantLigatures):
+ (WebCore::StyleBuilderCustom::applyValueFontVariantNumeric):
+ (WebCore::StyleBuilderCustom::applyValueFontVariantEastAsian):
+ * platform/text/TextFlags.h: Provide convenience classes.
+ (WebCore::FontVariantLigaturesValues::FontVariantLigaturesValues):
+ (WebCore::FontVariantNumericValues::FontVariantNumericValues):
+ (WebCore::FontVariantEastAsianValues::FontVariantEastAsianValues):
+
2016-02-12 Jer Noble <[email protected]>
Build fix after r196506; publish MediaResourceLoader.h as a private header so it can be used by
Modified: trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj (196509 => 196510)
--- trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj 2016-02-12 22:17:30 UTC (rev 196509)
+++ trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj 2016-02-12 22:22:20 UTC (rev 196510)
@@ -9583,6 +9583,20 @@
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Production|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Production|x64'">true</ExcludedFromBuild>
</ClCompile>
+ <ClCompile Include="..\css\FontFace.cpp">
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug_WinCairo|Win32'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug_WinCairo|x64'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugSuffix|Win32'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugSuffix|x64'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release_WinCairo|Win32'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release_WinCairo|x64'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Production|Win32'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Production|x64'">true</ExcludedFromBuild>
+ </ClCompile>
<ClCompile Include="..\css\CSSFontFace.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
@@ -10242,6 +10256,20 @@
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Production|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Production|x64'">true</ExcludedFromBuild>
</ClCompile>
+ <ClCompile Include="..\css\FontVariantBuilder.cpp">
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug_WinCairo|Win32'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug_WinCairo|x64'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugSuffix|Win32'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='DebugSuffix|x64'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release_WinCairo|Win32'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release_WinCairo|x64'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Production|Win32'">true</ExcludedFromBuild>
+ <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Production|x64'">true</ExcludedFromBuild>
+ </ClCompile>
<ClCompile Include="..\css\FontLoader.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
@@ -21630,6 +21658,7 @@
<ClInclude Include="..\css\CSSCursorImageValue.h" />
<ClInclude Include="..\css\CSSFilterImageValue.h" />
<ClInclude Include="..\css\CSSFontFace.h" />
+ <ClInclude Include="..\css\FontFace.h" />
<ClInclude Include="..\css\CSSFontFaceLoadEvent.h" />
<ClInclude Include="..\css\CSSFontFaceRule.h" />
<ClInclude Include="..\css\CSSFontFaceSource.h" />
Modified: trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj.filters (196509 => 196510)
--- trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj.filters 2016-02-12 22:17:30 UTC (rev 196509)
+++ trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj.filters 2016-02-12 22:22:20 UTC (rev 196510)
@@ -2084,6 +2084,9 @@
<ClCompile Include="..\css\CSSCursorImageValue.cpp">
<Filter>css</Filter>
</ClCompile>
+ <ClCompile Include="..\css\FontFace.cpp">
+ <Filter>css</Filter>
+ </ClCompile>
<ClCompile Include="..\css\CSSFontFace.cpp">
<Filter>css</Filter>
</ClCompile>
@@ -2222,6 +2225,9 @@
<ClCompile Include="..\css\CSSVariableValue.cpp">
<Filter>css</Filter>
</ClCompile>
+ <ClCompile Include="..\css\FontVariantBuilder.cpp">
+ <Filter>css</Filter>
+ </ClCompile>
<ClCompile Include="..\css\FontLoader.cpp">
<Filter>css</Filter>
</ClCompile>
@@ -9052,6 +9058,9 @@
<ClInclude Include="..\css\CSSCursorImageValue.h">
<Filter>css</Filter>
</ClInclude>
+ <ClInclude Include="..\css\FontFace.h">
+ <Filter>css</Filter>
+ </ClInclude>
<ClInclude Include="..\css\CSSFontFace.h">
<Filter>css</Filter>
</ClInclude>
Modified: trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj (196509 => 196510)
--- trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj 2016-02-12 22:17:30 UTC (rev 196509)
+++ trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj 2016-02-12 22:22:20 UTC (rev 196510)
@@ -951,9 +951,12 @@
1C21E57D183ED1FF001C289D /* IOSurfacePool.h in Headers */ = {isa = PBXBuildFile; fileRef = 1C21E57B183ED1FF001C289D /* IOSurfacePool.h */; settings = {ATTRIBUTES = (Private, ); }; };
1C2417BA1992C04100EF9938 /* [email protected] in Resources */ = {isa = PBXBuildFile; fileRef = 1C2417B91992C04100EF9938 /* [email protected] */; };
1C26497A0D7E248A00BD10F2 /* DocumentLoaderMac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1C2649790D7E248A00BD10F2 /* DocumentLoaderMac.cpp */; };
+ 1C3249111C6D6A3B007EDB32 /* FontVariantBuilder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1C3249101C6D6A3B007EDB32 /* FontVariantBuilder.cpp */; };
1C3969D01B74211E002BCFA7 /* FontCacheCoreText.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1C3969CF1B74211E002BCFA7 /* FontCacheCoreText.cpp */; };
1C6466251A12C38E0094603C /* CoreTextSPI.h in Headers */ = {isa = PBXBuildFile; fileRef = 1C5E980F1A02CEFA002DB55F /* CoreTextSPI.h */; settings = {ATTRIBUTES = (Private, ); }; };
1C6466281A12C4200094603C /* NSFontSPI.h in Headers */ = {isa = PBXBuildFile; fileRef = 1C6466271A12C3F90094603C /* NSFontSPI.h */; settings = {ATTRIBUTES = (Private, ); }; };
+ 1C6626101C6E7CA600AB527C /* FontFace.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1C66260E1C6E7CA600AB527C /* FontFace.cpp */; };
+ 1C6626111C6E7CA600AB527C /* FontFace.h in Headers */ = {isa = PBXBuildFile; fileRef = 1C66260F1C6E7CA600AB527C /* FontFace.h */; };
1C81B95A0E97330800266E07 /* InspectorController.h in Headers */ = {isa = PBXBuildFile; fileRef = 1C81B9560E97330800266E07 /* InspectorController.h */; settings = {ATTRIBUTES = (Private, ); }; };
1C81B95B0E97330800266E07 /* InspectorController.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1C81B9570E97330800266E07 /* InspectorController.cpp */; };
1C81B95C0E97330800266E07 /* InspectorClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 1C81B9580E97330800266E07 /* InspectorClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
@@ -8352,9 +8355,12 @@
1C21E57B183ED1FF001C289D /* IOSurfacePool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IOSurfacePool.h; sourceTree = "<group>"; };
1C2417B91992C04100EF9938 /* [email protected] */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = "[email protected]"; sourceTree = "<group>"; };
1C2649790D7E248A00BD10F2 /* DocumentLoaderMac.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DocumentLoaderMac.cpp; sourceTree = "<group>"; };
+ 1C3249101C6D6A3B007EDB32 /* FontVariantBuilder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FontVariantBuilder.cpp; sourceTree = "<group>"; };
1C3969CF1B74211E002BCFA7 /* FontCacheCoreText.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FontCacheCoreText.cpp; sourceTree = "<group>"; };
1C5E980F1A02CEFA002DB55F /* CoreTextSPI.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = CoreTextSPI.h; sourceTree = "<group>"; };
1C6466271A12C3F90094603C /* NSFontSPI.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = NSFontSPI.h; sourceTree = "<group>"; };
+ 1C66260E1C6E7CA600AB527C /* FontFace.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FontFace.cpp; sourceTree = "<group>"; };
+ 1C66260F1C6E7CA600AB527C /* FontFace.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FontFace.h; sourceTree = "<group>"; };
1C81B9560E97330800266E07 /* InspectorController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InspectorController.h; sourceTree = "<group>"; };
1C81B9570E97330800266E07 /* InspectorController.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = InspectorController.cpp; sourceTree = "<group>"; };
1C81B9580E97330800266E07 /* InspectorClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InspectorClient.h; sourceTree = "<group>"; };
@@ -23703,6 +23709,9 @@
3FFFF9A6159D9A550020BBD5 /* WebKitCSSViewportRule.cpp */,
3FFFF9A7159D9A550020BBD5 /* WebKitCSSViewportRule.h */,
3F2B33E3165ABD3500E3987C /* WebKitCSSViewportRule.idl */,
+ 1C3249101C6D6A3B007EDB32 /* FontVariantBuilder.cpp */,
+ 1C66260E1C6E7CA600AB527C /* FontFace.cpp */,
+ 1C66260F1C6E7CA600AB527C /* FontFace.h */,
);
path = css;
sourceTree = "<group>";
@@ -24996,6 +25005,7 @@
BCB16C1C0979C3BD00467741 /* CachedImage.h in Headers */,
319FBD5F15D2F464009640A6 /* CachedImageClient.h in Headers */,
510184690B08602A004A825F /* CachedPage.h in Headers */,
+ 1C6626111C6E7CA600AB527C /* FontFace.h in Headers */,
D0EDA775143E303C0028E383 /* CachedRawResource.h in Headers */,
E1B533491717DEE300F205F9 /* CachedRawResourceClient.h in Headers */,
BCB16C200979C3BD00467741 /* CachedResource.h in Headers */,
@@ -29911,6 +29921,7 @@
B275357D0B053814002CE64F /* IntRectMac.mm in Sources */,
2D46F05017B96FD2005647F0 /* IntSize.cpp in Sources */,
B27535620B053814002CE64F /* IntSizeCG.cpp in Sources */,
+ 1C3249111C6D6A3B007EDB32 /* FontVariantBuilder.cpp in Sources */,
B275357E0B053814002CE64F /* IntSizeMac.mm in Sources */,
2D0B4AAC18DA1CCD00434DE1 /* IOSurface.mm in Sources */,
1C21E57C183ED1FF001C289D /* IOSurfacePool.cpp in Sources */,
@@ -30112,6 +30123,7 @@
BCCBAD400C18C14200CE890F /* JSHTMLCollection.cpp in Sources */,
BCCBAD3B0C18BFF800CE890F /* JSHTMLCollectionCustom.cpp in Sources */,
F5C041E60FFCA96D00839D4A /* JSHTMLDataListElement.cpp in Sources */,
+ 1C6626101C6E7CA600AB527C /* FontFace.cpp in Sources */,
D359D8BE129CA55C0006E5D2 /* JSHTMLDetailsElement.cpp in Sources */,
1A85B1E60A1B240500D8C87C /* JSHTMLDirectoryElement.cpp in Sources */,
1A85B2B60A1B2AC700D8C87C /* JSHTMLDivElement.cpp in Sources */,
Modified: trunk/Source/WebCore/css/CSSAllInOne.cpp (196509 => 196510)
--- trunk/Source/WebCore/css/CSSAllInOne.cpp 2016-02-12 22:17:30 UTC (rev 196509)
+++ trunk/Source/WebCore/css/CSSAllInOne.cpp 2016-02-12 22:22:20 UTC (rev 196510)
@@ -93,7 +93,9 @@
#include "DOMWindowCSS.cpp"
#include "DocumentRuleSets.cpp"
#include "ElementRuleCollector.cpp"
+#include "FontFace.cpp"
#include "FontLoader.cpp"
+#include "FontVariantBuilder.cpp"
#include "InspectorCSSOMWrappers.cpp"
#include "LengthFunctions.cpp"
#include "MediaList.cpp"
Modified: trunk/Source/WebCore/css/CSSFontFace.cpp (196509 => 196510)
--- trunk/Source/WebCore/css/CSSFontFace.cpp 2016-02-12 22:17:30 UTC (rev 196509)
+++ trunk/Source/WebCore/css/CSSFontFace.cpp 2016-02-12 22:22:20 UTC (rev 196510)
@@ -27,16 +27,194 @@
#include "CSSFontFace.h"
#include "CSSFontFaceSource.h"
+#include "CSSFontFamily.h"
+#include "CSSFontFeatureValue.h"
#include "CSSFontSelector.h"
+#include "CSSPrimitiveValueMappings.h"
#include "CSSSegmentedFontFace.h"
+#include "CSSUnicodeRangeValue.h"
+#include "CSSValue.h"
+#include "CSSValueList.h"
#include "Document.h"
#include "Font.h"
#include "FontDescription.h"
#include "FontLoader.h"
+#include "FontVariantBuilder.h"
#include "RuntimeEnabledFeatures.h"
+#include "StyleProperties.h"
namespace WebCore {
+CSSFontFace::CSSFontFace(bool isLocalFallback)
+ : m_isLocalFallback(isLocalFallback)
+{
+}
+
+CSSFontFace::~CSSFontFace()
+{
+}
+
+bool CSSFontFace::setFamilies(CSSValue& family)
+{
+ if (!is<CSSValueList>(family))
+ return false;
+
+ CSSValueList& familyList = downcast<CSSValueList>(family);
+ if (!familyList.length())
+ return false;
+
+ m_families = &familyList;
+ return true;
+}
+
+bool CSSFontFace::setStyle(CSSValue& style)
+{
+ if (!is<CSSPrimitiveValue>(style))
+ return false;
+
+ unsigned styleMask = 0;
+ switch (downcast<CSSPrimitiveValue>(style).getValueID()) {
+ case CSSValueNormal:
+ styleMask = FontStyleNormalMask;
+ break;
+ case CSSValueItalic:
+ case CSSValueOblique:
+ styleMask = FontStyleItalicMask;
+ break;
+ default:
+ return false;
+ }
+
+ m_traitsMask = static_cast<FontTraitsMask>((static_cast<unsigned>(m_traitsMask) & (~FontStyleMask)) | styleMask);
+ return true;
+}
+
+bool CSSFontFace::setWeight(CSSValue& weight)
+{
+ if (!is<CSSPrimitiveValue>(weight))
+ return false;
+
+ unsigned weightMask = 0;
+ switch (downcast<CSSPrimitiveValue>(weight).getValueID()) {
+ case CSSValueBold:
+ case CSSValue700:
+ weightMask = FontWeight700Mask;
+ break;
+ case CSSValueNormal:
+ case CSSValue400:
+ weightMask = FontWeight400Mask;
+ break;
+ case CSSValue900:
+ weightMask = FontWeight900Mask;
+ break;
+ case CSSValue800:
+ weightMask = FontWeight800Mask;
+ break;
+ case CSSValue600:
+ weightMask = FontWeight600Mask;
+ break;
+ case CSSValue500:
+ weightMask = FontWeight500Mask;
+ break;
+ case CSSValue300:
+ weightMask = FontWeight300Mask;
+ break;
+ case CSSValue200:
+ weightMask = FontWeight200Mask;
+ break;
+ case CSSValue100:
+ weightMask = FontWeight100Mask;
+ break;
+ default:
+ break;
+ }
+
+ m_traitsMask = static_cast<FontTraitsMask>((static_cast<unsigned>(m_traitsMask) & (~FontWeightMask)) | weightMask);
+ return true;
+}
+
+bool CSSFontFace::setUnicodeRange(CSSValue& unicodeRange)
+{
+ if (!is<CSSValueList>(unicodeRange))
+ return false;
+
+ m_ranges.clear();
+ auto& list = downcast<CSSValueList>(unicodeRange);
+ for (auto& rangeValue : list) {
+ CSSUnicodeRangeValue& range = downcast<CSSUnicodeRangeValue>(rangeValue.get());
+ m_ranges.append(UnicodeRange(range.from(), range.to()));
+ }
+ return true;
+}
+
+bool CSSFontFace::setVariantLigatures(CSSValue& variantLigatures)
+{
+ auto ligatures = extractFontVariantLigatures(variantLigatures);
+ m_variantSettings.commonLigatures = ligatures.commonLigatures;
+ m_variantSettings.discretionaryLigatures = ligatures.discretionaryLigatures;
+ m_variantSettings.historicalLigatures = ligatures.historicalLigatures;
+ m_variantSettings.contextualAlternates = ligatures.contextualAlternates;
+ return true;
+}
+
+bool CSSFontFace::setVariantPosition(CSSValue& variantPosition)
+{
+ if (!is<CSSPrimitiveValue>(variantPosition))
+ return false;
+ m_variantSettings.position = downcast<CSSPrimitiveValue>(variantPosition);
+ return true;
+}
+
+bool CSSFontFace::setVariantCaps(CSSValue& variantCaps)
+{
+ if (!is<CSSPrimitiveValue>(variantCaps))
+ return false;
+ m_variantSettings.caps = downcast<CSSPrimitiveValue>(variantCaps);
+ return true;
+}
+
+bool CSSFontFace::setVariantNumeric(CSSValue& variantNumeric)
+{
+ auto numeric = extractFontVariantNumeric(variantNumeric);
+ m_variantSettings.numericFigure = numeric.figure;
+ m_variantSettings.numericSpacing = numeric.spacing;
+ m_variantSettings.numericFraction = numeric.fraction;
+ m_variantSettings.numericOrdinal = numeric.ordinal;
+ m_variantSettings.numericSlashedZero = numeric.slashedZero;
+ return true;
+}
+
+bool CSSFontFace::setVariantAlternates(CSSValue& variantAlternates)
+{
+ if (!is<CSSPrimitiveValue>(variantAlternates))
+ return false;
+ m_variantSettings.alternates = downcast<CSSPrimitiveValue>(variantAlternates);
+ return true;
+}
+
+bool CSSFontFace::setVariantEastAsian(CSSValue& variantEastAsian)
+{
+ auto eastAsian = extractFontVariantEastAsian(variantEastAsian);
+ m_variantSettings.eastAsianVariant = eastAsian.variant;
+ m_variantSettings.eastAsianWidth = eastAsian.width;
+ m_variantSettings.eastAsianRuby = eastAsian.ruby;
+ return true;
+}
+
+bool CSSFontFace::setFeatureSettings(CSSValue& featureSettings)
+{
+ if (!is<CSSValueList>(featureSettings))
+ return false;
+
+ m_featureSettings = FontFeatureSettings();
+ auto& list = downcast<CSSValueList>(featureSettings);
+ for (auto& rangeValue : list) {
+ CSSFontFeatureValue& feature = downcast<CSSFontFeatureValue>(rangeValue.get());
+ m_featureSettings.insert(FontFeature(feature.tag(), feature.value()));
+ }
+ return true;
+}
+
bool CSSFontFace::allSourcesFailed() const
{
for (auto& source : m_sources) {
Modified: trunk/Source/WebCore/css/CSSFontFace.h (196509 => 196510)
--- trunk/Source/WebCore/css/CSSFontFace.h 2016-02-12 22:17:30 UTC (rev 196509)
+++ trunk/Source/WebCore/css/CSSFontFace.h 2016-02-12 22:22:20 UTC (rev 196510)
@@ -40,45 +40,43 @@
namespace WebCore {
class CSSSegmentedFontFace;
+class CSSValue;
+class CSSValueList;
class FontDescription;
class Font;
class CSSFontFace : public RefCounted<CSSFontFace> {
public:
- static Ref<CSSFontFace> create(FontTraitsMask traitsMask, bool isLocalFallback = false) { return adoptRef(*new CSSFontFace(traitsMask, isLocalFallback)); }
+ static Ref<CSSFontFace> create(bool isLocalFallback = false) { return adoptRef(*new CSSFontFace(isLocalFallback)); }
+ virtual ~CSSFontFace();
- FontTraitsMask traitsMask() const { return m_traitsMask; }
+ bool setFamilies(CSSValue&);
+ bool setStyle(CSSValue&);
+ bool setWeight(CSSValue&);
+ bool setUnicodeRange(CSSValue&);
+ bool setVariantLigatures(CSSValue&);
+ bool setVariantPosition(CSSValue&);
+ bool setVariantCaps(CSSValue&);
+ bool setVariantNumeric(CSSValue&);
+ bool setVariantAlternates(CSSValue&);
+ bool setVariantEastAsian(CSSValue&);
+ bool setFeatureSettings(CSSValue&);
struct UnicodeRange;
-
- void addRange(UChar32 from, UChar32 to) { m_ranges.append(UnicodeRange(from, to)); }
+ const CSSValueList* families() const { return m_families.get(); }
+ FontTraitsMask traitsMask() const { return m_traitsMask; }
const Vector<UnicodeRange>& ranges() const { return m_ranges; }
+ const FontFeatureSettings& featureSettings() const { return m_featureSettings; }
+ const FontVariantSettings& variantSettings() const { return m_variantSettings; }
+ void setVariantSettings(const FontVariantSettings& variantSettings) { m_variantSettings = variantSettings; }
+ void setTraitsMask(FontTraitsMask traitsMask) { m_traitsMask = traitsMask; }
+ bool isLocalFallback() const { return m_isLocalFallback; }
- void insertFeature(FontFeature&& feature) { m_featureSettings.insert(WTFMove(feature)); }
-
- void setVariantCommonLigatures(FontVariantLigatures ligatures) { m_variantSettings.commonLigatures = ligatures; }
- void setVariantDiscretionaryLigatures(FontVariantLigatures ligatures) { m_variantSettings.discretionaryLigatures = ligatures; }
- void setVariantHistoricalLigatures(FontVariantLigatures ligatures) { m_variantSettings.historicalLigatures = ligatures; }
- void setVariantContextualAlternates(FontVariantLigatures ligatures) { m_variantSettings.contextualAlternates = ligatures; }
- void setVariantPosition(FontVariantPosition position) { m_variantSettings.position = position; }
- void setVariantCaps(FontVariantCaps caps) { m_variantSettings.caps = caps; }
- void setVariantNumericFigure(FontVariantNumericFigure figure) { m_variantSettings.numericFigure = figure; }
- void setVariantNumericSpacing(FontVariantNumericSpacing spacing) { m_variantSettings.numericSpacing = spacing; }
- void setVariantNumericFraction(FontVariantNumericFraction fraction) { m_variantSettings.numericFraction = fraction; }
- void setVariantNumericOrdinal(FontVariantNumericOrdinal ordinal) { m_variantSettings.numericOrdinal = ordinal; }
- void setVariantNumericSlashedZero(FontVariantNumericSlashedZero slashedZero) { m_variantSettings.numericSlashedZero = slashedZero; }
- void setVariantAlternates(FontVariantAlternates alternates) { m_variantSettings.alternates = alternates; }
- void setVariantEastAsianVariant(FontVariantEastAsianVariant variant) { m_variantSettings.eastAsianVariant = variant; }
- void setVariantEastAsianWidth(FontVariantEastAsianWidth width) { m_variantSettings.eastAsianWidth = width; }
- void setVariantEastAsianRuby(FontVariantEastAsianRuby ruby) { m_variantSettings.eastAsianRuby = ruby; }
-
void addedToSegmentedFontFace(CSSSegmentedFontFace&);
void removedFromSegmentedFontFace(CSSSegmentedFontFace&);
bool allSourcesFailed() const;
- bool isLocalFallback() const { return m_isLocalFallback; }
-
void adoptSource(std::unique_ptr<CSSFontFaceSource>&&);
void fontLoaded(CSSFontFaceSource&);
@@ -105,12 +103,9 @@
#endif
private:
- CSSFontFace(FontTraitsMask traitsMask, bool isLocalFallback)
- : m_traitsMask(traitsMask)
- , m_isLocalFallback(isLocalFallback)
- {
- }
+ CSSFontFace(bool isLocalFallback);
+ RefPtr<CSSValueList> m_families;
FontTraitsMask m_traitsMask;
Vector<UnicodeRange> m_ranges;
HashSet<CSSSegmentedFontFace*> m_segmentedFontFaces;
Modified: trunk/Source/WebCore/css/CSSFontSelector.cpp (196509 => 196510)
--- trunk/Source/WebCore/css/CSSFontSelector.cpp 2016-02-12 22:17:30 UTC (rev 196509)
+++ trunk/Source/WebCore/css/CSSFontSelector.cpp 2016-02-12 22:22:20 UTC (rev 196510)
@@ -41,6 +41,7 @@
#include "CSSUnicodeRangeValue.h"
#include "CSSValueKeywords.h"
#include "CSSValueList.h"
+#include "CSSValuePool.h"
#include "CachedResourceLoader.h"
#include "Document.h"
#include "Font.h"
@@ -87,75 +88,8 @@
return m_fonts.isEmpty();
}
-static Optional<FontTraitsMask> computeTraitsMask(const StyleProperties& style)
+static void appendSources(CSSFontFace& fontFace, CSSValueList& srcList, Document* document, bool isInitiatingElementInUserAgentShadowTree)
{
- unsigned traitsMask = 0;
-
- if (RefPtr<CSSValue> fontStyle = style.getPropertyCSSValue(CSSPropertyFontStyle)) {
- if (!is<CSSPrimitiveValue>(*fontStyle))
- return Nullopt;
-
- switch (downcast<CSSPrimitiveValue>(*fontStyle).getValueID()) {
- case CSSValueNormal:
- traitsMask |= FontStyleNormalMask;
- break;
- case CSSValueItalic:
- case CSSValueOblique:
- traitsMask |= FontStyleItalicMask;
- break;
- default:
- break;
- }
- } else
- traitsMask |= FontStyleNormalMask;
-
- if (RefPtr<CSSValue> fontWeight = style.getPropertyCSSValue(CSSPropertyFontWeight)) {
- if (!is<CSSPrimitiveValue>(*fontWeight))
- return Nullopt;
-
- switch (downcast<CSSPrimitiveValue>(*fontWeight).getValueID()) {
- case CSSValueBold:
- case CSSValue700:
- traitsMask |= FontWeight700Mask;
- break;
- case CSSValueNormal:
- case CSSValue400:
- traitsMask |= FontWeight400Mask;
- break;
- case CSSValue900:
- traitsMask |= FontWeight900Mask;
- break;
- case CSSValue800:
- traitsMask |= FontWeight800Mask;
- break;
- case CSSValue600:
- traitsMask |= FontWeight600Mask;
- break;
- case CSSValue500:
- traitsMask |= FontWeight500Mask;
- break;
- case CSSValue300:
- traitsMask |= FontWeight300Mask;
- break;
- case CSSValue200:
- traitsMask |= FontWeight200Mask;
- break;
- case CSSValue100:
- traitsMask |= FontWeight100Mask;
- break;
- default:
- break;
- }
- } else
- traitsMask |= FontWeight400Mask;
-
- return static_cast<FontTraitsMask>(traitsMask);
-}
-
-static Ref<CSSFontFace> createFontFace(CSSValueList& srcList, FontTraitsMask traitsMask, Document* document, bool isInitiatingElementInUserAgentShadowTree)
-{
- Ref<CSSFontFace> fontFace = CSSFontFace::create(traitsMask);
-
for (auto& src : srcList) {
// An item in the list either specifies a string (local font name) or a URL (remote font to download).
CSSFontFaceSrcValue& item = downcast<CSSFontFaceSrcValue>(src.get());
@@ -172,16 +106,14 @@
bool allowDownloading = foundSVGFont || (settings && settings->downloadableBinaryFontsEnabled());
if (allowDownloading && item.isSupportedFormat() && document) {
if (CachedFont* cachedFont = item.cachedFont(document, foundSVGFont, isInitiatingElementInUserAgentShadowTree))
- source = std::make_unique<CSSFontFaceSource>(fontFace.get(), item.resource(), cachedFont);
+ source = std::make_unique<CSSFontFaceSource>(fontFace, item.resource(), cachedFont);
}
} else
- source = std::make_unique<CSSFontFaceSource>(fontFace.get(), item.resource(), nullptr, fontFaceElement);
+ source = std::make_unique<CSSFontFaceSource>(fontFace, item.resource(), nullptr, fontFaceElement);
if (source)
- fontFace->adoptSource(WTFMove(source));
+ fontFace.adoptSource(WTFMove(source));
}
-
- return fontFace;
}
static String familyNameFromPrimitive(const CSSPrimitiveValue& value)
@@ -221,7 +153,8 @@
Vector<Ref<CSSFontFace>> faces = { };
for (auto mask : traitsMasks) {
- Ref<CSSFontFace> face = CSSFontFace::create(mask, true);
+ Ref<CSSFontFace> face = CSSFontFace::create(true);
+ face->setTraitsMask(mask);
face->adoptSource(std::make_unique<CSSFontFaceSource>(face.get(), familyName));
ASSERT(!face->allSourcesFailed());
faces.append(WTFMove(face));
@@ -233,6 +166,8 @@
{
const StyleProperties& style = fontFaceRule.properties();
RefPtr<CSSValue> fontFamily = style.getPropertyCSSValue(CSSPropertyFontFamily);
+ RefPtr<CSSValue> fontStyle = style.getPropertyCSSValue(CSSPropertyFontStyle);
+ RefPtr<CSSValue> fontWeight = style.getPropertyCSSValue(CSSPropertyFontWeight);
RefPtr<CSSValue> src = ""
RefPtr<CSSValue> unicodeRange = style.getPropertyCSSValue(CSSPropertyUnicodeRange);
RefPtr<CSSValue> featureSettings = style.getPropertyCSSValue(CSSPropertyFontFeatureSettings);
@@ -249,54 +184,47 @@
if (!familyList.length())
return;
+ if (!fontStyle)
+ fontStyle = CSSValuePool::singleton().createIdentifierValue(CSSValueNormal).ptr();
+
+ if (!fontWeight)
+ fontWeight = CSSValuePool::singleton().createIdentifierValue(CSSValueNormal);
+
+ CSSValueList* rangeList = downcast<CSSValueList>(unicodeRange.get());
+
CSSValueList& srcList = downcast<CSSValueList>(*src);
if (!srcList.length())
return;
- CSSValueList* rangeList = downcast<CSSValueList>(unicodeRange.get());
+ Ref<CSSFontFace> fontFace = CSSFontFace::create();
- auto computedTraitsMask = computeTraitsMask(style);
- if (!computedTraitsMask)
+ if (!fontFace->setFamilies(*fontFamily))
return;
- auto traitsMask = computedTraitsMask.value();
+ if (!fontFace->setStyle(*fontStyle))
+ return;
+ if (!fontFace->setWeight(*fontWeight))
+ return;
+ if (rangeList && !fontFace->setUnicodeRange(*rangeList))
+ return;
+ if (variantLigatures && !fontFace->setVariantLigatures(*variantLigatures))
+ return;
+ if (variantPosition && !fontFace->setVariantPosition(*variantPosition))
+ return;
+ if (variantCaps && !fontFace->setVariantCaps(*variantCaps))
+ return;
+ if (variantNumeric && !fontFace->setVariantNumeric(*variantNumeric))
+ return;
+ if (variantAlternates && !fontFace->setVariantAlternates(*variantAlternates))
+ return;
+ if (variantEastAsian && !fontFace->setVariantEastAsian(*variantEastAsian))
+ return;
+ if (featureSettings && !fontFace->setFeatureSettings(*featureSettings))
+ return;
- Ref<CSSFontFace> fontFace = createFontFace(srcList, traitsMask, m_document, isInitiatingElementInUserAgentShadowTree);
+ appendSources(fontFace, srcList, m_document, isInitiatingElementInUserAgentShadowTree);
if (fontFace->allSourcesFailed())
return;
- if (rangeList) {
- unsigned numRanges = rangeList->length();
- for (unsigned i = 0; i < numRanges; i++) {
- CSSUnicodeRangeValue& range = downcast<CSSUnicodeRangeValue>(*rangeList->itemWithoutBoundsCheck(i));
- fontFace->addRange(range.from(), range.to());
- }
- }
-
- if (featureSettings) {
- for (auto& item : downcast<CSSValueList>(*featureSettings)) {
- auto& feature = downcast<CSSFontFeatureValue>(item.get());
- fontFace->insertFeature(FontFeature(feature.tag(), feature.value()));
- }
- }
-
- if (variantLigatures)
- applyValueFontVariantLigatures(fontFace.get(), *variantLigatures);
-
- if (variantPosition && is<CSSPrimitiveValue>(*variantPosition))
- fontFace->setVariantPosition(downcast<CSSPrimitiveValue>(*variantPosition));
-
- if (variantCaps && is<CSSPrimitiveValue>(*variantCaps))
- fontFace->setVariantCaps(downcast<CSSPrimitiveValue>(*variantCaps));
-
- if (variantNumeric)
- applyValueFontVariantNumeric(fontFace.get(), *variantNumeric);
-
- if (variantAlternates && is<CSSPrimitiveValue>(*variantAlternates))
- fontFace->setVariantAlternates(downcast<CSSPrimitiveValue>(*variantAlternates));
-
- if (variantEastAsian)
- applyValueFontVariantEastAsian(fontFace.get(), *variantEastAsian);
-
for (auto& item : familyList) {
String familyName = familyNameFromPrimitive(downcast<CSSPrimitiveValue>(item.get()));
if (familyName.isEmpty())
Added: trunk/Source/WebCore/css/FontFace.cpp (0 => 196510)
--- trunk/Source/WebCore/css/FontFace.cpp (rev 0)
+++ trunk/Source/WebCore/css/FontFace.cpp 2016-02-12 22:22:20 UTC (rev 196510)
@@ -0,0 +1,204 @@
+/*
+ * Copyright (C) 2007, 2008, 2011, 2013 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "FontFace.h"
+
+#include "CSSFontFace.h"
+#include "CSSFontFeatureValue.h"
+#include "CSSUnicodeRangeValue.h"
+#include "CSSValue.h"
+#include "FontVariantBuilder.h"
+#include "StyleProperties.h"
+#include <wtf/text/StringBuilder.h>
+
+namespace WebCore {
+
+FontFace::FontFace()
+ : m_backing(CSSFontFace::create())
+{
+}
+
+FontFace::~FontFace()
+{
+}
+
+static inline RefPtr<CSSValue> parseString(const String& string, CSSPropertyID propertyID)
+{
+ Ref<MutableStyleProperties> style = MutableStyleProperties::create();
+ auto result = CSSParser::parseValue(style.ptr(), propertyID, string, true, CSSStrictMode, nullptr);
+ if (result == CSSParser::ParseResult::Error)
+ return nullptr;
+ return style->getPropertyCSSValue(propertyID);
+}
+
+void FontFace::setFamily(const String& family, ExceptionCode& ec)
+{
+ bool success = false;
+ if (auto value = parseString(family, CSSPropertyFontFamily))
+ success = m_backing->setFamilies(*value);
+ if (!success)
+ ec = SYNTAX_ERR;
+}
+
+void FontFace::setStyle(const String& style, ExceptionCode& ec)
+{
+ bool success = false;
+ if (auto value = parseString(style, CSSPropertyFontStyle))
+ success = m_backing->setStyle(*value);
+ if (!success)
+ ec = SYNTAX_ERR;
+}
+
+void FontFace::setWeight(const String& weight, ExceptionCode& ec)
+{
+ bool success = false;
+ if (auto value = parseString(weight, CSSPropertyFontWeight))
+ success = m_backing->setWeight(*value);
+ if (!success)
+ ec = SYNTAX_ERR;
+}
+
+void FontFace::setStretch(const String&, ExceptionCode&)
+{
+ // We don't support font-stretch. Swallow the call.
+}
+
+void FontFace::setUnicodeRange(const String& unicodeRange, ExceptionCode& ec)
+{
+ bool success = false;
+ if (auto value = parseString(unicodeRange, CSSPropertyUnicodeRange))
+ success = m_backing->setUnicodeRange(*value);
+ if (!success)
+ ec = SYNTAX_ERR;
+}
+
+void FontFace::setVariant(const String& variant, ExceptionCode& ec)
+{
+ Ref<MutableStyleProperties> style = MutableStyleProperties::create();
+ auto result = CSSParser::parseValue(style.ptr(), CSSPropertyFontVariant, variant, true, CSSStrictMode, nullptr);
+ if (result != CSSParser::ParseResult::Error) {
+ FontVariantSettings backup = m_backing->variantSettings();
+ bool success = true;
+ if (auto value = style->getPropertyCSSValue(CSSPropertyFontVariantLigatures))
+ success &= m_backing->setVariantLigatures(*value);
+ if (auto value = style->getPropertyCSSValue(CSSPropertyFontVariantPosition))
+ success &= m_backing->setVariantPosition(*value);
+ if (auto value = style->getPropertyCSSValue(CSSPropertyFontVariantCaps))
+ success &= m_backing->setVariantCaps(*value);
+ if (auto value = style->getPropertyCSSValue(CSSPropertyFontVariantNumeric))
+ success &= m_backing->setVariantNumeric(*value);
+ if (auto value = style->getPropertyCSSValue(CSSPropertyFontVariantAlternates))
+ success &= m_backing->setVariantAlternates(*value);
+ if (auto value = style->getPropertyCSSValue(CSSPropertyFontVariantEastAsian))
+ success &= m_backing->setVariantEastAsian(*value);
+ if (success)
+ return;
+ m_backing->setVariantSettings(backup);
+ }
+ ec = SYNTAX_ERR;
+}
+
+void FontFace::setFeatureSettings(const String& featureSettings, ExceptionCode& ec)
+{
+ bool success = false;
+ if (auto value = parseString(featureSettings, CSSPropertyFontFeatureSettings))
+ success = m_backing->setFeatureSettings(*value);
+ if (!success)
+ ec = SYNTAX_ERR;
+}
+
+String FontFace::family() const
+{
+ return m_backing->families()->cssText();
+}
+
+String FontFace::style() const
+{
+ switch (m_backing->traitsMask() & FontStyleMask) {
+ case FontStyleNormalMask:
+ return String("normal", String::ConstructFromLiteral);
+ case FontStyleItalicMask:
+ return String("italic", String::ConstructFromLiteral);
+ }
+ ASSERT_NOT_REACHED();
+ return String("normal", String::ConstructFromLiteral);
+}
+
+String FontFace::weight() const
+{
+ switch (m_backing->traitsMask() & FontWeightMask) {
+ case FontWeight100Mask:
+ return String("100", String::ConstructFromLiteral);
+ case FontWeight200Mask:
+ return String("200", String::ConstructFromLiteral);
+ case FontWeight300Mask:
+ return String("300", String::ConstructFromLiteral);
+ case FontWeight400Mask:
+ return String("normal", String::ConstructFromLiteral);
+ case FontWeight500Mask:
+ return String("500", String::ConstructFromLiteral);
+ case FontWeight600Mask:
+ return String("600", String::ConstructFromLiteral);
+ case FontWeight700Mask:
+ return String("bold", String::ConstructFromLiteral);
+ case FontWeight800Mask:
+ return String("800", String::ConstructFromLiteral);
+ case FontWeight900Mask:
+ return String("900", String::ConstructFromLiteral);
+ }
+ ASSERT_NOT_REACHED();
+ return String("normal", String::ConstructFromLiteral);
+}
+
+String FontFace::stretch() const
+{
+ return "normal";
+}
+
+String FontFace::unicodeRange() const
+{
+ RefPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
+ for (auto& range : m_backing->ranges())
+ values->append(CSSUnicodeRangeValue::create(range.from(), range.to()));
+ return values->cssText();
+}
+
+String FontFace::variant() const
+{
+ return computeFontVariant(m_backing->variantSettings())->cssText();
+}
+
+String FontFace::featureSettings() const
+{
+ if (!m_backing->featureSettings().size())
+ return "normal";
+ RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
+ for (auto& feature : m_backing->featureSettings())
+ list->append(CSSFontFeatureValue::create(FontFeatureTag(feature.tag()), feature.value()));
+ return list->cssText();
+}
+
+}
Added: trunk/Source/WebCore/css/FontFace.h (0 => 196510)
--- trunk/Source/WebCore/css/FontFace.h (rev 0)
+++ trunk/Source/WebCore/css/FontFace.h 2016-02-12 22:22:20 UTC (rev 196510)
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef FontFace_h
+#define FontFace_h
+
+#include "ExceptionCode.h"
+#include <wtf/RefCounted.h>
+#include <wtf/RefPtr.h>
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+
+class CSSFontFace;
+
+class FontFace : public RefCounted<FontFace> {
+public:
+ static Ref<FontFace> create() { return adoptRef(*new FontFace()); }
+ virtual ~FontFace();
+
+ void setFamily(const String&, ExceptionCode&);
+ void setStyle(const String&, ExceptionCode&);
+ void setWeight(const String&, ExceptionCode&);
+ void setStretch(const String&, ExceptionCode&);
+ void setUnicodeRange(const String&, ExceptionCode&);
+ void setVariant(const String&, ExceptionCode&);
+ void setFeatureSettings(const String&, ExceptionCode&);
+
+ String family() const;
+ String style() const;
+ String weight() const;
+ String stretch() const;
+ String unicodeRange() const;
+ String variant() const;
+ String featureSettings() const;
+
+private:
+ FontFace();
+
+ Ref<CSSFontFace> m_backing;
+};
+
+}
+
+#endif
Added: trunk/Source/WebCore/css/FontVariantBuilder.cpp (0 => 196510)
--- trunk/Source/WebCore/css/FontVariantBuilder.cpp (rev 0)
+++ trunk/Source/WebCore/css/FontVariantBuilder.cpp 2016-02-12 22:22:20 UTC (rev 196510)
@@ -0,0 +1,375 @@
+/*
+ * Copyright (C) 2015 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "FontVariantBuilder.h"
+
+#include "CSSPrimitiveValue.h"
+#include "CSSValueList.h"
+#include "CSSValuePool.h"
+#include "TextFlags.h"
+
+namespace WebCore {
+
+FontVariantLigaturesValues extractFontVariantLigatures(CSSValue& value)
+{
+ FontVariantLigatures common = FontVariantLigatures::Normal;
+ FontVariantLigatures discretionary = FontVariantLigatures::Normal;
+ FontVariantLigatures historical = FontVariantLigatures::Normal;
+ FontVariantLigatures contextualAlternates = FontVariantLigatures::Normal;
+
+ if (is<CSSValueList>(value)) {
+ for (auto& item : downcast<CSSValueList>(value)) {
+ switch (downcast<CSSPrimitiveValue>(item.get()).getValueID()) {
+ case CSSValueNoCommonLigatures:
+ common = FontVariantLigatures::No;
+ break;
+ case CSSValueCommonLigatures:
+ common = FontVariantLigatures::Yes;
+ break;
+ case CSSValueNoDiscretionaryLigatures:
+ discretionary = FontVariantLigatures::No;
+ break;
+ case CSSValueDiscretionaryLigatures:
+ discretionary = FontVariantLigatures::Yes;
+ break;
+ case CSSValueNoHistoricalLigatures:
+ historical = FontVariantLigatures::No;
+ break;
+ case CSSValueHistoricalLigatures:
+ historical = FontVariantLigatures::Yes;
+ break;
+ case CSSValueContextual:
+ contextualAlternates = FontVariantLigatures::Yes;
+ break;
+ case CSSValueNoContextual:
+ contextualAlternates = FontVariantLigatures::No;
+ break;
+ default:
+ ASSERT_NOT_REACHED();
+ break;
+ }
+ }
+ } else if (is<CSSPrimitiveValue>(value)) {
+ switch (downcast<CSSPrimitiveValue>(value).getValueID()) {
+ case CSSValueNormal:
+ break;
+ case CSSValueNone:
+ common = FontVariantLigatures::No;
+ discretionary = FontVariantLigatures::No;
+ historical = FontVariantLigatures::No;
+ contextualAlternates = FontVariantLigatures::No;
+ break;
+ default:
+ ASSERT_NOT_REACHED();
+ break;
+ }
+ }
+
+ return FontVariantLigaturesValues(common, discretionary, historical, contextualAlternates);
+}
+
+FontVariantNumericValues extractFontVariantNumeric(CSSValue& value)
+{
+ FontVariantNumericFigure figure = FontVariantNumericFigure::Normal;
+ FontVariantNumericSpacing spacing = FontVariantNumericSpacing::Normal;
+ FontVariantNumericFraction fraction = FontVariantNumericFraction::Normal;
+ FontVariantNumericOrdinal ordinal = FontVariantNumericOrdinal::Normal;
+ FontVariantNumericSlashedZero slashedZero = FontVariantNumericSlashedZero::Normal;
+
+ if (is<CSSValueList>(value)) {
+ for (auto& item : downcast<CSSValueList>(value)) {
+ switch (downcast<CSSPrimitiveValue>(item.get()).getValueID()) {
+ case CSSValueLiningNums:
+ figure = FontVariantNumericFigure::LiningNumbers;
+ break;
+ case CSSValueOldstyleNums:
+ figure = FontVariantNumericFigure::OldStyleNumbers;
+ break;
+ case CSSValueProportionalNums:
+ spacing = FontVariantNumericSpacing::ProportionalNumbers;
+ break;
+ case CSSValueTabularNums:
+ spacing = FontVariantNumericSpacing::TabularNumbers;
+ break;
+ case CSSValueDiagonalFractions:
+ fraction = FontVariantNumericFraction::DiagonalFractions;
+ break;
+ case CSSValueStackedFractions:
+ fraction = FontVariantNumericFraction::StackedFractions;
+ break;
+ case CSSValueOrdinal:
+ ordinal = FontVariantNumericOrdinal::Yes;
+ break;
+ case CSSValueSlashedZero:
+ slashedZero = FontVariantNumericSlashedZero::Yes;
+ break;
+ default:
+ ASSERT_NOT_REACHED();
+ break;
+ }
+ }
+ } else if (is<CSSPrimitiveValue>(value))
+ ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNormal);
+
+ return FontVariantNumericValues(figure, spacing, fraction, ordinal, slashedZero);
+}
+
+FontVariantEastAsianValues extractFontVariantEastAsian(CSSValue& value)
+{
+ FontVariantEastAsianVariant variant = FontVariantEastAsianVariant::Normal;
+ FontVariantEastAsianWidth width = FontVariantEastAsianWidth::Normal;
+ FontVariantEastAsianRuby ruby = FontVariantEastAsianRuby::Normal;
+
+ if (is<CSSValueList>(value)) {
+ for (auto& item : downcast<CSSValueList>(value)) {
+ switch (downcast<CSSPrimitiveValue>(item.get()).getValueID()) {
+ case CSSValueJis78:
+ variant = FontVariantEastAsianVariant::Jis78;
+ break;
+ case CSSValueJis83:
+ variant = FontVariantEastAsianVariant::Jis83;
+ break;
+ case CSSValueJis90:
+ variant = FontVariantEastAsianVariant::Jis90;
+ break;
+ case CSSValueJis04:
+ variant = FontVariantEastAsianVariant::Jis04;
+ break;
+ case CSSValueSimplified:
+ variant = FontVariantEastAsianVariant::Simplified;
+ break;
+ case CSSValueTraditional:
+ variant = FontVariantEastAsianVariant::Traditional;
+ break;
+ case CSSValueFullWidth:
+ width = FontVariantEastAsianWidth::Full;
+ break;
+ case CSSValueProportionalWidth:
+ width = FontVariantEastAsianWidth::Proportional;
+ break;
+ case CSSValueRuby:
+ ruby = FontVariantEastAsianRuby::Yes;
+ break;
+ default:
+ ASSERT_NOT_REACHED();
+ break;
+ }
+ }
+ } else if (is<CSSPrimitiveValue>(value))
+ ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNormal);
+
+ return FontVariantEastAsianValues(variant, width, ruby);
+}
+
+Ref<CSSValue> computeFontVariant(const FontVariantSettings& variantSettings)
+{
+ if (variantSettings.isAllNormal())
+ return CSSValuePool::singleton().createIdentifierValue(CSSValueNormal);
+
+ auto list = CSSValueList::createSpaceSeparated();
+
+ switch (variantSettings.commonLigatures) {
+ case FontVariantLigatures::Normal:
+ break;
+ case FontVariantLigatures::Yes:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueCommonLigatures));
+ break;
+ case FontVariantLigatures::No:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueNoCommonLigatures));
+ break;
+ }
+
+ switch (variantSettings.discretionaryLigatures) {
+ case FontVariantLigatures::Normal:
+ break;
+ case FontVariantLigatures::Yes:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueDiscretionaryLigatures));
+ break;
+ case FontVariantLigatures::No:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueNoDiscretionaryLigatures));
+ break;
+ }
+
+ switch (variantSettings.historicalLigatures) {
+ case FontVariantLigatures::Normal:
+ break;
+ case FontVariantLigatures::Yes:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueHistoricalLigatures));
+ break;
+ case FontVariantLigatures::No:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueNoHistoricalLigatures));
+ break;
+ }
+
+ switch (variantSettings.contextualAlternates) {
+ case FontVariantLigatures::Normal:
+ break;
+ case FontVariantLigatures::Yes:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueContextual));
+ break;
+ case FontVariantLigatures::No:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueNoContextual));
+ break;
+ }
+
+ switch (variantSettings.position) {
+ case FontVariantPosition::Normal:
+ break;
+ case FontVariantPosition::Subscript:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueSub));
+ break;
+ case FontVariantPosition::Superscript:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueSuper));
+ break;
+ }
+
+ switch (variantSettings.caps) {
+ case FontVariantCaps::Normal:
+ break;
+ case FontVariantCaps::Small:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueSmallCaps));
+ break;
+ case FontVariantCaps::AllSmall:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueAllSmallCaps));
+ break;
+ case FontVariantCaps::Petite:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValuePetiteCaps));
+ break;
+ case FontVariantCaps::AllPetite:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueAllPetiteCaps));
+ break;
+ case FontVariantCaps::Unicase:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueUnicase));
+ break;
+ case FontVariantCaps::Titling:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueTitlingCaps));
+ break;
+ }
+
+ switch (variantSettings.numericFigure) {
+ case FontVariantNumericFigure::Normal:
+ break;
+ case FontVariantNumericFigure::LiningNumbers:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueLiningNums));
+ break;
+ case FontVariantNumericFigure::OldStyleNumbers:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueOldstyleNums));
+ break;
+ }
+
+ switch (variantSettings.numericSpacing) {
+ case FontVariantNumericSpacing::Normal:
+ break;
+ case FontVariantNumericSpacing::ProportionalNumbers:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueProportionalNums));
+ break;
+ case FontVariantNumericSpacing::TabularNumbers:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueTabularNums));
+ break;
+ }
+
+ switch (variantSettings.numericFraction) {
+ case FontVariantNumericFraction::Normal:
+ break;
+ case FontVariantNumericFraction::DiagonalFractions:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueDiagonalFractions));
+ break;
+ case FontVariantNumericFraction::StackedFractions:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueStackedFractions));
+ break;
+ }
+
+ switch (variantSettings.numericOrdinal) {
+ case FontVariantNumericOrdinal::Normal:
+ break;
+ case FontVariantNumericOrdinal::Yes:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueOrdinal));
+ break;
+ }
+
+ switch (variantSettings.numericSlashedZero) {
+ case FontVariantNumericSlashedZero::Normal:
+ break;
+ case FontVariantNumericSlashedZero::Yes:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueSlashedZero));
+ break;
+ }
+
+ switch (variantSettings.alternates) {
+ case FontVariantAlternates::Normal:
+ break;
+ case FontVariantAlternates::HistoricalForms:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueHistoricalForms));
+ break;
+ }
+
+ switch (variantSettings.eastAsianVariant) {
+ case FontVariantEastAsianVariant::Normal:
+ break;
+ case FontVariantEastAsianVariant::Jis78:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueJis78));
+ break;
+ case FontVariantEastAsianVariant::Jis83:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueJis83));
+ break;
+ case FontVariantEastAsianVariant::Jis90:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueJis90));
+ break;
+ case FontVariantEastAsianVariant::Jis04:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueJis04));
+ break;
+ case FontVariantEastAsianVariant::Simplified:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueSimplified));
+ break;
+ case FontVariantEastAsianVariant::Traditional:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueTraditional));
+ break;
+ }
+
+ switch (variantSettings.eastAsianWidth) {
+ case FontVariantEastAsianWidth::Normal:
+ break;
+ case FontVariantEastAsianWidth::Full:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueFullWidth));
+ break;
+ case FontVariantEastAsianWidth::Proportional:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueProportionalWidth));
+ break;
+ }
+
+ switch (variantSettings.eastAsianRuby) {
+ case FontVariantEastAsianRuby::Normal:
+ break;
+ case FontVariantEastAsianRuby::Yes:
+ list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueRuby));
+ break;
+ }
+
+ return WTFMove(list);
+}
+
+}
+
Modified: trunk/Source/WebCore/css/FontVariantBuilder.h (196509 => 196510)
--- trunk/Source/WebCore/css/FontVariantBuilder.h 2016-02-12 22:17:30 UTC (rev 196509)
+++ trunk/Source/WebCore/css/FontVariantBuilder.h 2016-02-12 22:22:20 UTC (rev 196510)
@@ -26,171 +26,22 @@
#ifndef FontVariantBuilder_h
#define FontVariantBuilder_h
+#include <wtf/Ref.h>
+
namespace WebCore {
-template <typename T>
-inline void applyValueFontVariantLigatures(T& receiver, CSSValue& value)
-{
- FontVariantLigatures common = FontVariantLigatures::Normal;
- FontVariantLigatures discretionary = FontVariantLigatures::Normal;
- FontVariantLigatures historical = FontVariantLigatures::Normal;
- FontVariantLigatures contextualAlternates = FontVariantLigatures::Normal;
+class CSSValue;
+struct FontVariantSettings;
+struct FontVariantLigaturesValues;
+struct FontVariantNumericValues;
+struct FontVariantEastAsianValues;
- if (is<CSSValueList>(value)) {
- for (auto& item : downcast<CSSValueList>(value)) {
- switch (downcast<CSSPrimitiveValue>(item.get()).getValueID()) {
- case CSSValueNoCommonLigatures:
- common = FontVariantLigatures::No;
- break;
- case CSSValueCommonLigatures:
- common = FontVariantLigatures::Yes;
- break;
- case CSSValueNoDiscretionaryLigatures:
- discretionary = FontVariantLigatures::No;
- break;
- case CSSValueDiscretionaryLigatures:
- discretionary = FontVariantLigatures::Yes;
- break;
- case CSSValueNoHistoricalLigatures:
- historical = FontVariantLigatures::No;
- break;
- case CSSValueHistoricalLigatures:
- historical = FontVariantLigatures::Yes;
- break;
- case CSSValueContextual:
- contextualAlternates = FontVariantLigatures::Yes;
- break;
- case CSSValueNoContextual:
- contextualAlternates = FontVariantLigatures::No;
- break;
- default:
- ASSERT_NOT_REACHED();
- break;
- }
- }
- } else if (is<CSSPrimitiveValue>(value)) {
- switch (downcast<CSSPrimitiveValue>(value).getValueID()) {
- case CSSValueNormal:
- break;
- case CSSValueNone:
- common = FontVariantLigatures::No;
- discretionary = FontVariantLigatures::No;
- historical = FontVariantLigatures::No;
- contextualAlternates = FontVariantLigatures::No;
- break;
- default:
- ASSERT_NOT_REACHED();
- break;
- }
- }
+FontVariantLigaturesValues extractFontVariantLigatures(CSSValue&);
+FontVariantNumericValues extractFontVariantNumeric(CSSValue&);
+FontVariantEastAsianValues extractFontVariantEastAsian(CSSValue&);
- receiver.setVariantCommonLigatures(common);
- receiver.setVariantDiscretionaryLigatures(discretionary);
- receiver.setVariantHistoricalLigatures(historical);
- receiver.setVariantContextualAlternates(contextualAlternates);
-}
+Ref<CSSValue> computeFontVariant(const FontVariantSettings&);
-template <typename T>
-inline void applyValueFontVariantNumeric(T& receiver, CSSValue& value)
-{
- FontVariantNumericFigure figure = FontVariantNumericFigure::Normal;
- FontVariantNumericSpacing spacing = FontVariantNumericSpacing::Normal;
- FontVariantNumericFraction fraction = FontVariantNumericFraction::Normal;
- FontVariantNumericOrdinal ordinal = FontVariantNumericOrdinal::Normal;
- FontVariantNumericSlashedZero slashedZero = FontVariantNumericSlashedZero::Normal;
-
- if (is<CSSValueList>(value)) {
- for (auto& item : downcast<CSSValueList>(value)) {
- switch (downcast<CSSPrimitiveValue>(item.get()).getValueID()) {
- case CSSValueLiningNums:
- figure = FontVariantNumericFigure::LiningNumbers;
- break;
- case CSSValueOldstyleNums:
- figure = FontVariantNumericFigure::OldStyleNumbers;
- break;
- case CSSValueProportionalNums:
- spacing = FontVariantNumericSpacing::ProportionalNumbers;
- break;
- case CSSValueTabularNums:
- spacing = FontVariantNumericSpacing::TabularNumbers;
- break;
- case CSSValueDiagonalFractions:
- fraction = FontVariantNumericFraction::DiagonalFractions;
- break;
- case CSSValueStackedFractions:
- fraction = FontVariantNumericFraction::StackedFractions;
- break;
- case CSSValueOrdinal:
- ordinal = FontVariantNumericOrdinal::Yes;
- break;
- case CSSValueSlashedZero:
- slashedZero = FontVariantNumericSlashedZero::Yes;
- break;
- default:
- ASSERT_NOT_REACHED();
- break;
- }
- }
- } else if (is<CSSPrimitiveValue>(value))
- ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNormal);
-
- receiver.setVariantNumericFigure(figure);
- receiver.setVariantNumericSpacing(spacing);
- receiver.setVariantNumericFraction(fraction);
- receiver.setVariantNumericOrdinal(ordinal);
- receiver.setVariantNumericSlashedZero(slashedZero);
}
-template <typename T>
-inline void applyValueFontVariantEastAsian(T& receiver, CSSValue& value)
-{
- FontVariantEastAsianVariant variant = FontVariantEastAsianVariant::Normal;
- FontVariantEastAsianWidth width = FontVariantEastAsianWidth::Normal;
- FontVariantEastAsianRuby ruby = FontVariantEastAsianRuby::Normal;
-
- if (is<CSSValueList>(value)) {
- for (auto& item : downcast<CSSValueList>(value)) {
- switch (downcast<CSSPrimitiveValue>(item.get()).getValueID()) {
- case CSSValueJis78:
- variant = FontVariantEastAsianVariant::Jis78;
- break;
- case CSSValueJis83:
- variant = FontVariantEastAsianVariant::Jis83;
- break;
- case CSSValueJis90:
- variant = FontVariantEastAsianVariant::Jis90;
- break;
- case CSSValueJis04:
- variant = FontVariantEastAsianVariant::Jis04;
- break;
- case CSSValueSimplified:
- variant = FontVariantEastAsianVariant::Simplified;
- break;
- case CSSValueTraditional:
- variant = FontVariantEastAsianVariant::Traditional;
- break;
- case CSSValueFullWidth:
- width = FontVariantEastAsianWidth::Full;
- break;
- case CSSValueProportionalWidth:
- width = FontVariantEastAsianWidth::Proportional;
- break;
- case CSSValueRuby:
- ruby = FontVariantEastAsianRuby::Yes;
- break;
- default:
- ASSERT_NOT_REACHED();
- break;
- }
- }
- } else if (is<CSSPrimitiveValue>(value))
- ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNormal);
-
- receiver.setVariantEastAsianVariant(variant);
- receiver.setVariantEastAsianWidth(width);
- receiver.setVariantEastAsianRuby(ruby);
-}
-
-}
-
#endif
Modified: trunk/Source/WebCore/css/StyleBuilderCustom.h (196509 => 196510)
--- trunk/Source/WebCore/css/StyleBuilderCustom.h 2016-02-12 22:17:30 UTC (rev 196509)
+++ trunk/Source/WebCore/css/StyleBuilderCustom.h 2016-02-12 22:22:20 UTC (rev 196510)
@@ -1407,7 +1407,11 @@
inline void StyleBuilderCustom::applyValueFontVariantLigatures(StyleResolver& styleResolver, CSSValue& value)
{
auto fontDescription = styleResolver.fontDescription();
- WebCore::applyValueFontVariantLigatures(fontDescription, value);
+ auto variantLigatures = extractFontVariantLigatures(value);
+ fontDescription.setVariantCommonLigatures(variantLigatures.commonLigatures);
+ fontDescription.setVariantDiscretionaryLigatures(variantLigatures.discretionaryLigatures);
+ fontDescription.setVariantHistoricalLigatures(variantLigatures.historicalLigatures);
+ fontDescription.setVariantContextualAlternates(variantLigatures.contextualAlternates);
styleResolver.setFontDescription(fontDescription);
}
@@ -1436,7 +1440,12 @@
inline void StyleBuilderCustom::applyValueFontVariantNumeric(StyleResolver& styleResolver, CSSValue& value)
{
auto fontDescription = styleResolver.fontDescription();
- WebCore::applyValueFontVariantNumeric(fontDescription, value);
+ auto variantNumeric = extractFontVariantNumeric(value);
+ fontDescription.setVariantNumericFigure(variantNumeric.figure);
+ fontDescription.setVariantNumericSpacing(variantNumeric.spacing);
+ fontDescription.setVariantNumericFraction(variantNumeric.fraction);
+ fontDescription.setVariantNumericOrdinal(variantNumeric.ordinal);
+ fontDescription.setVariantNumericSlashedZero(variantNumeric.slashedZero);
styleResolver.setFontDescription(fontDescription);
}
@@ -1461,7 +1470,10 @@
inline void StyleBuilderCustom::applyValueFontVariantEastAsian(StyleResolver& styleResolver, CSSValue& value)
{
auto fontDescription = styleResolver.fontDescription();
- WebCore::applyValueFontVariantEastAsian(fontDescription, value);
+ auto variantEastAsian = extractFontVariantEastAsian(value);
+ fontDescription.setVariantEastAsianVariant(variantEastAsian.variant);
+ fontDescription.setVariantEastAsianWidth(variantEastAsian.width);
+ fontDescription.setVariantEastAsianRuby(variantEastAsian.ruby);
styleResolver.setFontDescription(fontDescription);
}
Modified: trunk/Source/WebCore/platform/text/TextFlags.h (196509 => 196510)
--- trunk/Source/WebCore/platform/text/TextFlags.h 2016-02-12 22:17:30 UTC (rev 196509)
+++ trunk/Source/WebCore/platform/text/TextFlags.h 2016-02-12 22:22:20 UTC (rev 196510)
@@ -248,6 +248,63 @@
FontVariantEastAsianRuby eastAsianRuby;
};
+struct FontVariantLigaturesValues {
+ FontVariantLigaturesValues(
+ FontVariantLigatures commonLigatures,
+ FontVariantLigatures discretionaryLigatures,
+ FontVariantLigatures historicalLigatures,
+ FontVariantLigatures contextualAlternates)
+ : commonLigatures(commonLigatures)
+ , discretionaryLigatures(discretionaryLigatures)
+ , historicalLigatures(historicalLigatures)
+ , contextualAlternates(contextualAlternates)
+ {
+ }
+
+ FontVariantLigatures commonLigatures;
+ FontVariantLigatures discretionaryLigatures;
+ FontVariantLigatures historicalLigatures;
+ FontVariantLigatures contextualAlternates;
+};
+
+struct FontVariantNumericValues {
+ FontVariantNumericValues(
+ FontVariantNumericFigure figure,
+ FontVariantNumericSpacing spacing,
+ FontVariantNumericFraction fraction,
+ FontVariantNumericOrdinal ordinal,
+ FontVariantNumericSlashedZero slashedZero)
+ : figure(figure)
+ , spacing(spacing)
+ , fraction(fraction)
+ , ordinal(ordinal)
+ , slashedZero(slashedZero)
+ {
+ }
+
+ FontVariantNumericFigure figure;
+ FontVariantNumericSpacing spacing;
+ FontVariantNumericFraction fraction;
+ FontVariantNumericOrdinal ordinal;
+ FontVariantNumericSlashedZero slashedZero;
+};
+
+struct FontVariantEastAsianValues {
+ FontVariantEastAsianValues(
+ FontVariantEastAsianVariant variant,
+ FontVariantEastAsianWidth width,
+ FontVariantEastAsianRuby ruby)
+ : variant(variant)
+ , width(width)
+ , ruby(ruby)
+ {
+ }
+
+ FontVariantEastAsianVariant variant;
+ FontVariantEastAsianWidth width;
+ FontVariantEastAsianRuby ruby;
+};
+
enum FontWidthVariant {
RegularWidth,
HalfWidth,
