Changeset 178532 in webkit


Ignore:
Timestamp:
Jan 15, 2015 2:52:30 PM (9 years ago)
Author:
commit-queue@webkit.org
Message:

Canonicalization of :lang() should preserve the :lang()'s arguments representations
https://bugs.webkit.org/show_bug.cgi?id=139928

Patch by Dhi Aurrahman <diorahman@rockybars.com> on 2015-01-15
Reviewed by Benjamin Poulain.

Source/WebCore:

Preserve the representation of IDENT and STRING when serializing the
:lang(). For example, :lang(foo,"bar" ,baz) should be serialized as
:lang(foo, "bar", baz) instead of :lang(foo, bar, baz).

Rename CSSParserSelector::setArgumentList, CSSSelector::setArgumentList
and CSSSelector::argumentList to CSSParserSelector::setLangArgumentList,
CSSSelector::setLangArgumentList and CSSSelector::langArgumentList
respectively, since those methods are being exclusively used in respect
with :lang().

Update the test of serializing :lang() with IDENT and STRING arguments.

  • css/CSSGrammar.y.in:
  • css/CSSParserValues.cpp:

(WebCore::CSSParserSelector::setLangArgumentList):
(WebCore::CSSParserSelector::setArgumentList): Deleted.

  • css/CSSParserValues.h:

(WebCore::CSSParserString::init):
(WebCore::CSSParserString::clear):
(WebCore::CSSParserString::isParsedFromString):
(WebCore::CSSParserString::setParsedFromString):

  • css/CSSSelector.cpp:

(WebCore::appendLangArgumentList):
(WebCore::CSSSelector::selectorText):
(WebCore::CSSSelector::setLangArgumentList):
(WebCore::appendArgumentList): Deleted.
(WebCore::CSSSelector::setArgumentList): Deleted.

  • css/CSSSelector.h:

(WebCore::CSSSelector::langArgumentList):
(WebCore::CSSSelector::langArgumentParsedFromStringFlagList):
(WebCore::CSSSelector::argumentList): Deleted.

  • css/SelectorChecker.cpp:

(WebCore::SelectorChecker::checkOne):

LayoutTests:

  • fast/css/css-lang-selector-with-string-arguments-text-expected.txt: Updated.
  • fast/css/css-lang-selector-with-string-arguments-text.html: Updated.
Location:
trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r178527 r178532  
     12015-01-15  Dhi Aurrahman  <diorahman@rockybars.com>
     2
     3        Canonicalization of :lang() should preserve the :lang()'s arguments representations
     4        https://bugs.webkit.org/show_bug.cgi?id=139928
     5
     6        Reviewed by Benjamin Poulain.
     7
     8        * fast/css/css-lang-selector-with-string-arguments-text-expected.txt: Updated.
     9        * fast/css/css-lang-selector-with-string-arguments-text.html: Updated.
     10
    1112015-01-14  Alexey Proskuryakov  <ap@apple.com>
    212
  • trunk/LayoutTests/fast/css/css-lang-selector-with-string-arguments-text-expected.txt

    r177745 r178532  
    44
    55
    6 PASS parseThenSerializeRule(':lang("a") { }') is ':lang(a) { }'
    7 PASS parseThenSerializeRule(':lang("bb", cc) { }') is ':lang(bb, cc) { }'
    8 PASS parseThenSerializeRule(':lang("ddd", eee) { }') is ':lang(ddd, eee) { }'
    9 PASS parseThenSerializeRule(':lang("*-1997") { }') is ':lang(*-1997) { }'
    10 PASS parseThenSerializeRule(':lang("*-1997", "*-1998") { }') is ':lang(*-1997, *-1998) { }'
    11 PASS parseThenSerializeRule(':lang("") { }') is ':lang() { }'
     6PASS parseThenSerializeRule(':lang("a") { }') is ':lang("a") { }'
     7PASS parseThenSerializeRule(':lang("bb", cc) { }') is ':lang("bb", cc) { }'
     8PASS parseThenSerializeRule(':lang("ddd", eee) { }') is ':lang("ddd", eee) { }'
     9PASS parseThenSerializeRule(':lang("ddd", eee, ffff) { }') is ':lang("ddd", eee, ffff) { }'
     10PASS parseThenSerializeRule(':lang("ddd", eee, "ffff") { }') is ':lang("ddd", eee, "ffff") { }'
     11PASS parseThenSerializeRule(':lang("*-1997") { }') is ':lang("*-1997") { }'
     12PASS parseThenSerializeRule(':lang("*-1997", "*-1998") { }') is ':lang("*-1997", "*-1998") { }'
     13PASS parseThenSerializeRule(':lang("*-1997", "*-1998", "*-1999") { }') is ':lang("*-1997", "*-1998", "*-1999") { }'
     14PASS parseThenSerializeRule(':lang("") { }') is ':lang("") { }'
     15
     16PASS parseThenSerializeRule(':lang(foo, "bar", baz) { }') is ':lang(foo, "bar", baz) { }'
     17PASS parseThenSerializeRule(':lang(foo,      "bar"     , baz) { }') is ':lang(foo, "bar", baz) { }'
     18PASS parseThenSerializeRule(':lang(    foo    ,     "bar"    ,     baz    ) { }') is ':lang(foo, "bar", baz) { }'
    1219PASS successfullyParsed is true
    1320
  • trunk/LayoutTests/fast/css/css-lang-selector-with-string-arguments-text.html

    r177745 r178532  
    2626function testSelectorRoundTrip(selector)
    2727{
    28     var expected = selector.split('"').join('');
    29     shouldBe("parseThenSerializeRule('" + selector + " { }')", "'" + expected + " { }'");
     28    shouldBe("parseThenSerializeRule('" + selector + " { }')", "'" + selector + " { }'");
    3029}
    3130
     
    3332testSelectorRoundTrip(':lang("bb", cc)');
    3433testSelectorRoundTrip(':lang("ddd", eee)');
     34testSelectorRoundTrip(':lang("ddd", eee, ffff)');
     35testSelectorRoundTrip(':lang("ddd", eee, "ffff")');
    3536testSelectorRoundTrip(':lang("*-1997")');
    3637testSelectorRoundTrip(':lang("*-1997", "*-1998")');
     38testSelectorRoundTrip(':lang("*-1997", "*-1998", "*-1999")');
    3739testSelectorRoundTrip(':lang("")');
    3840
     41debug('');
     42
     43shouldBe("parseThenSerializeRule(':lang(foo, \"bar\", baz) { }')", "':lang(foo, \"bar\", baz) { }'");
     44shouldBe("parseThenSerializeRule(':lang(foo,      \"bar\"     , baz) { }')", "':lang(foo, \"bar\", baz) { }'");
     45shouldBe("parseThenSerializeRule(':lang(    foo    ,     \"bar\"    ,     baz    ) { }')", "':lang(foo, \"bar\", baz) { }'");
    3946</script>
    4047<script src="../../resources/js-test-post.js"></script>
  • trunk/Source/WebCore/ChangeLog

    r178531 r178532  
     12015-01-15  Dhi Aurrahman  <diorahman@rockybars.com>
     2
     3        Canonicalization of :lang() should preserve the :lang()'s arguments representations
     4        https://bugs.webkit.org/show_bug.cgi?id=139928
     5
     6        Reviewed by Benjamin Poulain.
     7
     8        Preserve the representation of IDENT and STRING when serializing the
     9        :lang(). For example, :lang(foo,"bar"   ,baz) should be serialized as
     10        :lang(foo, "bar", baz) instead of :lang(foo, bar, baz).
     11
     12        Rename CSSParserSelector::setArgumentList, CSSSelector::setArgumentList
     13        and CSSSelector::argumentList to CSSParserSelector::setLangArgumentList,
     14        CSSSelector::setLangArgumentList and CSSSelector::langArgumentList
     15        respectively, since those methods are being exclusively used in respect
     16        with :lang().
     17
     18        Update the test of serializing :lang() with IDENT and STRING arguments.
     19
     20        * css/CSSGrammar.y.in:
     21        * css/CSSParserValues.cpp:
     22        (WebCore::CSSParserSelector::setLangArgumentList):
     23        (WebCore::CSSParserSelector::setArgumentList): Deleted.
     24        * css/CSSParserValues.h:
     25        (WebCore::CSSParserString::init):
     26        (WebCore::CSSParserString::clear):
     27        (WebCore::CSSParserString::isParsedFromString):
     28        (WebCore::CSSParserString::setParsedFromString):
     29        * css/CSSSelector.cpp:
     30        (WebCore::appendLangArgumentList):
     31        (WebCore::CSSSelector::selectorText):
     32        (WebCore::CSSSelector::setLangArgumentList):
     33        (WebCore::appendArgumentList): Deleted.
     34        (WebCore::CSSSelector::setArgumentList): Deleted.
     35        * css/CSSSelector.h:
     36        (WebCore::CSSSelector::langArgumentList):
     37        (WebCore::CSSSelector::langArgumentParsedFromStringFlagList):
     38        (WebCore::CSSSelector::argumentList): Deleted.
     39        * css/SelectorChecker.cpp:
     40        (WebCore::SelectorChecker::checkOne):
     41
    1422015-01-15  Brent Fulgham  <bfulgham@apple.com>
    243
  • trunk/Source/WebCore/css/CSSGrammar.y.in

    r177745 r178532  
    11051105
    11061106#if ENABLE_CSS_SELECTORS_LEVEL4
    1107 lang_range: LANGRANGE | IDENT | STRING
     1107lang_range: LANGRANGE | IDENT | STRING { $1.setTokenType(TokenType::AtomicStringToken); $$ = $1; } ;
    11081108
    11091109comma_separated_lang_ranges:
     
    13981398            auto selector = std::make_unique<CSSParserSelector>();
    13991399            selector->setMatch(CSSSelector::PseudoClass);
    1400             selector->setArgumentList(*std::unique_ptr<Vector<CSSParserString>>($4));
     1400            selector->setLangArgumentList(*std::unique_ptr<Vector<CSSParserString>>($4));
    14011401            selector->setPseudoClassValue($2);
    14021402            if (selector->pseudoClassType() == CSSSelector::PseudoClassLang)
  • trunk/Source/WebCore/css/CSSParserValues.cpp

    r177232 r178532  
    263263
    264264#if ENABLE(CSS_SELECTORS_LEVEL4)
    265 void CSSParserSelector::setArgumentList(Vector<CSSParserString>& stringVector)
     265void CSSParserSelector::setLangArgumentList(const Vector<CSSParserString>& stringVector)
    266266{
    267267    ASSERT_WITH_MESSAGE(!stringVector.isEmpty(), "No CSS Selector takes an empty argument list.");
    268     auto argumentList = std::make_unique<Vector<AtomicString>>();
     268    auto argumentList = std::make_unique<Vector<LanguageArgument>>();
    269269    argumentList->reserveInitialCapacity(stringVector.size());
    270     for (const AtomicString& argument : stringVector)
    271         argumentList->append(argument);
    272     m_selector->setArgumentList(WTF::move(argumentList));
     270    for (const CSSParserString& string : stringVector) {
     271        LanguageArgument languageArgument;
     272        languageArgument.languageRange = string;
     273        languageArgument.tokenType = string.tokenType();
     274        argumentList->append(languageArgument);
     275    }
     276    m_selector->setLangArgumentList(WTF::move(argumentList));
    273277}
    274278#endif
  • trunk/Source/WebCore/css/CSSParserValues.h

    r177232 r178532  
    7676    void setLength(unsigned length) { m_length = length; }
    7777
     78#if ENABLE(CSS_SELECTORS_LEVEL4)
     79    TokenType tokenType() const { return m_tokenType; }
     80    void setTokenType(TokenType tokenType) { m_tokenType = tokenType; }
     81#endif
     82
    7883    void lower();
    7984
     
    102107    unsigned m_length;
    103108    bool m_is8Bit;
     109#if ENABLE(CSS_SELECTORS_LEVEL4)
     110    TokenType m_tokenType;
     111#endif
    104112};
    105113
     
    203211    void adoptSelectorVector(Vector<std::unique_ptr<CSSParserSelector>>& selectorVector);
    204212#if ENABLE(CSS_SELECTORS_LEVEL4)
    205     void setArgumentList(Vector<CSSParserString>& stringVector);
     213    void setLangArgumentList(const Vector<CSSParserString>& stringVector);
    206214#endif
    207215
  • trunk/Source/WebCore/css/CSSSelector.cpp

    r177313 r178532  
    347347
    348348#if ENABLE(CSS_SELECTORS_LEVEL4)
    349 static void appendArgumentList(StringBuilder& str, const Vector<AtomicString>& argumentList)
     349static void appendLangArgumentList(StringBuilder& str, const Vector<LanguageArgument>& argumentList)
    350350{
    351351    unsigned argumentListSize = argumentList.size();
    352352    for (unsigned i = 0; i < argumentListSize; ++i) {
    353         str.append(argumentList[i]);
     353        const LanguageArgument& argument = argumentList[i];
     354        bool isAtomicStringToken = argument.tokenType == TokenType::AtomicStringToken;
     355        if (isAtomicStringToken)
     356            str.append('"');
     357        str.append(argument.languageRange);
     358        if (isAtomicStringToken)
     359            str.append('"');
    354360        if (i != argumentListSize - 1)
    355361            str.appendLiteral(", ");
     
    492498                str.appendLiteral(":lang(");
    493499#if ENABLE(CSS_SELECTORS_LEVEL4)
    494                 ASSERT_WITH_MESSAGE(cs->argumentList() && !cs->argumentList()->isEmpty(), "An empty :lang() is invalid and should never be generated by the parser.");
    495                 appendArgumentList(str, *cs->argumentList());
     500                ASSERT_WITH_MESSAGE(cs->langArgumentList() && !cs->langArgumentList()->isEmpty(), "An empty :lang() is invalid and should never be generated by the parser.");
     501                appendLangArgumentList(str, *cs->langArgumentList());
    496502                str.append(')');
    497503#else
     
    709715
    710716#if ENABLE(CSS_SELECTORS_LEVEL4)
    711 void CSSSelector::setArgumentList(std::unique_ptr<Vector<AtomicString>> argumentList)
     717void CSSSelector::setLangArgumentList(std::unique_ptr<Vector<LanguageArgument>> argumentList)
    712718{
    713719    createRareData();
    714     m_data.m_rareData->m_argumentList = WTF::move(argumentList);
     720    m_data.m_rareData->m_langArgumentList = WTF::move(argumentList);
    715721}
    716722#endif
  • trunk/Source/WebCore/css/CSSSelector.h

    r176545 r178532  
    3030    class CSSSelectorList;
    3131
     32#if ENABLE(CSS_SELECTORS_LEVEL4)
     33    enum class TokenType {
     34        IdentifierToken = 0,
     35        AtomicStringToken
     36    };
     37   
     38    struct LanguageArgument {
     39        AtomicString languageRange;
     40        TokenType tokenType;
     41    };
     42#endif
    3243    enum class SelectorSpecificityIncrement {
    3344        ClassA = 0x10000,
     
    223234        const AtomicString& argument() const { return m_hasRareData ? m_data.m_rareData->m_argument : nullAtom; }
    224235#if ENABLE(CSS_SELECTORS_LEVEL4)
    225         const Vector<AtomicString>* argumentList() const { return m_hasRareData ? m_data.m_rareData->m_argumentList.get() : nullptr; }
     236        const Vector<LanguageArgument>* langArgumentList() const { return m_hasRareData ? m_data.m_rareData->m_langArgumentList.get() : nullptr; }
    226237#endif
    227238        const CSSSelectorList* selectorList() const { return m_hasRareData ? m_data.m_rareData->m_selectorList.get() : nullptr; }
     
    231242        void setArgument(const AtomicString&);
    232243#if ENABLE(CSS_SELECTORS_LEVEL4)
    233         void setArgumentList(std::unique_ptr<Vector<AtomicString>>);
     244        void setLangArgumentList(std::unique_ptr<Vector<LanguageArgument>>);
    234245#endif
    235246        void setSelectorList(std::unique_ptr<CSSSelectorList>);
     
    331342            AtomicString m_argument; // Used for :contains and :nth-*
    332343#if ENABLE(CSS_SELECTORS_LEVEL4)
    333             std::unique_ptr<Vector<AtomicString>> m_argumentList;
     344            std::unique_ptr<Vector<LanguageArgument>> m_langArgumentList;
    334345#endif
    335346            std::unique_ptr<CSSSelectorList> m_selectorList; // Used for :-webkit-any and :not
  • trunk/Source/WebCore/css/SelectorChecker.cpp

    r177925 r178532  
    936936            {
    937937#if ENABLE(CSS_SELECTORS_LEVEL4)
    938                 ASSERT(selector->argumentList() && !selector->argumentList()->isEmpty());
    939                 return matchesLangPseudoClass(element, *selector->argumentList());
     938                ASSERT(selector->langArgumentList() && !selector->langArgumentList()->isEmpty());
     939                return matchesLangPseudoClass(element, *selector->langArgumentList());
    940940#else
    941941                const AtomicString& argument = selector->argument();     
  • trunk/Source/WebCore/css/SelectorCheckerTestFunctions.h

    r178198 r178532  
    147147}
    148148
    149 inline bool matchesLangPseudoClass(const Element* element, const Vector<AtomicString>& ranges)
     149inline bool matchesLangPseudoClass(const Element* element, const Vector<LanguageArgument>& argumentList)
    150150{
    151151    ASSERT(element);
     
    162162        return false;
    163163
    164     // Implement basic and extended filterings of given language tags 
     164    // Implement basic and extended filterings of given language tags
    165165    // as specified in www.ietf.org/rfc/rfc4647.txt.
    166166    Vector<String> rangeSubtags;
     
    169169    language.string().split('-', true, languageSubtags);
    170170
    171     for (const AtomicString& range : ranges) {
     171    for (const LanguageArgument& argument : argumentList) {
     172        const AtomicString& range = argument.languageRange;
    172173        if (range.isEmpty())
    173174            continue;
Note: See TracChangeset for help on using the changeset viewer.