Changeset 192843 in webkit


Ignore:
Timestamp:
Nov 30, 2015 4:09:42 PM (8 years ago)
Author:
commit-queue@webkit.org
Message:

Unreviewed, rolling out r192819.
​https://bugs.webkit.org/show_bug.cgi?id=151681

This change broke existing layout tests on Windows (Requested
by ryanhaddad on #webkit).

Reverted changeset:

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

Location:
trunk
Files:
2 deleted
31 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r192833 r192843  
     12015-11-30  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r192819.
     4        https://bugs.webkit.org/show_bug.cgi?id=151681
     5
     6        This change broke existing layout tests on Windows (Requested
     7        by ryanhaddad on #webkit).
     8
     9        Reverted changeset:
     10
     11        "Unify font-variant-* with font-variant shorthand"
     12        https://bugs.webkit.org/show_bug.cgi?id=149773
     13        http://trac.webkit.org/changeset/192819
     14
    1152015-11-30  Brady Eidson  <beidson@apple.com>
    216

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

    r192819 r192843  
    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 "common-ligatures"
     6PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-ligatures').cssText is "normal"
    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 "oldstyle-nums"
    53 PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-numeric').cssText is "tabular-nums"
    54 PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-numeric').cssText is "stacked-fractions"
     52PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-numeric').cssText is "normal"
     53PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-numeric').cssText is "normal"
     54PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-numeric').cssText is "normal"
    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 "jis83"
    78 PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-east-asian').cssText is "traditional"
     77PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-east-asian').cssText is "normal"
     78PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-east-asian').cssText is "normal"
    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 "proportional-width"
     83PASS window.getComputedStyle(document.getElementById('testElement')).getPropertyCSSValue('font-variant-east-asian').cssText is "normal"
    8484PASS successfullyParsed is true
    8585

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

    r192819 r192843  
    2121runTest("font-variant-ligatures", "notavalidvalue", "normal");
    2222runTest("font-variant-ligatures", "common-ligatures", "common-ligatures");
    23 runTest("font-variant-ligatures", "common-ligatures common-ligatures", "common-ligatures");
     23runTest("font-variant-ligatures", "common-ligatures common-ligatures", "normal");
    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", "oldstyle-nums");
    73 runTest("font-variant-numeric", "proportional-nums tabular-nums", "tabular-nums");
    74 runTest("font-variant-numeric", "diagonal-fractions stacked-fractions", "stacked-fractions");
     72runTest("font-variant-numeric", "lining-nums oldstyle-nums", "normal");
     73runTest("font-variant-numeric", "proportional-nums tabular-nums", "normal");
     74runTest("font-variant-numeric", "diagonal-fractions stacked-fractions", "normal");
    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", "jis83");
    100 runTest("font-variant-east-asian", "jis90 traditional", "traditional");
     99runTest("font-variant-east-asian", "jis78 jis83", "normal");
     100runTest("font-variant-east-asian", "jis90 traditional", "normal");
    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", "proportional-width");
     105runTest("font-variant-east-asian", "full-width proportional-width", "normal");
    106106</script>
    107107<script src="../resources/js-test-post.js"></script>

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

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

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

    r192819 r192843  
    22Font for '12px monospace':
    33font-style: normal (original property was font and property was implicitly set.)
    4 font-variant-caps: normal (original property was font and property was implicitly set.)
     4font-variant: 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-caps: normal (original property was font and property was implicitly set.)
     12font-variant: 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-caps: normal (original property was font and property was implicitly set.)
     20font-variant: 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-caps: normal (original property was font)
     28font-variant: 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-caps: normal (original property was font)
     36font-variant: 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-caps: small-caps (original property was font)
     44font-variant: 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-caps: normal (original property was font and property was implicitly set.)
     53font-variant: 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-caps: small-caps (original property was font)
     59font-variant: 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-caps: small-caps (original property was font)
     68font-variant: 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

    r192819 r192843  
    1414PASS: 'historical-ligatures' parsed as 'historical-ligatures' and computed to 'historical-ligatures'
    1515
    16 PASS: 'no-common-ligatures no-common-ligatures' parsed as 'no-common-ligatures' and computed to 'no-common-ligatures'
     16PASS: 'no-common-ligatures no-common-ligatures' parsed as '' and computed to 'normal'
    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

    r192819 r192843  
    4444
    4545    log("");
    46     test('no-common-ligatures no-common-ligatures', 'no-common-ligatures', 'no-common-ligatures');
     46    test('no-common-ligatures no-common-ligatures', '', 'normal');
    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

    r192819 r192843  
    1717color: white
    1818font-style: normal (original property was font and property was implicitly set.)
    19 font-variant-caps: normal (original property was font and property was implicitly set.)
     19font-variant: 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

    r192819 r192843  
    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.
    1402 webkit.org/b/149774 css3/font-feature-settings-font-face-rendering.html [ Pass Failure ImageOnlyFailure ]
    1403 webkit.org/b/149774 css3/font-feature-settings-rendering.html [ Pass Failure ImageOnlyFailure ]
    1404 webkit.org/b/149774 css3/font-variant-all.html [ Pass Failure ImageOnlyFailure ]
    1405 webkit.org/b/149774 css3/font-variant-font-face-all.html [ Pass Failure ImageOnlyFailure ]
    1406 webkit.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

    r192819 r192843  
    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 20x175
    17               text run at (21,1) width 175: "\x{7B2C}\x{4E00}\x{6BB5}\x{843D} Paragraph 1"
     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"
    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 20x181
    20               text run at (21,1) width 181: "\x{7B2C}\x{4E8C}\x{6BB5}\x{843D} Paragraph 2"
     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"

  • trunk/Source/WebCore/ChangeLog

    r192839 r192843  
     12015-11-30  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r192819.
     4        https://bugs.webkit.org/show_bug.cgi?id=151681
     5
     6        This change broke existing layout tests on Windows (Requested
     7        by ryanhaddad on #webkit).
     8
     9        Reverted changeset:
     10
     11        "Unify font-variant-* with font-variant shorthand"
     12        https://bugs.webkit.org/show_bug.cgi?id=149773
     13        http://trac.webkit.org/changeset/192819
     14
    1152015-11-30  Darin Adler  <darin@apple.com>
    216

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

    r192819 r192843  
    13831383    case FontVariantEastAsianWidth::Normal:
    13841384        break;
    1385     case FontVariantEastAsianWidth::Full:
     1385    case FontVariantEastAsianWidth::FullWidth:
    13861386        valueList->append(cssValuePool.createIdentifierValue(CSSValueFullWidth));
    13871387        break;
    1388     case FontVariantEastAsianWidth::Proportional:
     1388    case FontVariantEastAsianWidth::ProportionalWidth:
    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<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 
    2013 static Ref<CSSPrimitiveValue> fontWeightFromStyle(RenderStyle& style)
    2014 {
    2015     switch (style.fontDescription().weight()) {
     1826static 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
     1833static Ref<CSSPrimitiveValue> fontWeightFromStyle(RenderStyle* style)
     1834{
     1835    switch (style->fontDescription().weight()) {
    20161836    case FontWeight100:
    20171837        return CSSValuePool::singleton().createIdentifierValue(CSSValue100);
    … …  
    26982518        case CSSPropertyFont: {
    26992519            RefPtr<CSSFontValue> computedFont = CSSFontValue::create();
    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);
     2520            computedFont->style = fontStyleFromStyle(style.get());
     2521            computedFont->variant = fontVariantFromStyle(style.get());
     2522            computedFont->weight = fontWeightFromStyle(style.get());
    27062523            computedFont->size = fontSizeFromStyle(*style);
    27072524            computedFont->lineHeight = lineHeightFromStyle(*style);
    … …  
    27202537            return fontSizeFromStyle(*style);
    27212538        case CSSPropertyFontStyle:
    2722             return fontStyleFromStyle(*style);
     2539            return fontStyleFromStyle(style.get());
    27232540        case CSSPropertyFontVariant:
    2724             return fontVariantFromStyle(*style);
     2541            return fontVariantFromStyle(style.get());
    27252542        case CSSPropertyFontWeight:
    2726             return fontWeightFromStyle(*style);
     2543            return fontWeightFromStyle(style.get());
    27272544        case CSSPropertyFontSynthesis:
    27282545            return fontSynthesisFromStyle(*style);

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

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

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

    r192819 r192843  
    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)
    10641068            return true;
    10651069        break;
    … …  
    11961200    case CSSPropertyFontVariantCaps:
    11971201    case CSSPropertyFontVariantAlternates:
     1202    case CSSPropertyFontVariant:
    11981203        return true;
    11991204    default:
    … …  
    31163121            validPrimitive = true;
    31173122        else
    3118             return parseFontVariantLigatures(important, UnknownIsFailure::Yes);
     3123            return parseFontVariantLigatures(important);
    31193124        break;
    31203125    case CSSPropertyFontVariantNumeric:
    … …  
    31223127            validPrimitive = true;
    31233128        else
    3124             return parseFontVariantNumeric(important, UnknownIsFailure::Yes);
     3129            return parseFontVariantNumeric(important);
    31253130        break;
    31263131    case CSSPropertyFontVariantEastAsian:
    … …  
    31283133            validPrimitive = true;
    31293134        else
    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);
     3135            return parseFontVariantEastAsian(important);
     3136        break;
    31493137
    31503138    case CSSPropertyWebkitClipPath:
    … …  
    68196807        } else if (!fontVariantParsed && (value->id == CSSValueNormal || value->id == CSSValueSmallCaps)) {
    68206808            // Font variant in the shorthand is particular, it only accepts normal or small-caps.
    6821             addProperty(CSSPropertyFontVariantCaps, CSSValuePool::singleton().createIdentifierValue(value->id), important);
     6809            addProperty(CSSPropertyFontVariant, CSSValuePool::singleton().createIdentifierValue(value->id), important);
    68226810            fontVariantParsed = true;
    68236811        } else if (!fontWeightParsed && parseFontWeight(important))
    … …  
    68346822        addProperty(CSSPropertyFontStyle, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, true);
    68356823    if (!fontVariantParsed)
    6836         addProperty(CSSPropertyFontVariantCaps, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, true);
     6824        addProperty(CSSPropertyFontVariant, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, true);
    68376825    if (!fontWeightParsed)
    68386826        addProperty(CSSPropertyFontWeight, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important, true);
    … …  
    68936881    fontFamilyList->append(CSSValuePool::singleton().createFontFamilyValue(fontDescription.familyAt(0), FromSystemFontID::Yes));
    68946882    addProperty(CSSPropertyFontFamily, WTF::move(fontFamilyList), important);
    6895     addProperty(CSSPropertyFontVariantCaps, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important);
     6883    addProperty(CSSPropertyFontVariant, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important);
    68966884    addProperty(CSSPropertyLineHeight, CSSValuePool::singleton().createIdentifierValue(CSSValueNormal), important);
    68976885}
    … …  
    1062010608}
    1062110609
    10622 bool CSSParser::parseFontVariantLigatures(bool important, UnknownIsFailure unknownIsFailure)
     10610bool CSSParser::parseFontVariantLigatures(bool important)
    1062310611{
    1062410612    auto values = CSSValueList::createSpaceSeparated();
    10625     FontVariantLigatures commonLigatures = FontVariantLigatures::Normal;
    10626     FontVariantLigatures discretionaryLigatures = FontVariantLigatures::Normal;
    10627     FontVariantLigatures historicalLigatures = FontVariantLigatures::Normal;
    10628     FontVariantLigatures contextualAlternates = FontVariantLigatures::Normal;
     10613    bool sawCommonValue = false;
     10614    bool sawDiscretionaryValue = false;
     10615    bool sawHistoricalValue = false;
     10616    bool sawContextualValue = false;
    1062910617
    1063010618    for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
    … …  
    1063410622        switch (value->id) {
    1063510623        case CSSValueNoCommonLigatures:
    10636             commonLigatures = FontVariantLigatures::No;
    10637             break;
    1063810624        case CSSValueCommonLigatures:
    10639             commonLigatures = FontVariantLigatures::Yes;
     10625            if (sawCommonValue)
     10626                return false;
     10627            sawCommonValue = true;
     10628            values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
    1064010629            break;
    1064110630        case CSSValueNoDiscretionaryLigatures:
    10642             discretionaryLigatures = FontVariantLigatures::No;
    10643             break;
    1064410631        case CSSValueDiscretionaryLigatures:
    10645             discretionaryLigatures = FontVariantLigatures::Yes;
     10632            if (sawDiscretionaryValue)
     10633                return false;
     10634            sawDiscretionaryValue = true;
     10635            values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
    1064610636            break;
    1064710637        case CSSValueNoHistoricalLigatures:
    10648             historicalLigatures = FontVariantLigatures::No;
    10649             break;
    1065010638        case CSSValueHistoricalLigatures:
    10651             historicalLigatures = FontVariantLigatures::Yes;
     10639            if (sawHistoricalValue)
     10640                return false;
     10641            sawHistoricalValue = true;
     10642            values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
    1065210643            break;
    1065310644        case CSSValueContextual:
    10654             contextualAlternates = FontVariantLigatures::Yes;
    10655             break;
    1065610645        case CSSValueNoContextual:
    10657             contextualAlternates = FontVariantLigatures::No;
     10646            if (sawContextualValue)
     10647                return false;
     10648            sawContextualValue = true;
     10649            values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
    1065810650            break;
    1065910651        default:
    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;
     10652            return false;
     10653        }
    1070810654    }
    1070910655
    1071010656    if (!values->length())
    10711         return unknownIsFailure == UnknownIsFailure::No;
    10712 
    10713     addProperty(CSSPropertyFontVariantLigatures, WTF::move(values), important, false);
     10657        return false;
     10658
     10659    addProperty(CSSPropertyFontVariantLigatures, WTF::move(values), important);
    1071410660    return true;
    1071510661}
    1071610662
    10717 bool CSSParser::parseFontVariantNumeric(bool important, UnknownIsFailure unknownIsFailure)
     10663bool CSSParser::parseFontVariantNumeric(bool important)
    1071810664{
    1071910665    auto values = CSSValueList::createSpaceSeparated();
    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;
     10666    bool sawFigureValue = false;
     10667    bool sawSpacingValue = false;
     10668    bool sawFractionValue = false;
     10669    bool sawOrdinal = false;
     10670    bool sawSlashedZero = false;
    1072510671
    1072610672    for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
    … …  
    1073010676        switch (value->id) {
    1073110677        case CSSValueLiningNums:
    10732             figure = FontVariantNumericFigure::LiningNumbers;
    10733             break;
    1073410678        case CSSValueOldstyleNums:
    10735             figure = FontVariantNumericFigure::OldStyleNumbers;
     10679            if (sawFigureValue)
     10680                return false;
     10681            sawFigureValue = true;
     10682            values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
    1073610683            break;
    1073710684        case CSSValueProportionalNums:
    10738             spacing = FontVariantNumericSpacing::ProportionalNumbers;
    10739             break;
    1074010685        case CSSValueTabularNums:
    10741             spacing = FontVariantNumericSpacing::TabularNumbers;
     10686            if (sawSpacingValue)
     10687                return false;
     10688            sawSpacingValue = true;
     10689            values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
    1074210690            break;
    1074310691        case CSSValueDiagonalFractions:
    10744             fraction = FontVariantNumericFraction::DiagonalFractions;
    10745             break;
    1074610692        case CSSValueStackedFractions:
    10747             fraction = FontVariantNumericFraction::StackedFractions;
     10693            if (sawFractionValue)
     10694                return false;
     10695            sawFractionValue = true;
     10696            values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
    1074810697            break;
    1074910698        case CSSValueOrdinal:
    10750             ordinal = FontVariantNumericOrdinal::Yes;
     10699            if (sawOrdinal)
     10700                return false;
     10701            sawOrdinal = true;
     10702            values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
    1075110703            break;
    1075210704        case CSSValueSlashedZero:
    10753             slashedZero = FontVariantNumericSlashedZero::Yes;
     10705            if (sawSlashedZero)
     10706                return false;
     10707            sawSlashedZero = true;
     10708            values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
    1075410709            break;
    1075510710        default:
    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;
     10711            return false;
     10712        }
    1080910713    }
    1081010714
    1081110715    if (!values->length())
    10812         return unknownIsFailure == UnknownIsFailure::No;
    10813 
    10814     addProperty(CSSPropertyFontVariantNumeric, WTF::move(values), important, false);
     10716        return false;
     10717
     10718    addProperty(CSSPropertyFontVariantNumeric, WTF::move(values), important);
    1081510719    return true;
    1081610720}
    1081710721
    10818 bool CSSParser::parseFontVariantEastAsian(bool important, UnknownIsFailure unknownIsFailure)
     10722bool CSSParser::parseFontVariantEastAsian(bool important)
    1081910723{
    1082010724    auto values = CSSValueList::createSpaceSeparated();
    10821     FontVariantEastAsianVariant variant = FontVariantEastAsianVariant::Normal;
    10822     FontVariantEastAsianWidth width = FontVariantEastAsianWidth::Normal;
    10823     FontVariantEastAsianRuby ruby = FontVariantEastAsianRuby::Normal;
     10725    bool sawVariantValue = false;
     10726    bool sawWidthValue = false;
     10727    bool sawRuby = false;
    1082410728
    1082510729    for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
    … …  
    1082810732
    1082910733        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 
    10912 bool 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:
    1095010734        case CSSValueJis78:
    1095110735        case CSSValueJis83:
    … …  
    1095410738        case CSSValueSimplified:
    1095510739        case CSSValueTraditional:
     10740            if (sawVariantValue)
     10741                return false;
     10742            sawVariantValue = true;
     10743            values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
     10744            break;
    1095610745        case CSSValueFullWidth:
    1095710746        case CSSValueProportionalWidth:
     10747            if (sawWidthValue)
     10748                return false;
     10749            sawWidthValue = true;
     10750            values->append(CSSValuePool::singleton().createIdentifierValue(value->id));
     10751            break;
    1095810752        case CSSValueRuby:
    10959             break;
    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;
     10753            sawRuby = true;
    1098610754            break;
    1098710755        default:
    … …  
    1099010758    }
    1099110759
    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 
     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);
    1103410767    return true;
    1103510768}

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

    r192819 r192843  
    349349    bool parseRegionThread(CSSPropertyID, bool important);
    350350
    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);
     351    bool parseFontVariantLigatures(bool important);
     352    bool parseFontVariantNumeric(bool important);
     353    bool parseFontVariantEastAsian(bool important);
    356354
    357355    bool parseWillChange(bool important);

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

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

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

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

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

    r192819 r192843  
    270270        break; // No prefix.
    271271    case CSSPropertyFontFamily:
    272     case CSSPropertyFontVariantCaps:
     272    case CSSPropertyFontVariant:
    273273    case CSSPropertyFontWeight:
    274274        prefix = ' ';
    … …  
    304304    StringBuilder result;
    305305    appendFontLonghandValueIfExplicit(CSSPropertyFontStyle, result, commonValue);
    306     appendFontLonghandValueIfExplicit(CSSPropertyFontVariantCaps, result, commonValue);
     306    appendFontLonghandValueIfExplicit(CSSPropertyFontVariant, result, commonValue);
    307307    appendFontLonghandValueIfExplicit(CSSPropertyFontWeight, result, commonValue);
    308308    if (!result.isEmpty())
    … …  
    974974            case CSSPropertyFontSize:
    975975            case CSSPropertyFontStyle:
    976             case CSSPropertyFontVariantCaps:
     976            case CSSPropertyFontVariant:
    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

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

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

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

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

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

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

    r192819 r192843  
    262262    defaultStyle->removeProperty(CSSPropertyFontWeight);
    263263    defaultStyle->removeProperty(CSSPropertyFontStyle);
    264     defaultStyle->removeProperty(CSSPropertyFontVariantCaps);
     264    defaultStyle->removeProperty(CSSPropertyFontVariant);
    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

    r192819 r192843  
    21192119    if (fontDescription.italic())
    21202120        serializedFont.appendLiteral("italic ");
    2121     if (fontDescription.variantCaps() == FontVariantCaps::Small)
     2121    if (fontDescription.smallCaps() == FontSmallCapsOn)
    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(CSSPropertyFontVariantCaps, parsedStyle->getPropertyCSSValue(CSSPropertyFontVariantCaps).get());
     2190    styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontVariant, parsedStyle->getPropertyCSSValue(CSSPropertyFontVariant).get());
    21912191    styleResolver.applyPropertyToCurrentStyle(CSSPropertyFontWeight, parsedStyle->getPropertyCSSValue(CSSPropertyFontWeight).get());
    21922192

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

    r192819 r192843  
    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()) << 10
    114             | static_cast<unsigned>(description.textRenderingMode()) << 8
     113        unsigned first = static_cast<unsigned>(description.script()) << 11
     114            | static_cast<unsigned>(description.textRenderingMode()) << 9
     115            | static_cast<unsigned>(description.smallCaps()) << 8
    115116            | static_cast<unsigned>(description.fontSynthesis()) << 6
    116117            | static_cast<unsigned>(description.widthVariant()) << 4

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

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

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

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

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

    r192819 r192843  
    5353    , m_widthVariant(RegularWidth)
    5454    , m_italic(FontItalicOff)
     55    , m_smallCaps(FontSmallCapsOff)
    5556    , m_weight(FontWeightNormal)
    5657    , m_renderingMode(static_cast<unsigned>(FontRenderingMode::Normal))

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

    r192819 r192843  
    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); }
    5152    FontWeight weight() const { return static_cast<FontWeight>(m_weight); }
    5253    FontWeight lighterWeight() const;
    … …  
    99100    void setItalic(FontItalic i) { m_italic = i; }
    100101    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); }
    101104    void setWeight(FontWeight w) { m_weight = w; }
    102105    void setRenderingMode(FontRenderingMode mode) { m_renderingMode = static_cast<unsigned>(mode); }
    … …  
    135138    unsigned m_widthVariant : 2; // FontWidthVariant
    136139    unsigned m_italic : 1; // FontItalic
     140    unsigned m_smallCaps : 1; // FontSmallCaps
    137141    unsigned m_weight : 8; // FontWeight
    138142    unsigned m_renderingMode : 1; // Used to switch between CG and GDI text on Windows.
    … …  
    161165    return m_computedSize == other.m_computedSize
    162166        && m_italic == other.m_italic
     167        && m_smallCaps == other.m_smallCaps
    163168        && m_weight == other.m_weight
    164169        && m_renderingMode == other.m_renderingMode
    … …  
    247252        return familiesEqualForTextAutoSizing(other)
    248253            && m_specifiedSize == other.m_specifiedSize
    249             && variantSettings() == other.variantSettings()
     254            && smallCaps() == other.smallCaps()
    250255            && m_isAbsoluteSize == other.m_isAbsoluteSize;
    251256    }

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

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

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

    r192819 r192843  
    140140enum class FontVariantEastAsianWidth {
    141141    Normal,
    142     Full,
    143     Proportional
     142    FullWidth,
     143    ProportionalWidth
    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 
    243224    FontVariantLigatures commonLigatures;
    244225    FontVariantLigatures discretionaryLigatures;

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

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