Changeset 192819 in webkit


Ignore:
Timestamp:
Nov 30, 2015 1:20:32 PM (8 years ago)
Author:
mmaxfield@apple.com
Message:

Unify font-variant-* with font-variant shorthand
​https://bugs.webkit.org/show_bug.cgi?id=149773

Reviewed by Darin Adler.

Source/WebCore:

This patch makes font-variant a shorthand for the following properties:
font-variant-ligatures
font-variant-position
font-variant-caps
font-variant-numeric
font-variant-alternates
font-variant-east-asian

This is consistent with the CSS Fonts Level 3 spec.

This patch also migrates the "font" longhand to use the font-variant-caps
property.

Test: fast/text/font-variant-shorthand.html

  • css/CSSComputedStyleDeclaration.cpp:

(WebCore::fontVariantEastAsianPropertyValue): Rename FontVariantEastAsian values.
(WebCore::fontVariantFromStyle): We must consult with the longhand properties to determine
font-variant computed style.
(WebCore::ComputedStyleExtractor::propertyValue): Don't put any-old font-variant-caps inside
the font shorthand.

  • css/CSSFontSelector.cpp:

(WebCore::CSSFontSelector::addFontFaceRule): Guard against incorrect downcasts (due to inherit
of the new shorthand property).

  • css/CSSParser.cpp: Parse font-variant as a shorthand. Also implement its "normal" and "none" values.

(WebCore::CSSParser::parseValue):
(WebCore::CSSParser::parseFont):
(WebCore::CSSParser::parseSystemFont):
(WebCore::CSSParser::parseFontVariantLigatures):
(WebCore::CSSParser::parseFontVariantNumeric):
(WebCore::CSSParser::parseFontVariantEastAsian):
(WebCore::CSSParser::parseFontVariant):
(WebCore::isValidKeywordPropertyAndValue): Deleted.
(WebCore::isKeywordPropertyID): Deleted.

  • css/CSSParser.h:
  • css/CSSPropertyNames.in: Turn font-variant into a shorthand property.
  • css/FontVariantBuilder.h: Guard against incorrect downcasts. Also update for renamed

FontVariantEastAsian type.
(WebCore::applyValueFontVariantLigatures):
(WebCore::applyValueFontVariantNumeric):
(WebCore::applyValueFontVariantEastAsian):

  • css/StyleProperties.cpp: Update to use the more specific property.

(WebCore::StyleProperties::appendFontLonghandValueIfExplicit):
(WebCore::StyleProperties::fontValue):
(WebCore::StyleProperties::asText):

  • css/StyleResolver.cpp: Ditto.

(WebCore::StyleResolver::isValidCueStyleProperty):

  • editing/EditingStyle.cpp: Ditto.
  • editing/cocoa/HTMLConverter.mm: Ditto.

(HTMLConverterCaches::propertyValueForNode):
(HTMLConverter::computedAttributesForElement):

  • editing/ios/EditorIOS.mm: Ditto.

(WebCore::Editor::removeUnchangeableStyles):

  • html/canvas/CanvasRenderingContext2D.cpp: Ditto.

(WebCore::CanvasRenderingContext2D::font):
(WebCore::CanvasRenderingContext2D::setFont):

  • platform/graphics/FontCache.h: Removing duplicate cache key value.

(WebCore::FontDescriptionKey::makeFlagsKey):

  • platform/graphics/FontCascade.cpp: Migrate to the new font-variant-caps from the old member variable.

(WebCore::FontCascade::glyphDataForCharacter):

  • platform/graphics/FontCascade.h: Ditto.

(WebCore::FontCascade::isSmallCaps):

  • platform/graphics/FontDescription.cpp: Ditto.

(WebCore::FontDescription::FontDescription):

  • platform/graphics/FontDescription.h: Ditto.

(WebCore::FontCascadeDescription::equalForTextAutoSizing):
(WebCore::FontDescription::smallCaps): Deleted.
(WebCore::FontDescription::setSmallCaps): Deleted.
(WebCore::FontDescription::setIsSmallCaps): Deleted.
(WebCore::FontDescription::operator==): Deleted.

  • platform/graphics/cocoa/FontCacheCoreText.cpp: Rename FontVariantEastAsianWidth.

(WebCore::computeFeatureSettingsFromVariants):

  • platform/text/TextFlags.h: Ditto.

(WebCore::FontVariantSettings::operator==):

  • rendering/RenderText.cpp: Migrage to the new font-variant-caps from the old member variable.

(WebCore::RenderText::widthFromCache):

LayoutTests:

Update tests. Also temporarily skip existing font-features tests until
​https://bugs.webkit.org/show_bug.cgi?id=149774 is fixed.

  • css3/font-variant-parsing-expected.txt:
  • css3/font-variant-parsing.html:
  • fast/css/font-property-priority-expected.txt:
  • fast/css/font-shorthand-expected.txt:
  • fast/css/parsing-font-variant-ligatures-expected.txt:
  • fast/css/parsing-font-variant-ligatures.html:
  • fast/inspector-support/style-expected.txt:
  • fast/text/font-variant-shorthand-expected.txt: Added.
  • fast/text/font-variant-shorthand.html: Added.
  • platform/mac/TestExpectations:
  • platform/mac/fast/writing-mode/broken-ideograph-small-caps-expected.txt:
Location:
trunk
Files:
2 added
31 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r192813 r192819  
     12015-11-30  Myles C. Maxfield  <mmaxfield@apple.com>
     2
     3        Unify font-variant-* with font-variant shorthand
     4        https://bugs.webkit.org/show_bug.cgi?id=149773
     5
     6        Reviewed by Darin Adler.
     7
     8        Update tests. Also temporarily skip existing font-features tests until
     9        https://bugs.webkit.org/show_bug.cgi?id=149774 is fixed.
     10
     11        * css3/font-variant-parsing-expected.txt:
     12        * css3/font-variant-parsing.html:
     13        * fast/css/font-property-priority-expected.txt:
     14        * fast/css/font-shorthand-expected.txt:
     15        * fast/css/parsing-font-variant-ligatures-expected.txt:
     16        * fast/css/parsing-font-variant-ligatures.html:
     17        * fast/inspector-support/style-expected.txt:
     18        * fast/text/font-variant-shorthand-expected.txt: Added.
     19        * fast/text/font-variant-shorthand.html: Added.
     20        * platform/mac/TestExpectations:
     21        * platform/mac/fast/writing-mode/broken-ideograph-small-caps-expected.txt:
     22
    1232015-11-30  Brady Eidson  <beidson@apple.com>
    224

  • trunk/LayoutTests/css3/font-variant-parsing-expected.txt

    r190192 r192819  
    44PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-ligatures').cssText is "normal"
    55PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-ligatures').cssText is "common-ligatures"
    6 PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-ligatures').cssText is "normal"
     6PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-ligatures').cssText is "common-ligatures"
    77PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-ligatures').cssText is "no-common-ligatures"
    88PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-ligatures').cssText is "discretionary-ligatures"
    … …  
    5050PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-numeric').cssText is "slashed-zero"
    5151PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-numeric').cssText is "lining-nums slashed-zero"
    52 PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-numeric').cssText is "normal"
    53 PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-numeric').cssText is "normal"
    54 PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-numeric').cssText is "normal"
     52PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-numeric').cssText is "oldstyle-nums"
     53PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-numeric').cssText is "tabular-nums"
     54PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-numeric').cssText is "stacked-fractions"
    5555PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-numeric').cssText is "lining-nums proportional-nums"
    5656PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-numeric').cssText is "lining-nums diagonal-fractions"
    … …  
    7575PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-east-asian').cssText is "proportional-width"
    7676PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-east-asian').cssText is "ruby"
    77 PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-east-asian').cssText is "normal"
    78 PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-east-asian').cssText is "normal"
     77PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-east-asian').cssText is "jis83"
     78PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-east-asian').cssText is "traditional"
    7979PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-east-asian').cssText is "traditional full-width"
    8080PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-east-asian').cssText is "jis04 proportional-width"
    8181PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-east-asian').cssText is "jis04 proportional-width ruby"
    8282PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-east-asian').cssText is "jis83 ruby"
    83 PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-east-asian').cssText is "normal"
     83PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-east-asian').cssText is "proportional-width"
    8484PASS successfullyParsed is true
    8585

  • trunk/LayoutTests/css3/font-variant-parsing.html

    r190192 r192819  
    2121runTest("font-variant-ligatures", "notavalidvalue", "normal");
    2222runTest("font-variant-ligatures", "common-ligatures", "common-ligatures");
    23 runTest("font-variant-ligatures", "common-ligatures common-ligatures", "normal");
     23runTest("font-variant-ligatures", "common-ligatures common-ligatures", "common-ligatures");
    2424runTest("font-variant-ligatures", "no-common-ligatures", "no-common-ligatures");
    2525runTest("font-variant-ligatures", "discretionary-ligatures", "discretionary-ligatures");
    … …  
    7070runTest("font-variant-numeric", "slashed-zero", "slashed-zero");
    7171runTest("font-variant-numeric", "lining-nums slashed-zero", "lining-nums slashed-zero");
    72 runTest("font-variant-numeric", "lining-nums oldstyle-nums", "normal");
    73 runTest("font-variant-numeric", "proportional-nums tabular-nums", "normal");
    74 runTest("font-variant-numeric", "diagonal-fractions stacked-fractions", "normal");
     72runTest("font-variant-numeric", "lining-nums oldstyle-nums", "oldstyle-nums");
     73runTest("font-variant-numeric", "proportional-nums tabular-nums", "tabular-nums");
     74runTest("font-variant-numeric", "diagonal-fractions stacked-fractions", "stacked-fractions");
    7575runTest("font-variant-numeric", "lining-nums proportional-nums", "lining-nums proportional-nums");
    7676runTest("font-variant-numeric", "lining-nums diagonal-fractions", "lining-nums diagonal-fractions");
    … …  
    9797runTest("font-variant-east-asian", "proportional-width", "proportional-width");
    9898runTest("font-variant-east-asian", "ruby", "ruby");
    99 runTest("font-variant-east-asian", "jis78 jis83", "normal");
    100 runTest("font-variant-east-asian", "jis90 traditional", "normal");
     99runTest("font-variant-east-asian", "jis78 jis83", "jis83");
     100runTest("font-variant-east-asian", "jis90 traditional", "traditional");
    101101runTest("font-variant-east-asian", "full-width traditional", "traditional full-width");
    102102runTest("font-variant-east-asian", "jis04 proportional-width", "jis04 proportional-width");
    103103runTest("font-variant-east-asian", "jis04 proportional-width ruby", "jis04 proportional-width ruby");
    104104runTest("font-variant-east-asian", "jis83 ruby", "jis83 ruby");
    105 runTest("font-variant-east-asian", "full-width proportional-width", "normal");
     105runTest("font-variant-east-asian", "full-width proportional-width", "proportional-width");
    106106</script>
    107107<script src="../resources/js-test-post.js"></script>

  • trunk/LayoutTests/fast/css/font-property-priority-expected.txt

    r35910 r192819  
    22
    33Property 'font-weight' has priority 'important'.
    4 Property 'font-variant' has priority 'important'.
     4Property 'font-variant-caps' has priority 'important'.
    55Property 'font-style' has priority 'important'.
    66

  • trunk/LayoutTests/fast/css/font-shorthand-expected.txt

    r114895 r192819  
    22Font for '12px monospace':
    33font-style: normal (original property was font and property was implicitly set.)
    4 font-variant: normal (original property was font and property was implicitly set.)
     4font-variant-caps: normal (original property was font and property was implicitly set.)
    55font-weight: normal (original property was font and property was implicitly set.)
    66font-size: 12px (original property was font)
    … …  
    1010Font for '12px/24px serif':
    1111font-style: normal (original property was font and property was implicitly set.)
    12 font-variant: normal (original property was font and property was implicitly set.)
     12font-variant-caps: normal (original property was font and property was implicitly set.)
    1313font-weight: normal (original property was font and property was implicitly set.)
    1414font-size: 12px (original property was font)
    … …  
    1818Font for 'normal 12px serif':
    1919font-style: normal (original property was font)
    20 font-variant: normal (original property was font and property was implicitly set.)
     20font-variant-caps: normal (original property was font and property was implicitly set.)
    2121font-weight: normal (original property was font and property was implicitly set.)
    2222font-size: 12px (original property was font)
    … …  
    2626Font for 'normal normal 12px serif':
    2727font-style: normal (original property was font)
    28 font-variant: normal (original property was font)
     28font-variant-caps: normal (original property was font)
    2929font-weight: normal (original property was font and property was implicitly set.)
    3030font-size: 12px (original property was font)
    … …  
    3434Font for 'normal normal normal 12px serif':
    3535font-style: normal (original property was font)
    36 font-variant: normal (original property was font)
     36font-variant-caps: normal (original property was font)
    3737font-weight: normal (original property was font)
    3838font-size: 12px (original property was font)
    … …  
    4242Font for 'italic small-caps 12px/24px serif':
    4343font-style: italic (original property was font)
    44 font-variant: small-caps (original property was font)
     44font-variant-caps: small-caps (original property was font)
    4545font-weight: normal (original property was font and property was implicitly set.)
    4646font-size: 12px (original property was font)
    … …  
    5151font-style: italic (original property was font)
    5252font-weight: bold (original property was font)
    53 font-variant: normal (original property was font and property was implicitly set.)
     53font-variant-caps: normal (original property was font and property was implicitly set.)
    5454font-size: 12px (original property was font)
    5555line-height: 24px (original property was font)
    … …  
    5757
    5858Font for 'small-caps bold 14px/28px Arial, sans-serif':
    59 font-variant: small-caps (original property was font)
     59font-variant-caps: small-caps (original property was font)
    6060font-weight: bold (original property was font)
    6161font-style: normal (original property was font and property was implicitly set.)
    … …  
    6666Font for 'italic small-caps bold 14px/28px Arial, sans-serif':
    6767font-style: italic (original property was font)
    68 font-variant: small-caps (original property was font)
     68font-variant-caps: small-caps (original property was font)
    6969font-weight: bold (original property was font)
    7070font-size: 14px (original property was font)

  • trunk/LayoutTests/fast/css/parsing-font-variant-ligatures-expected.txt

    r104882 r192819  
    1414PASS: 'historical-ligatures' parsed as 'historical-ligatures' and computed to 'historical-ligatures'
    1515
    16 PASS: 'no-common-ligatures no-common-ligatures' parsed as '' and computed to 'normal'
     16PASS: 'no-common-ligatures no-common-ligatures' parsed as 'no-common-ligatures' and computed to 'no-common-ligatures'
    1717PASS: 'common-ligatures no-discretionary-ligatures' parsed as 'common-ligatures no-discretionary-ligatures' and computed to 'common-ligatures no-discretionary-ligatures'
    1818PASS: 'common-ligatures no-discretionary-ligatures historical-ligatures' parsed as 'common-ligatures no-discretionary-ligatures historical-ligatures' and computed to 'common-ligatures no-discretionary-ligatures historical-ligatures'

  • trunk/LayoutTests/fast/css/parsing-font-variant-ligatures.html

    r190192 r192819  
    4444
    4545    log("");
    46     test('no-common-ligatures no-common-ligatures', '', 'normal');
     46    test('no-common-ligatures no-common-ligatures', 'no-common-ligatures', 'no-common-ligatures');
    4747    test('common-ligatures no-discretionary-ligatures', 'common-ligatures no-discretionary-ligatures', 'common-ligatures no-discretionary-ligatures');
    4848    test('common-ligatures no-discretionary-ligatures historical-ligatures', 'common-ligatures no-discretionary-ligatures historical-ligatures', 'common-ligatures no-discretionary-ligatures historical-ligatures');

  • trunk/LayoutTests/fast/inspector-support/style-expected.txt

    r116645 r192819  
    1717color: white
    1818font-style: normal (original property was font and property was implicitly set.)
    19 font-variant: normal (original property was font and property was implicitly set.)
     19font-variant-caps: normal (original property was font and property was implicitly set.)
    2020font-weight: normal (original property was font and property was implicitly set.)
    2121font-size: 24px (original property was font)

  • trunk/LayoutTests/platform/mac/TestExpectations

    r192765 r192819  
    13981398
    13991399webkit.org/b/151469 imported/w3c/html-templates/parsing-html-templates/creating-an-element-for-the-token/template-owner-document.html [ Pass Crash ]
     1400
     1401# Temporarily disable font-features tests until synthesis for font-variant-caps is implemented.
     1402webkit.org/b/149774 css3/font-feature-settings-font-face-rendering.html [ Pass Failure ImageOnlyFailure ]
     1403webkit.org/b/149774 css3/font-feature-settings-rendering.html [ Pass Failure ImageOnlyFailure ]
     1404webkit.org/b/149774 css3/font-variant-all.html [ Pass Failure ImageOnlyFailure ]
     1405webkit.org/b/149774 css3/font-variant-font-face-all.html [ Pass Failure ImageOnlyFailure ]
     1406webkit.org/b/149774 css3/font-variant-font-face-override.html [ Pass Failure ImageOnlyFailure ]

  • trunk/LayoutTests/platform/mac/fast/writing-mode/broken-ideograph-small-caps-expected.txt

    r185655 r192819  
    1414        RenderBlock {DIV} at (278,1) size 277x275 [bgcolor=#FFFFEE]
    1515          RenderBlock {P} at (14,28) size 63x219 [bgcolor=#FFAAAA] [border: none (20px solid #FF8888) none (20px solid #FF8888)]
    16             RenderText {#text} at (21,1) size 20x195
    17               text run at (21,1) width 195: "\x{7B2C}\x{4E00}\x{6BB5}\x{843D} Paragraph 1"
     16            RenderText {#text} at (21,1) size 20x175
     17              text run at (21,1) width 175: "\x{7B2C}\x{4E00}\x{6BB5}\x{843D} Paragraph 1"
    1818          RenderBlock {P} at (90,28) size 63x219 [bgcolor=#FFAAAA] [border: none (20px solid #FF8888) none (20px solid #FF8888)]
    19             RenderText {#text} at (21,1) size 20x195
    20               text run at (21,1) width 195: "\x{7B2C}\x{4E8C}\x{6BB5}\x{843D} Paragraph 2"
     19            RenderText {#text} at (21,1) size 20x181
     20              text run at (21,1) width 181: "\x{7B2C}\x{4E8C}\x{6BB5}\x{843D} Paragraph 2"

  • trunk/Source/WebCore/ChangeLog

    r192813 r192819  
     12015-11-30  Myles C. Maxfield  <mmaxfield@apple.com>
     2
     3        Unify font-variant-* with font-variant shorthand
     4        https://bugs.webkit.org/show_bug.cgi?id=149773
     5
     6        Reviewed by Darin Adler.
     7
     8        This patch makes font-variant a shorthand for the following properties:
     9        font-variant-ligatures
     10        font-variant-position
     11        font-variant-caps
     12        font-variant-numeric
     13        font-variant-alternates
     14        font-variant-east-asian
     15
     16        This is consistent with the CSS Fonts Level 3 spec.
     17
     18        This patch also migrates the "font" longhand to use the font-variant-caps
     19        property.
     20
     21        Test: fast/text/font-variant-shorthand.html
     22
     23        * css/CSSComputedStyleDeclaration.cpp:
     24        (WebCore::fontVariantEastAsianPropertyValue): Rename FontVariantEastAsian values.
     25        (WebCore::fontVariantFromStyle): We must consult with the longhand properties to determine
     26        font-variant computed style.
     27        (WebCore::ComputedStyleExtractor::propertyValue): Don't put any-old font-variant-caps inside
     28        the font shorthand.
     29        * css/CSSFontSelector.cpp:
     30        (WebCore::CSSFontSelector::addFontFaceRule): Guard against incorrect downcasts (due to inherit
     31        of the new shorthand property).
     32        * css/CSSParser.cpp: Parse font-variant as a shorthand. Also implement its "normal" and "none" values.
     33        (WebCore::CSSParser::parseValue):
     34        (WebCore::CSSParser::parseFont):
     35        (WebCore::CSSParser::parseSystemFont):
     36        (WebCore::CSSParser::parseFontVariantLigatures):
     37        (WebCore::CSSParser::parseFontVariantNumeric):
     38        (WebCore::CSSParser::parseFontVariantEastAsian):
     39        (WebCore::CSSParser::parseFontVariant):
     40        (WebCore::isValidKeywordPropertyAndValue): Deleted.
     41        (WebCore::isKeywordPropertyID): Deleted.
     42        * css/CSSParser.h:
     43        * css/CSSPropertyNames.in: Turn font-variant into a shorthand property.
     44        * css/FontVariantBuilder.h: Guard against incorrect downcasts. Also update for renamed
     45        FontVariantEastAsian type.
     46        (WebCore::applyValueFontVariantLigatures):
     47        (WebCore::applyValueFontVariantNumeric):
     48        (WebCore::applyValueFontVariantEastAsian):
     49        * css/StyleProperties.cpp: Update to use the more specific property.
     50        (WebCore::StyleProperties::appendFontLonghandValueIfExplicit):
     51        (WebCore::StyleProperties::fontValue):
     52        (WebCore::StyleProperties::asText):
     53        * css/StyleResolver.cpp: Ditto.
     54        (WebCore::StyleResolver::isValidCueStyleProperty):
     55        * editing/EditingStyle.cpp: Ditto.
     56        * editing/cocoa/HTMLConverter.mm: Ditto.
     57        (HTMLConverterCaches::propertyValueForNode):
     58        (HTMLConverter::computedAttributesForElement):
     59        * editing/ios/EditorIOS.mm: Ditto.
     60        (WebCore::Editor::removeUnchangeableStyles):
     61        * html/canvas/CanvasRenderingContext2D.cpp: Ditto.
     62        (WebCore::CanvasRenderingContext2D::font):
     63        (WebCore::CanvasRenderingContext2D::setFont):
     64        * platform/graphics/FontCache.h: Removing duplicate cache key value.
     65        (WebCore::FontDescriptionKey::makeFlagsKey):
     66        * platform/graphics/FontCascade.cpp: Migrate to the new font-variant-caps from the old member variable.
     67        (WebCore::FontCascade::glyphDataForCharacter):
     68        * platform/graphics/FontCascade.h: Ditto.
     69        (WebCore::FontCascade::isSmallCaps):
     70        * platform/graphics/FontDescription.cpp: Ditto.
     71        (WebCore::FontDescription::FontDescription):
     72        * platform/graphics/FontDescription.h: Ditto.
     73        (WebCore::FontCascadeDescription::equalForTextAutoSizing):
     74        (WebCore::FontDescription::smallCaps): Deleted.
     75        (WebCore::FontDescription::setSmallCaps): Deleted.
     76        (WebCore::FontDescription::setIsSmallCaps): Deleted.
     77        (WebCore::FontDescription::operator==): Deleted.
     78        * platform/graphics/cocoa/FontCacheCoreText.cpp: Rename FontVariantEastAsianWidth.
     79        (WebCore::computeFeatureSettingsFromVariants):
     80        * platform/text/TextFlags.h: Ditto.
     81        (WebCore::FontVariantSettings::operator==):
     82        * rendering/RenderText.cpp: Migrage to the new font-variant-caps from the old member variable.
     83        (WebCore::RenderText::widthFromCache):
     84
    1852015-11-30  Brady Eidson  <beidson@apple.com>
    286

  • trunk/Source/WebCore/css/CSSComputedStyleDeclaration.cpp

    r191452 r192819  
    13831383    case FontVariantEastAsianWidth::Normal:
    13841384        break;
    1385     case FontVariantEastAsianWidth::FullWidth:
     1385    case FontVariantEastAsianWidth::Full:
    13861386        valueList->append(cssValuePool.createIdentifierValue(CSSValueFullWidth));
    13871387        break;
    1388     case FontVariantEastAsianWidth::ProportionalWidth:
     1388    case FontVariantEastAsianWidth::Proportional:
    13891389        valueList->append(cssValuePool.createIdentifierValue(CSSValueProportionalWidth));
    13901390        break;
    … …  
    18171817}
    18181818
    1819 static Ref<CSSPrimitiveValue> fontStyleFromStyle(RenderStyle* style)
    1820 {
    1821     if (style->fontDescription().italic())
     1819static Ref<CSSPrimitiveValue> fontStyleFromStyle(RenderStyle& style)
     1820{
     1821    if (style.fontDescription().italic())
    18221822        return CSSValuePool::singleton().createIdentifierValue(CSSValueItalic);
    18231823    return CSSValuePool::singleton().createIdentifierValue(CSSValueNormal);
    18241824}
    18251825
    1826 static Ref<CSSPrimitiveValue> fontVariantFromStyle(RenderStyle* style)
    1827 {
    1828     if (style->fontDescription().smallCaps())
    1829         return CSSValuePool::singleton().createIdentifierValue(CSSValueSmallCaps);
    1830     return CSSValuePool::singleton().createIdentifierValue(CSSValueNormal);
    1831 }
    1832 
    1833 static Ref<CSSPrimitiveValue> fontWeightFromStyle(RenderStyle* style)
    1834 {
    1835     switch (style->fontDescription().weight()) {
     1826static Ref<CSSValue> fontVariantFromStyle(RenderStyle& style)
     1827{
     1828    if (style.fontDescription().variantSettings().isAllNormal())
     1829        return CSSValuePool::singleton().createIdentifierValue(CSSValueNormal);
     1830
     1831    auto list = CSSValueList::createSpaceSeparated();
     1832
     1833    switch (style.fontDescription().variantCommonLigatures()) {
     1834    case FontVariantLigatures::Normal:
     1835        break;
     1836    case FontVariantLigatures::Yes:
     1837        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueCommonLigatures));
     1838        break;
     1839    case FontVariantLigatures::No:
     1840        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueNoCommonLigatures));
     1841        break;
     1842    }
     1843
     1844    switch (style.fontDescription().variantDiscretionaryLigatures()) {
     1845    case FontVariantLigatures::Normal:
     1846        break;
     1847    case FontVariantLigatures::Yes:
     1848        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueDiscretionaryLigatures));
     1849        break;
     1850    case FontVariantLigatures::No:
     1851        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueNoDiscretionaryLigatures));
     1852        break;
     1853    }
     1854
     1855    switch (style.fontDescription().variantHistoricalLigatures()) {
     1856    case FontVariantLigatures::Normal:
     1857        break;
     1858    case FontVariantLigatures::Yes:
     1859        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueHistoricalLigatures));
     1860        break;
     1861    case FontVariantLigatures::No:
     1862        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueNoHistoricalLigatures));
     1863        break;
     1864    }
     1865
     1866    switch (style.fontDescription().variantContextualAlternates()) {
     1867    case FontVariantLigatures::Normal:
     1868        break;
     1869    case FontVariantLigatures::Yes:
     1870        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueContextual));
     1871        break;
     1872    case FontVariantLigatures::No:
     1873        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueNoContextual));
     1874        break;
     1875    }
     1876
     1877    switch (style.fontDescription().variantPosition()) {
     1878    case FontVariantPosition::Normal:
     1879        break;
     1880    case FontVariantPosition::Subscript:
     1881        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueSub));
     1882        break;
     1883    case FontVariantPosition::Superscript:
     1884        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueSuper));
     1885        break;
     1886    }
     1887
     1888    switch (style.fontDescription().variantCaps()) {
     1889    case FontVariantCaps::Normal:
     1890        break;
     1891    case FontVariantCaps::Small:
     1892        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueSmallCaps));
     1893        break;
     1894    case FontVariantCaps::AllSmall:
     1895        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueAllSmallCaps));
     1896        break;
     1897    case FontVariantCaps::Petite:
     1898        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValuePetiteCaps));
     1899        break;
     1900    case FontVariantCaps::AllPetite:
     1901        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueAllPetiteCaps));
     1902        break;
     1903    case FontVariantCaps::Unicase:
     1904        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueUnicase));
     1905        break;
     1906    case FontVariantCaps::Titling:
     1907        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueTitlingCaps));
     1908        break;
     1909    }
     1910
     1911    switch (style.fontDescription().variantNumericFigure()) {
     1912    case FontVariantNumericFigure::Normal:
     1913        break;
     1914    case FontVariantNumericFigure::LiningNumbers:
     1915        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueLiningNums));
     1916        break;
     1917    case FontVariantNumericFigure::OldStyleNumbers:
     1918        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueOldstyleNums));
     1919        break;
     1920    }
     1921
     1922    switch (style.fontDescription().variantNumericSpacing()) {
     1923    case FontVariantNumericSpacing::Normal:
     1924        break;
     1925    case FontVariantNumericSpacing::ProportionalNumbers:
     1926        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueProportionalNums));
     1927        break;
     1928    case FontVariantNumericSpacing::TabularNumbers:
     1929        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueTabularNums));
     1930        break;
     1931    }
     1932
     1933    switch (style.fontDescription().variantNumericFraction()) {
     1934    case FontVariantNumericFraction::Normal:
     1935        break;
     1936    case FontVariantNumericFraction::DiagonalFractions:
     1937        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueDiagonalFractions));
     1938        break;
     1939    case FontVariantNumericFraction::StackedFractions:
     1940        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueStackedFractions));
     1941        break;
     1942    }
     1943
     1944    switch (style.fontDescription().variantNumericOrdinal()) {
     1945    case FontVariantNumericOrdinal::Normal:
     1946        break;
     1947    case FontVariantNumericOrdinal::Yes:
     1948        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueOrdinal));
     1949        break;
     1950    }
     1951
     1952    switch (style.fontDescription().variantNumericSlashedZero()) {
     1953    case FontVariantNumericSlashedZero::Normal:
     1954        break;
     1955    case FontVariantNumericSlashedZero::Yes:
     1956        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueSlashedZero));
     1957        break;
     1958    }
     1959
     1960    switch (style.fontDescription().variantAlternates()) {
     1961    case FontVariantAlternates::Normal:
     1962        break;
     1963    case FontVariantAlternates::HistoricalForms:
     1964        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueHistoricalForms));
     1965        break;
     1966    }
     1967
     1968    switch (style.fontDescription().variantEastAsianVariant()) {
     1969    case FontVariantEastAsianVariant::Normal:
     1970        break;
     1971    case FontVariantEastAsianVariant::Jis78:
     1972        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueJis78));
     1973        break;
     1974    case FontVariantEastAsianVariant::Jis83:
     1975        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueJis83));
     1976        break;
     1977    case FontVariantEastAsianVariant::Jis90:
     1978        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueJis90));
     1979        break;
     1980    case FontVariantEastAsianVariant::Jis04:
     1981        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueJis04));
     1982        break;
     1983    case FontVariantEastAsianVariant::Simplified:
     1984        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueSimplified));
     1985        break;
     1986    case FontVariantEastAsianVariant::Traditional:
     1987        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueTraditional));
     1988        break;
     1989    }
     1990
     1991    switch (style.fontDescription().variantEastAsianWidth()) {
     1992    case FontVariantEastAsianWidth::Normal:
     1993        break;
     1994    case FontVariantEastAsianWidth::Full:
     1995        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueFullWidth));
     1996        break;
     1997    case FontVariantEastAsianWidth::Proportional:
     1998        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueProportionalWidth));
     1999        break;
     2000    }
     2001
     2002    switch (style.fontDescription().variantEastAsianRuby()) {
     2003    case FontVariantEastAsianRuby::Normal:
     2004        break;
     2005    case FontVariantEastAsianRuby::Yes:
     2006        list.get().append(CSSValuePool::singleton().createIdentifierValue(CSSValueRuby));
     2007        break;
     2008    }
     2009
     2010    return WTF::move(list);
     2011}
     2012
     2013static Ref<CSSPrimitiveValue> fontWeightFromStyle(RenderStyle& style)
     2014{
     2015    switch (style.fontDescription().weight()) {
    18362016    case FontWeight100:
    18372017        return CSSValuePool::singleton().createIdentifierValue(CSSValue100);
    … …  
    25182698        case CSSPropertyFont: {
    25192699            RefPtr<CSSFontValue> computedFont = CSSFontValue::create();
    2520             computedFont->style = fontStyleFromStyle(style.get());
    2521             computedFont->variant = fontVariantFromStyle(style.get());
    2522             computedFont->weight = fontWeightFromStyle(style.get());
     2700            computedFont->style = fontStyleFromStyle(*style);
     2701            if (style->fontDescription().variantCaps() == FontVariantCaps::Small)
     2702                computedFont->variant = CSSValuePool::singleton().createIdentifierValue(CSSValueSmallCaps);
     2703            else
     2704                computedFont->variant = CSSValuePool::singleton().createIdentifierValue(CSSValueNormal);
     2705            computedFont->weight = fontWeightFromStyle(*style);
    25232706            computedFont->size = fontSizeFromStyle(*style);
    25242707            computedFont->lineHeight = lineHeightFromStyle(*style);
    … …  
    25372720            return fontSizeFromStyle(*style);
    25382721        case CSSPropertyFontStyle:
    2539             return fontStyleFromStyle(style.get());
     2722            return fontStyleFromStyle(*style);
    25402723        case CSSPropertyFontVariant:
    2541             return fontVariantFromStyle(style.get());
     2724            return fontVariantFromStyle(*style);
    25422725        case CSSPropertyFontWeight:
    2543             return fontWeightFromStyle(style.get());
     2726            return fontWeightFromStyle(*style);
    25442727        case CSSPropertyFontSynthesis:
    25452728            return fontSynthesisFromStyle(*style);

  • trunk/Source/WebCore/css/CSSFontSelector.cpp

    r192732 r192819  
    305305        applyValueFontVariantLigatures(fontFace.get(), *variantLigatures);
    306306
    307     if (variantPosition)
     307    if (is<CSSPrimitiveValue>(variantPosition.get()))
    308308        fontFace->setVariantPosition(downcast<CSSPrimitiveValue>(*variantPosition));
    309309
    310     if (variantCaps)
     310    if (is<CSSPrimitiveValue>(variantCaps.get()))
    311311        fontFace->setVariantCaps(downcast<CSSPrimitiveValue>(*variantCaps));
    312312
    … …  
    314314        applyValueFontVariantNumeric(fontFace.get(), *variantNumeric);
    315315
    316     if (variantAlternates)
     316    if (is<CSSPrimitiveValue>(variantAlternates.get()))
    317317        fontFace->setVariantAlternates(downcast<CSSPrimitiveValue>(*variantAlternates));
    318318

  • trunk/Source/WebCore/css/CSSParser.cpp

    r192732 r192819  
    10621062    case CSSPropertyFontVariantAlternates: // We only support the normal and historical-forms values.
    10631063        if (valueID == CSSValueNormal || valueID == CSSValueHistoricalForms)
    1064             return true;
    1065         break;
    1066     case CSSPropertyFontVariant: // normal | small-caps
    1067         if (valueID == CSSValueNormal || valueID == CSSValueSmallCaps)
    10681064            return true;
    10691065        break;
    … …  
    12001196    case CSSPropertyFontVariantCaps:
    12011197    case CSSPropertyFontVariantAlternates:
    1202     case CSSPropertyFontVariant:
    12031198        return true;
    12041199    default:
    … …  
    31213116            validPrimitive = true;
    31223117        else
    3123             return parseFontVariantLigatures(important);
     3118            return parseFontVariantLigatures(important, UnknownIsFailure::Yes);
    31243119        break;
    31253120    case CSSPropertyFontVariantNumeric:
    … …  
    31273122            validPrimitive = true;
    31283123        else
    3129             return parseFontVariantNumeric(important);
     3124            return parseFontVariantNumeric(important, UnknownIsFailure::Yes);
    31303125        break;
    31313126    case CSSPropertyFontVariantEastAsian:
    … …  
    31333128            validPrimitive = true;
    31343129        else
    3135             return parseFontVariantEastAsian(important);
    3136         break;
     3130            return parseFontVariantEastAsian(important, UnknownIsFailure::Yes);
     3131        break;
     3132    case CSSPropertyFontVariant:
     3133        if (id == CSSValueNormal) {
     3134            ShorthandScope scope(this, CSSPropertyFontVariant);
     3135            addProperty(CSSPropertyFontVariantLigatures, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, true);
     3136            addProperty(CSSPropertyFontVariantPosition, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, true);
     3137            addProperty(CSSPropertyFontVariantCaps, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, true);
     3138            addProperty(CSSPropertyFontVariantNumeric, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, true);
     3139            addProperty(CSSPropertyFontVariantAlternates, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, true);
     3140            addProperty(CSSPropertyFontVariantEastAsian, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, true);
     3141            return true;
     3142        }
     3143        if (id == CSSValueNone) {
     3144            ShorthandScope scope(this, CSSPropertyFontVariant);
     3145            addProperty(CSSPropertyFontVariantLigatures, CSSValuePool::singleton().createIdentifierValue(CSSValueNone), important, true);
     3146            return true;
     3147        }
     3148        return parseFontVariant(important);
    31373149
    31383150    case CSSPropertyWebkitClipPath:
    … …  
    68076819        } else if (!fontVariantParsed && (value->id == CSSValueNormal || value->id == CSSValueSmallCaps)) {
    68086820            // Font variant in the shorthand is particular, it only accepts normal or small-caps.
    6809             addProperty(CSSPropertyFontVariant, CSSValuePool::singleton().createIdentifierValue(value->id), important);
     6821            addProperty(CSSPropertyFontVariantCaps, CSSValuePool::singleton().createIdentifierValue(value->id), important);
    68106822            fontVariantParsed = true;
    68116823        } else if (!fontWeightParsed && parseFontWeight(important))
    … …  
    68226834        addProperty(CSSPropertyFontStyle, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, true);
    68236835    if (!fontVariantParsed)
    6824         addProperty(CSSPropertyFontVariant, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, true);
     6836        addProperty(CSSPropertyFontVariantCaps, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, true);
    68256837    if (!fontWeightParsed)
    68266838        addProperty(CSSPropertyFontWeight, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, true);
    … …  
    68816893    fontFamilyList->append(CSSValuePool::singleton().createFontFamilyValue(fontDescription.familyAt(0), FromSystemFontID::Yes));
    68826894    addProperty(CSSPropertyFontFamily, WTF::move(fontFamilyList), important);
    6883     addProperty(CSSPropertyFontVariant, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important);
     6895    addProperty(CSSPropertyFontVariantCaps, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important);
    68846896    addProperty(CSSPropertyLineHeight, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important);
    68856897}
    … …  
    1060810620}
    1060910621
    10610 bool CSSParser::parseFontVariantLigatures(bool important)
     10622bool CSSParser::parseFontVariantLigatures(bool important, UnknownIsFailure unknownIsFailure)
    1061110623{
    1061210624    auto values = CSSValueList::createSpaceSeparated();
    10613     bool sawCommonValue = false;
    10614     bool sawDiscretionaryValue = false;
    10615     bool sawHistoricalValue = false;
    10616     bool sawContextualValue = false;
     10625    FontVariantLigatures commonLigatures = FontVariantLigatures::Normal;
     10626    FontVariantLigatures discretionaryLigatures = FontVariantLigatures::Normal;
     10627    FontVariantLigatures historicalLigatures = FontVariantLigatures::Normal;
     10628    FontVariantLigatures contextualAlternates = FontVariantLigatures::Normal;
    1061710629
    1061810630    for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
    … …  
    1062210634        switch (value->id) {
    1062310635        case CSSValueNoCommonLigatures:
     10636            commonLigatures = FontVariantLigatures::No;
     10637            break;
    1062410638        case CSSValueCommonLigatures:
    10625             if (sawCommonValue)
    10626                 return false;
    10627             sawCommonValue = true;
    10628             values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
     10639            commonLigatures = FontVariantLigatures::Yes;
    1062910640            break;
    1063010641        case CSSValueNoDiscretionaryLigatures:
     10642            discretionaryLigatures = FontVariantLigatures::No;
     10643            break;
    1063110644        case CSSValueDiscretionaryLigatures:
    10632             if (sawDiscretionaryValue)
    10633                 return false;
    10634             sawDiscretionaryValue = true;
    10635             values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
     10645            discretionaryLigatures = FontVariantLigatures::Yes;
    1063610646            break;
    1063710647        case CSSValueNoHistoricalLigatures:
     10648            historicalLigatures = FontVariantLigatures::No;
     10649            break;
    1063810650        case CSSValueHistoricalLigatures:
    10639             if (sawHistoricalValue)
    10640                 return false;
    10641             sawHistoricalValue = true;
    10642             values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
     10651            historicalLigatures = FontVariantLigatures::Yes;
    1064310652            break;
    1064410653        case CSSValueContextual:
     10654            contextualAlternates = FontVariantLigatures::Yes;
     10655            break;
    1064510656        case CSSValueNoContextual:
    10646             if (sawContextualValue)
    10647                 return false;
    10648             sawContextualValue = true;
    10649             values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
     10657            contextualAlternates = FontVariantLigatures::No;
    1065010658            break;
    1065110659        default:
    10652             return false;
    10653         }
     10660            if (unknownIsFailure == UnknownIsFailure::Yes)
     10661                return false;
     10662            continue;
     10663        }
     10664    }
     10665
     10666    switch (commonLigatures) {
     10667    case FontVariantLigatures::Normal:
     10668        break;
     10669    case FontVariantLigatures::Yes:
     10670        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueCommonLigatures));
     10671        break;
     10672    case FontVariantLigatures::No:
     10673        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueNoCommonLigatures));
     10674        break;
     10675    }
     10676
     10677    switch (discretionaryLigatures) {
     10678    case FontVariantLigatures::Normal:
     10679        break;
     10680    case FontVariantLigatures::Yes:
     10681        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueDiscretionaryLigatures));
     10682        break;
     10683    case FontVariantLigatures::No:
     10684        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueNoDiscretionaryLigatures));
     10685        break;
     10686    }
     10687
     10688    switch (historicalLigatures) {
     10689    case FontVariantLigatures::Normal:
     10690        break;
     10691    case FontVariantLigatures::Yes:
     10692        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueHistoricalLigatures));
     10693        break;
     10694    case FontVariantLigatures::No:
     10695        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueNoHistoricalLigatures));
     10696        break;
     10697    }
     10698
     10699    switch (contextualAlternates) {
     10700    case FontVariantLigatures::Normal:
     10701        break;
     10702    case FontVariantLigatures::Yes:
     10703        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueContextual));
     10704        break;
     10705    case FontVariantLigatures::No:
     10706        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueNoContextual));
     10707        break;
    1065410708    }
    1065510709
    1065610710    if (!values->length())
    10657         return false;
    10658 
    10659     addProperty(CSSPropertyFontVariantLigatures, WTF::move(values), important);
     10711        return unknownIsFailure == UnknownIsFailure::No;
     10712
     10713    addProperty(CSSPropertyFontVariantLigatures, WTF::move(values), important, false);
    1066010714    return true;
    1066110715}
    1066210716
    10663 bool CSSParser::parseFontVariantNumeric(bool important)
     10717bool CSSParser::parseFontVariantNumeric(bool important, UnknownIsFailure unknownIsFailure)
    1066410718{
    1066510719    auto values = CSSValueList::createSpaceSeparated();
    10666     bool sawFigureValue = false;
    10667     bool sawSpacingValue = false;
    10668     bool sawFractionValue = false;
    10669     bool sawOrdinal = false;
    10670     bool sawSlashedZero = false;
     10720    FontVariantNumericFigure figure = FontVariantNumericFigure::Normal;
     10721    FontVariantNumericSpacing spacing = FontVariantNumericSpacing::Normal;
     10722    FontVariantNumericFraction fraction = FontVariantNumericFraction::Normal;
     10723    FontVariantNumericOrdinal ordinal = FontVariantNumericOrdinal::Normal;
     10724    FontVariantNumericSlashedZero slashedZero = FontVariantNumericSlashedZero::Normal;
    1067110725
    1067210726    for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
    … …  
    1067610730        switch (value->id) {
    1067710731        case CSSValueLiningNums:
     10732            figure = FontVariantNumericFigure::LiningNumbers;
     10733            break;
    1067810734        case CSSValueOldstyleNums:
    10679             if (sawFigureValue)
    10680                 return false;
    10681             sawFigureValue = true;
    10682             values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
     10735            figure = FontVariantNumericFigure::OldStyleNumbers;
    1068310736            break;
    1068410737        case CSSValueProportionalNums:
     10738            spacing = FontVariantNumericSpacing::ProportionalNumbers;
     10739            break;
    1068510740        case CSSValueTabularNums:
    10686             if (sawSpacingValue)
    10687                 return false;
    10688             sawSpacingValue = true;
    10689             values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
     10741            spacing = FontVariantNumericSpacing::TabularNumbers;
    1069010742            break;
    1069110743        case CSSValueDiagonalFractions:
     10744            fraction = FontVariantNumericFraction::DiagonalFractions;
     10745            break;
    1069210746        case CSSValueStackedFractions:
    10693             if (sawFractionValue)
    10694                 return false;
    10695             sawFractionValue = true;
    10696             values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
     10747            fraction = FontVariantNumericFraction::StackedFractions;
    1069710748            break;
    1069810749        case CSSValueOrdinal:
    10699             if (sawOrdinal)
    10700                 return false;
    10701             sawOrdinal = true;
    10702             values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
     10750            ordinal = FontVariantNumericOrdinal::Yes;
    1070310751            break;
    1070410752        case CSSValueSlashedZero:
    10705             if (sawSlashedZero)
    10706                 return false;
    10707             sawSlashedZero = true;
    10708             values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
     10753            slashedZero = FontVariantNumericSlashedZero::Yes;
    1070910754            break;
    1071010755        default:
    10711             return false;
    10712         }
     10756            if (unknownIsFailure == UnknownIsFailure::Yes)
     10757                return false;
     10758            continue;
     10759        }
     10760    }
     10761
     10762    switch (figure) {
     10763    case FontVariantNumericFigure::Normal:
     10764        break;
     10765    case FontVariantNumericFigure::LiningNumbers:
     10766        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueLiningNums));
     10767        break;
     10768    case FontVariantNumericFigure::OldStyleNumbers:
     10769        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueOldstyleNums));
     10770        break;
     10771    }
     10772
     10773    switch (spacing) {
     10774    case FontVariantNumericSpacing::Normal:
     10775        break;
     10776    case FontVariantNumericSpacing::ProportionalNumbers:
     10777        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueProportionalNums));
     10778        break;
     10779    case FontVariantNumericSpacing::TabularNumbers:
     10780        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueTabularNums));
     10781        break;
     10782    }
     10783
     10784    switch (fraction) {
     10785    case FontVariantNumericFraction::Normal:
     10786        break;
     10787    case FontVariantNumericFraction::DiagonalFractions:
     10788        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueDiagonalFractions));
     10789        break;
     10790    case FontVariantNumericFraction::StackedFractions:
     10791        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueStackedFractions));
     10792        break;
     10793    }
     10794
     10795    switch (ordinal) {
     10796    case FontVariantNumericOrdinal::Normal:
     10797        break;
     10798    case FontVariantNumericOrdinal::Yes:
     10799        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueOrdinal));
     10800        break;
     10801    }
     10802
     10803    switch (slashedZero) {
     10804    case FontVariantNumericSlashedZero::Normal:
     10805        break;
     10806    case FontVariantNumericSlashedZero::Yes:
     10807        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueSlashedZero));
     10808        break;
    1071310809    }
    1071410810
    1071510811    if (!values->length())
    10716         return false;
    10717 
    10718     addProperty(CSSPropertyFontVariantNumeric, WTF::move(values), important);
     10812        return unknownIsFailure == UnknownIsFailure::No;
     10813
     10814    addProperty(CSSPropertyFontVariantNumeric, WTF::move(values), important, false);
    1071910815    return true;
    1072010816}
    1072110817
    10722 bool CSSParser::parseFontVariantEastAsian(bool important)
     10818bool CSSParser::parseFontVariantEastAsian(bool important, UnknownIsFailure unknownIsFailure)
    1072310819{
    1072410820    auto values = CSSValueList::createSpaceSeparated();
    10725     bool sawVariantValue = false;
    10726     bool sawWidthValue = false;
    10727     bool sawRuby = false;
     10821    FontVariantEastAsianVariant variant = FontVariantEastAsianVariant::Normal;
     10822    FontVariantEastAsianWidth width = FontVariantEastAsianWidth::Normal;
     10823    FontVariantEastAsianRuby ruby = FontVariantEastAsianRuby::Normal;
    1072810824
    1072910825    for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
    … …  
    1073210828
    1073310829        switch (value->id) {
     10830        case CSSValueJis78:
     10831            variant = FontVariantEastAsianVariant::Jis78;
     10832            break;
     10833        case CSSValueJis83:
     10834            variant = FontVariantEastAsianVariant::Jis83;
     10835            break;
     10836        case CSSValueJis90:
     10837            variant = FontVariantEastAsianVariant::Jis90;
     10838            break;
     10839        case CSSValueJis04:
     10840            variant = FontVariantEastAsianVariant::Jis04;
     10841            break;
     10842        case CSSValueSimplified:
     10843            variant = FontVariantEastAsianVariant::Simplified;
     10844            break;
     10845        case CSSValueTraditional:
     10846            variant = FontVariantEastAsianVariant::Traditional;
     10847            break;
     10848        case CSSValueFullWidth:
     10849            width = FontVariantEastAsianWidth::Full;
     10850            break;
     10851        case CSSValueProportionalWidth:
     10852            width = FontVariantEastAsianWidth::Proportional;
     10853            break;
     10854        case CSSValueRuby:
     10855            ruby = FontVariantEastAsianRuby::Yes;
     10856            break;
     10857        default:
     10858            if (unknownIsFailure == UnknownIsFailure::Yes)
     10859                return false;
     10860            continue;
     10861        }
     10862    }
     10863
     10864    switch (variant) {
     10865    case FontVariantEastAsianVariant::Normal:
     10866        break;
     10867    case FontVariantEastAsianVariant::Jis78:
     10868        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueJis78));
     10869        break;
     10870    case FontVariantEastAsianVariant::Jis83:
     10871        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueJis83));
     10872        break;
     10873    case FontVariantEastAsianVariant::Jis90:
     10874        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueJis90));
     10875        break;
     10876    case FontVariantEastAsianVariant::Jis04:
     10877        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueJis04));
     10878        break;
     10879    case FontVariantEastAsianVariant::Simplified:
     10880        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueSimplified));
     10881        break;
     10882    case FontVariantEastAsianVariant::Traditional:
     10883        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueTraditional));
     10884        break;
     10885    }
     10886
     10887    switch (width) {
     10888    case FontVariantEastAsianWidth::Normal:
     10889        break;
     10890    case FontVariantEastAsianWidth::Full:
     10891        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueFullWidth));
     10892        break;
     10893    case FontVariantEastAsianWidth::Proportional:
     10894        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueProportionalWidth));
     10895        break;
     10896    }
     10897
     10898    switch (ruby) {
     10899    case FontVariantEastAsianRuby::Normal:
     10900        break;
     10901    case FontVariantEastAsianRuby::Yes:
     10902        values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueRuby));
     10903    }
     10904
     10905    if (!values->length())
     10906        return unknownIsFailure == UnknownIsFailure::No;
     10907
     10908    addProperty(CSSPropertyFontVariantEastAsian, WTF::move(values), important, false);
     10909    return true;
     10910}
     10911
     10912bool CSSParser::parseFontVariant(bool important)
     10913{
     10914    ShorthandScope scope(this, CSSPropertyFontVariant);
     10915    if (!parseFontVariantLigatures(important, UnknownIsFailure::No))
     10916        return false;
     10917    m_valueList->setCurrentIndex(0);
     10918    if (!parseFontVariantNumeric(important, UnknownIsFailure::No))
     10919        return false;
     10920    m_valueList->setCurrentIndex(0);
     10921    if (!parseFontVariantEastAsian(important, UnknownIsFailure::No))
     10922        return false;
     10923    m_valueList->setCurrentIndex(0);
     10924
     10925    FontVariantPosition position = FontVariantPosition::Normal;
     10926    FontVariantCaps caps = FontVariantCaps::Normal;
     10927    FontVariantAlternates alternates = FontVariantAlternates::Normal;
     10928
     10929    for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
     10930        if (value->unit != CSSPrimitiveValue::CSS_IDENT)
     10931            return false;
     10932
     10933        switch (value->id) {
     10934        case CSSValueNoCommonLigatures:
     10935        case CSSValueCommonLigatures:
     10936        case CSSValueNoDiscretionaryLigatures:
     10937        case CSSValueDiscretionaryLigatures:
     10938        case CSSValueNoHistoricalLigatures:
     10939        case CSSValueHistoricalLigatures:
     10940        case CSSValueContextual:
     10941        case CSSValueNoContextual:
     10942        case CSSValueLiningNums:
     10943        case CSSValueOldstyleNums:
     10944        case CSSValueProportionalNums:
     10945        case CSSValueTabularNums:
     10946        case CSSValueDiagonalFractions:
     10947        case CSSValueStackedFractions:
     10948        case CSSValueOrdinal:
     10949        case CSSValueSlashedZero:
    1073410950        case CSSValueJis78:
    1073510951        case CSSValueJis83:
    … …  
    1073810954        case CSSValueSimplified:
    1073910955        case CSSValueTraditional:
    10740             if (sawVariantValue)
    10741                 return false;
    10742             sawVariantValue = true;
    10743             values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
    10744             break;
    1074510956        case CSSValueFullWidth:
    1074610957        case CSSValueProportionalWidth:
    10747             if (sawWidthValue)
    10748                 return false;
    10749             sawWidthValue = true;
    10750             values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
     10958        case CSSValueRuby:
    1075110959            break;
    10752         case CSSValueRuby:
    10753             sawRuby = true;
     10960        case CSSValueSub:
     10961            position = FontVariantPosition::Subscript;
     10962            break;
     10963        case CSSValueSuper:
     10964            position = FontVariantPosition::Superscript;
     10965            break;
     10966        case CSSValueSmallCaps:
     10967            caps = FontVariantCaps::Small;
     10968            break;
     10969        case CSSValueAllSmallCaps:
     10970            caps = FontVariantCaps::AllSmall;
     10971            break;
     10972        case CSSValuePetiteCaps:
     10973            caps = FontVariantCaps::Petite;
     10974            break;
     10975        case CSSValueAllPetiteCaps:
     10976            caps = FontVariantCaps::AllPetite;
     10977            break;
     10978        case CSSValueUnicase:
     10979            caps = FontVariantCaps::Unicase;
     10980            break;
     10981        case CSSValueTitlingCaps:
     10982            caps = FontVariantCaps::Titling;
     10983            break;
     10984        case CSSValueHistoricalForms:
     10985            alternates = FontVariantAlternates::HistoricalForms;
    1075410986            break;
    1075510987        default:
    … …  
    1075810990    }
    1075910991
    10760     if (sawRuby)
    10761         values->append(CSSValuePool::singleton().createIdentifierValue(CSSValueRuby));
    10762 
    10763     if (!values->length())
    10764         return false;
    10765 
    10766     addProperty(CSSPropertyFontVariantEastAsian, WTF::move(values), important);
     10992    switch (position) {
     10993    case FontVariantPosition::Normal:
     10994        break;
     10995    case FontVariantPosition::Subscript:
     10996        addProperty(CSSPropertyFontVariantPosition, CSSValuePool::singleton().createIdentifierValue(CSSValueSub), important, false);
     10997        break;
     10998    case FontVariantPosition::Superscript:
     10999        addProperty(CSSPropertyFontVariantPosition, CSSValuePool::singleton().createIdentifierValue(CSSValueSuper), important, false);
     11000        break;
     11001    }
     11002
     11003    switch (caps) {
     11004    case FontVariantCaps::Normal:
     11005        break;
     11006    case FontVariantCaps::Small:
     11007        addProperty(CSSPropertyFontVariantCaps, CSSValuePool::singleton().createIdentifierValue(CSSValueSmallCaps), important, false);
     11008        break;
     11009    case FontVariantCaps::AllSmall:
     11010        addProperty(CSSPropertyFontVariantCaps, CSSValuePool::singleton().createIdentifierValue(CSSValueAllSmallCaps), important, false);
     11011        break;
     11012    case FontVariantCaps::Petite:
     11013        addProperty(CSSPropertyFontVariantCaps, CSSValuePool::singleton().createIdentifierValue(CSSValuePetiteCaps), important, false);
     11014        break;
     11015    case FontVariantCaps::AllPetite:
     11016        addProperty(CSSPropertyFontVariantCaps, CSSValuePool::singleton().createIdentifierValue(CSSValueAllPetiteCaps), important, false);
     11017        break;
     11018    case FontVariantCaps::Unicase:
     11019        addProperty(CSSPropertyFontVariantCaps, CSSValuePool::singleton().createIdentifierValue(CSSValueUnicase), important, false);
     11020        break;
     11021    case FontVariantCaps::Titling:
     11022        addProperty(CSSPropertyFontVariantCaps, CSSValuePool::singleton().createIdentifierValue(CSSValueTitlingCaps), important, false);
     11023        break;
     11024    }
     11025
     11026    switch (alternates) {
     11027    case FontVariantAlternates::Normal:
     11028        break;
     11029    case FontVariantAlternates::HistoricalForms:
     11030        addProperty(CSSPropertyFontVariantAlternates, CSSValuePool::singleton().createIdentifierValue(CSSValueHistoricalForms), important, false);
     11031        break;
     11032    }
     11033
    1076711034    return true;
    1076811035}

  • trunk/Source/WebCore/css/CSSParser.h

    r192732 r192819  
    349349    bool parseRegionThread(CSSPropertyID, bool important);
    350350
    351     bool parseFontVariantLigatures(bool important);
    352     bool parseFontVariantNumeric(bool important);
    353     bool parseFontVariantEastAsian(bool important);
     351    enum class UnknownIsFailure { Yes, No };
     352    bool parseFontVariantLigatures(bool important, UnknownIsFailure);
     353    bool parseFontVariantNumeric(bool important, UnknownIsFailure);
     354    bool parseFontVariantEastAsian(bool important, UnknownIsFailure);
     355    bool parseFontVariant(bool important);
    354356
    355357    bool parseWillChange(bool important);

  • trunk/Source/WebCore/css/CSSPropertyNames.in

    r192290 r192819  
    103103font-size [Inherited, Custom=All]
    104104font-style [Inherited, FontProperty, NameForMethods=Italic]
    105 font-variant [Inherited, FontProperty, NameForMethods=SmallCaps]
    106105font-weight [Inherited, Custom=All]
    107106text-rendering [Inherited, FontProperty, NameForMethods=TextRenderingMode]
    … …  
    230229flood-color [SVG, Converter=SVGColor]
    231230flood-opacity [SVG, Converter=Opacity]
    232 font [Inherited, Longhands=font-family|font-size|font-style|font-variant|font-weight|line-height]
     231font [Inherited, Longhands=font-family|font-size|font-style|font-variant-caps|font-weight|line-height]
     232font-variant [Inherited, Longhands=font-variant-ligatures|font-variant-position|font-variant-caps|font-variant-numeric|font-variant-alternates|font-variant-east-asian]
    233233font-stretch [SkipBuilder]
    234234glyph-orientation-horizontal [Inherited, SVG, Converter=GlyphOrientation]

  • trunk/Source/WebCore/css/FontVariantBuilder.h

    r191968 r192819  
    6969            }
    7070        }
    71     } else {
     71    } else if (is<CSSPrimitiveValue>(value)) {
    7272        switch (downcast<CSSPrimitiveValue>(value).getValueID()) {
    7373        case CSSValueNormal:
    … …  
    132132            }
    133133        }
    134     } else
     134    } else if (is<CSSPrimitiveValue>(value))
    135135        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNormal);
    136136
    … …  
    171171                break;
    172172            case CSSValueFullWidth:
    173                 width = FontVariantEastAsianWidth::FullWidth;
     173                width = FontVariantEastAsianWidth::Full;
    174174                break;
    175175            case CSSValueProportionalWidth:
    176                 width = FontVariantEastAsianWidth::ProportionalWidth;
     176                width = FontVariantEastAsianWidth::Proportional;
    177177                break;
    178178            case CSSValueRuby:
    … …  
    184184            }
    185185        }
    186     } else
     186    } else if (is<CSSPrimitiveValue>(value))
    187187        ASSERT(downcast<CSSPrimitiveValue>(value).getValueID() == CSSValueNormal);
    188188

  • trunk/Source/WebCore/css/StyleProperties.cpp

    r191938 r192819  
    270270        break; // No prefix.
    271271    case CSSPropertyFontFamily:
    272     case CSSPropertyFontVariant:
     272    case CSSPropertyFontVariantCaps:
    273273    case CSSPropertyFontWeight:
    274274        prefix = ' ';
    … …  
    304304    StringBuilder result;
    305305    appendFontLonghandValueIfExplicit(CSSPropertyFontStyle, result, commonValue);
    306     appendFontLonghandValueIfExplicit(CSSPropertyFontVariant, result, commonValue);
     306    appendFontLonghandValueIfExplicit(CSSPropertyFontVariantCaps, result, commonValue);
    307307    appendFontLonghandValueIfExplicit(CSSPropertyFontWeight, result, commonValue);
    308308    if (!result.isEmpty())
    … …  
    974974            case CSSPropertyFontSize:
    975975            case CSSPropertyFontStyle:
    976             case CSSPropertyFontVariant:
     976            case CSSPropertyFontVariantCaps:
    977977            case CSSPropertyFontWeight:
    978978                // Don't use CSSPropertyFont because old UAs can't recognize them but are important for editing.

  • trunk/Source/WebCore/css/StyleResolver.cpp

    r191935 r192819  
    18061806    case CSSPropertyFontSize:
    18071807    case CSSPropertyFontStyle:
    1808     case CSSPropertyFontVariant:
     1808    case CSSPropertyFontVariantCaps:
    18091809    case CSSPropertyFontWeight:
    18101810    case CSSPropertyLineHeight:

  • trunk/Source/WebCore/editing/EditingStyle.cpp

    r191671 r192819  
    6161    CSSPropertyFontSize,
    6262    CSSPropertyFontStyle,
    63     CSSPropertyFontVariant,
     63    CSSPropertyFontVariantCaps,
    6464    CSSPropertyFontWeight,
    6565    CSSPropertyLetterSpacing,

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

    r192140 r192819  
    758758        break;
    759759    case CSSPropertyFontFamily:
    760     case CSSPropertyFontVariant:
     760    case CSSPropertyFontVariantCaps:
    761761    case CSSPropertyTextTransform:
    762762    case CSSPropertyTextShadow:
    … …  
    11191119        }
    11201120#if !PLATFORM(IOS) // IJB: No small caps support on iOS
    1121         if (_caches->propertyValueForNode(element, CSSPropertyFontVariant) == "small-caps") {
     1121        if (_caches->propertyValueForNode(element, CSSPropertyFontVariantCaps) == "small-caps") {
    11221122            // ??? synthesize small-caps if [font isEqual:originalFont]
    11231123            NSFont *originalFont = font;

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

    r192285 r192819  
    262262    defaultStyle->removeProperty(CSSPropertyFontWeight);
    263263    defaultStyle->removeProperty(CSSPropertyFontStyle);
    264     defaultStyle->removeProperty(CSSPropertyFontVariant);
     264    defaultStyle->removeProperty(CSSPropertyFontVariantCaps);
    265265    // FIXME: we should handle also pasted quoted text, strikethrough, etc. <rdar://problem/9255115>
    266266    defaultStyle->removeProperty(CSSPropertyTextDecoration);

  • trunk/Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp

    r192140 r192819  
    21192119    if (fontDescription.italic())
    21202120        serializedFont.appendLiteral("italic ");
    2121     if (fontDescription.smallCaps() == FontSmallCapsOn)
     2121    if (fontDescription.variantCaps() == FontVariantCaps::Small)
    21222122        serializedFont.appendLiteral("small-caps ");
    21232123
    … …  
    21882188    styleResolver.applyPropertyToStyle(CSSPropertyFontFamily, parsedStyle->getPropertyCSSValue(CSSPropertyFontFamily).get(), &newStyle.get());
    21892189    styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontStyle, parsedStyle->getPropertyCSSValue(CSSPropertyFontStyle).get());
    2190     styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontVariant, parsedStyle->getPropertyCSSValue(CSSPropertyFontVariant).get());
     2190    styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontVariantCaps, parsedStyle->getPropertyCSSValue(CSSPropertyFontVariantCaps).get());
    21912191    styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontWeight, parsedStyle->getPropertyCSSValue(CSSPropertyFontWeight).get());
    21922192

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

    r192290 r192819  
    111111    {
    112112        static_assert(USCRIPT_CODE_LIMIT < 0x1000, "Script code must fit in an unsigned along with the other flags");
    113         unsigned first = static_cast<unsigned>(description.script()) << 11
    114             | static_cast<unsigned>(description.textRenderingMode()) << 9
    115             | static_cast<unsigned>(description.smallCaps()) << 8
     113        unsigned first = static_cast<unsigned>(description.script()) << 10
     114            | static_cast<unsigned>(description.textRenderingMode()) << 8
    116115            | static_cast<unsigned>(description.fontSynthesis()) << 6
    117116            | static_cast<unsigned>(description.widthVariant()) << 4

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

    r192770 r192819  
    394394{
    395395    if (variant == AutoVariant) {
    396         if (m_fontDescription.smallCaps() && !primaryFont().isSVGFont()) {
     396        if (m_fontDescription.variantCaps() == FontVariantCaps::Small && !primaryFont().isSVGFont()) {
    397397            UChar32 upperC = u_toupper(c);
    398398            if (upperC != c) {

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

    r191386 r192819  
    149149    void adjustSelectionRectForText(const TextRun&, LayoutRect& selectionRect, int from = 0, int to = -1) const;
    150150
    151     bool isSmallCaps() const { return m_fontDescription.smallCaps(); }
     151    bool isSmallCaps() const { return m_fontDescription.variantCaps() == FontVariantCaps::Small; }
    152152
    153153    float wordSpacing() const { return m_wordSpacing; }

  • trunk/Source/WebCore/platform/graphics/FontDescription.cpp

    r192732 r192819  
    5353    , m_widthVariant(RegularWidth)
    5454    , m_italic(FontItalicOff)
    55     , m_smallCaps(FontSmallCapsOff)
    5655    , m_weight(FontWeightNormal)
    5756    , m_renderingMode(static_cast<unsigned>(FontRenderingMode::Normal))

  • trunk/Source/WebCore/platform/graphics/FontDescription.h

    r192290 r192819  
    4949    FontItalic italic() const { return static_cast<FontItalic>(m_italic); }
    5050    int computedPixelSize() const { return int(m_computedSize + 0.5f); }
    51     FontSmallCaps smallCaps() const { return static_cast<FontSmallCaps>(m_smallCaps); }
    5251    FontWeight weight() const { return static_cast<FontWeight>(m_weight); }
    5352    FontWeight lighterWeight() const;
    … …  
    10099    void setItalic(FontItalic i) { m_italic = i; }
    101100    void setIsItalic(bool i) { setItalic(i ? FontItalicOn : FontItalicOff); }
    102     void setSmallCaps(FontSmallCaps c) { m_smallCaps = c; }
    103     void setIsSmallCaps(bool c) { setSmallCaps(c ? FontSmallCapsOn : FontSmallCapsOff); }
    104101    void setWeight(FontWeight w) { m_weight = w; }
    105102    void setRenderingMode(FontRenderingMode mode) { m_renderingMode = static_cast<unsigned>(mode); }
    … …  
    138135    unsigned m_widthVariant : 2; // FontWidthVariant
    139136    unsigned m_italic : 1; // FontItalic
    140     unsigned m_smallCaps : 1; // FontSmallCaps
    141137    unsigned m_weight : 8; // FontWeight
    142138    unsigned m_renderingMode : 1; // Used to switch between CG and GDI text on Windows.
    … …  
    165161    return m_computedSize == other.m_computedSize
    166162        && m_italic == other.m_italic
    167         && m_smallCaps == other.m_smallCaps
    168163        && m_weight == other.m_weight
    169164        && m_renderingMode == other.m_renderingMode
    … …  
    252247        return familiesEqualForTextAutoSizing(other)
    253248            && m_specifiedSize == other.m_specifiedSize
    254             && smallCaps() == other.smallCaps()
     249            && variantSettings() == other.variantSettings()
    255250            && m_isAbsoluteSize == other.m_isAbsoluteSize;
    256251    }

  • trunk/Source/WebCore/platform/graphics/cocoa/FontCacheCoreText.cpp

    r192732 r192819  
    343343    case FontVariantEastAsianWidth::Normal:
    344344        break;
    345     case FontVariantEastAsianWidth::FullWidth:
     345    case FontVariantEastAsianWidth::Full:
    346346        result.add(fontFeatureTag("fwid"), 1);
    347347        break;
    348     case FontVariantEastAsianWidth::ProportionalWidth:
     348    case FontVariantEastAsianWidth::Proportional:
    349349        result.add(fontFeatureTag("pwid"), 1);
    350350        break;

  • trunk/Source/WebCore/platform/text/TextFlags.h

    r192732 r192819  
    140140enum class FontVariantEastAsianWidth {
    141141    Normal,
    142     FullWidth,
    143     ProportionalWidth
     142    Full,
     143    Proportional
    144144};
    145145
    … …  
    222222    }
    223223
     224    bool operator==(const FontVariantSettings& other)
     225    {
     226        return commonLigatures == other.commonLigatures
     227            && discretionaryLigatures == other.discretionaryLigatures
     228            && historicalLigatures == other.historicalLigatures
     229            && contextualAlternates == other.contextualAlternates
     230            && position == other.position
     231            && caps == other.caps
     232            && numericFigure == other.numericFigure
     233            && numericSpacing == other.numericSpacing
     234            && numericFraction == other.numericFraction
     235            && numericOrdinal == other.numericOrdinal
     236            && numericSlashedZero == other.numericSlashedZero
     237            && alternates == other.alternates
     238            && eastAsianVariant == other.eastAsianVariant
     239            && eastAsianWidth == other.eastAsianWidth
     240            && eastAsianRuby == other.eastAsianRuby;
     241    }
     242
    224243    FontVariantLigatures commonLigatures;
    225244    FontVariantLigatures discretionaryLigatures;

  • trunk/Source/WebCore/rendering/RenderText.cpp

    r190685 r192819  
    461461    }
    462462
    463     if (f.isFixedPitch() && !f.isSmallCaps() && m_isAllASCII && (!glyphOverflow || !glyphOverflow->computeBounds)) {
     463    if (f.isFixedPitch() && f.fontDescription().variantSettings().isAllNormal() && m_isAllASCII && (!glyphOverflow || !glyphOverflow->computeBounds)) {
    464464        float monospaceCharacterWidth = f.spaceWidth();
    465465        float w = 0;
Note: See TracChangeset for help on using the changeset viewer.