Changeset 140371 in webkit

Timestamp:

Jan 21, 2013 4:45:14 PM (11 years ago)

Author:

akling@apple.com

Message:

CSS: Make tag sub-selectors standalone CSSSelectors.
<​http://webkit.org/b/107111>

Reviewed by Antti Koivisto.

TL;DR: Instead of storing a QualifiedName with every CSSSelector, special-case tag selectors

by promoting them to stand-alone CSSSelectors.
33% reduction in CSS selector memory usage, 4.77 MB progression on Membuster3.
Fixed some bugs in Shadow DOM that were exposed by these changes.

A selector like this:

div.tripp.trapp#trull { }

Would previously be represented by a chain of 3 CSSSelector objects like so:

[ Tag: "div", Type: Class, Value: "tripp" ]
[ Tag: *, Type: Class, Value: "trapp" ]
[ Tag: *, Type: ID, Value: "trull" ]

After this change, the memory layout becomes:

[ Type: Tag, Value: "div" ]
[ Type: Class, Value: "tripp" ]
[ Type: Class, Value: "trapp" ]
[ Type: ID, Value: "trull" ]

This is a huge net memory win since the majority of selectors don't even have a tag name
and those that do now have a flat cost of one more CSSSelector.
Traversal is also slightly cleaner since any tag name will now be in a predictable place.

• css/SelectorChecker.cpp:

(WebCore::isFastCheckableMatch):

• html/shadow/HTMLContentElement.cpp:

(WebCore::validateSubSelector):

Renamed CSSSelector::None to CSSSelector::Tag.

• css/SelectorChecker.h:

(WebCore::SelectorChecker::tagMatches):

• css/StyleResolver.cpp:

(WebCore::StyleResolver::ruleMatches):

Changed SelectorChecker::tagMatches() to take a QualifiedName instead of a CSSSelector.

• dom/QualifiedName.cpp:

(WebCore::QualifiedName::deref):
(WebCore::QualifiedName::QualifiedNameImpl::~QualifiedNameImpl):

• dom/QualifiedName.h:

(QualifiedNameImpl):

Give QualifiedNameImpl a destructor so it can remove itself from the global cache instead of
having QualifiedName do it. This makes it possible to participate in ownership of QualifiedNames
via a QualifiedNameImpl pointer, as used by the union member in CSSSelector.

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

(WebCore::CSSParser::createFloatingSelectorWithTagName):
(WebCore::CSSParser::updateSpecifiersWithNamespaceIfNeeded):
(WebCore::CSSParser::updateSpecifiersWithElementName):

• css/CSSParser.h:
• css/CSSParserValues.h:

(CSSParserSelector):

• css/CSSParserValues.cpp:

(WebCore::CSSParserSelector::CSSParserSelector):
(WebCore::CSSParserSelector::prependTagSelector):

Make the CSS parser slap a CSSSelector with m_match=Tag at the head of all selectors that match
one or more of these criteria:

• The selector starts with a tag, e.g "div.foo" or just plain "span"
• There is a @namespace rule in effect, and the override namespace needs to be stored with the selector. These will have CSSSelectors::m_isTagForNamespaceRule set, this is only so that selector serialization can avoid outputting a '*' tag where we previously didn't.

(WebCore::CSSParserSelector::isSimple):

Merged the CSSSelector::isSimple() logic into CSSParserSelector, since it's only needed during parsing
to figure out if a selector is allowed within :not().

• css/CSSSelector.h:

(CSSSelector):
(WebCore::CSSSelector::setValue):
(WebCore::CSSSelector::CSSSelector):
(WebCore::CSSSelector::~CSSSelector):
(WebCore::CSSSelector::tagQName):

• css/CSSSelector.cpp:

(WebCore::CSSSelector::createRareData):
(WebCore::CSSSelector::operator==):

Add a QualifiedNameImpl* m_tagQName member to the CSSSelector data union. This union pointer is used
if m_match == Tag. tagQName() is used to retrieve the tag (renamed from tag().)

(WebCore::CSSSelector::selectorText):

Only serialize Tag selector components that aren't namespace placeholders. This behavior is web-facing
so we make an effort to stay consistent.

(WebCore::CSSSelector::specificityForOneSelector):
(WebCore::CSSSelector::specificityForPage):

• css/CSSSelectorList.cpp:

(WebCore::SelectorNeedsNamespaceResolutionFunctor::operator()):

• css/RuleSet.cpp:

(WebCore::isSelectorMatchingHTMLBasedOnRuleHash):

• css/SelectorFilter.cpp:

(WebCore::collectDescendantSelectorIdentifierHashes):
(WebCore::SelectorFilter::collectIdentifierHashes):

Adapt algorithms to having Tag selectors.

(WebCore::selectorListContainsUncommonAttributeSelector):

Loop through all selector components when looking for uncommon attributes.

(WebCore::determinePropertyWhitelistType):

Loop through all selector components when looking for ::cue().

(WebCore::RuleSet::addRule):
(WebCore::RuleSet::findBestRuleSetAndAdd):

Break addRule into two methods to be able to peek ahead if the first selector is a Tag.
Otherwise we'd end up sticking most selectors in m_tagRules, breaking the class/ID/etc optimizations.

• css/SelectorChecker.cpp:

(WebCore::SelectorChecker::fastCheck):
(WebCore::SelectorChecker::fastCheckSingleSelector):

It's no longer necessary to check the tagQName for every selector component, so don't.
Also simplified the signature of the template argument function.

(WebCore::SelectorChecker::fastCheckRightmostSelector):

Updated for Tag selectors.

(WebCore::SelectorChecker::checkOne):
(WebCore::SelectorChecker::matches):
(WebCore::SelectorChecker::match):

Have match() take a SiblingTraversalStrategy so it can forward that to checkOne().
This is necessary for shadow DOM code that was incorrectly calling checkOne() instead of match().

• css/StyleResolver.cpp:

(WebCore::StyleResolver::ruleMatches):

The meaning of "single-part selector" changes a bit with this patch, and no longer includes "div.foo"
as that is now a Tag, followed by a Class. Given that, we can't assume the tag check is unnecessary
just because the rightmost descendant was found in one of the hashes.

(WebCore::StyleResolver::matchPageRulesForList):

Loop through all selector components when matching @page since pseudo types may not always be in
the first subselector now.

• html/shadow/ContentDistributor.cpp:

(WebCore::ContentDistributor::collectSelectFeatureSetFrom):

Collect feature information from subselectors to make sure nothing is missed. (This bug was exposed
by offsetting the subselectors.)

• html/shadow/ContentSelectorQuery.cpp:

(WebCore::ContentSelectorChecker::checkContentSelector):

Call SelectorChecker::match() instead of checkOne() to make subselector traversal work properly.

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• css/CSSGrammar.y.in (modified) (4 diffs)
• css/CSSParser.cpp (modified) (4 diffs)
• css/CSSParser.h (modified) (2 diffs)
• css/CSSParserValues.cpp (modified) (3 diffs)
• css/CSSParserValues.h (modified) (3 diffs)
• css/CSSSelector.cpp (modified) (8 diffs)
• css/CSSSelector.h (modified) (13 diffs)
• css/CSSSelectorList.cpp (modified) (1 diff)
• css/RuleSet.cpp (modified) (4 diffs)
• css/RuleSet.h (modified) (1 diff)
• css/SelectorChecker.cpp (modified) (19 diffs)
• css/SelectorChecker.h (modified) (4 diffs)
• css/SelectorFilter.cpp (modified) (4 diffs)
• css/StyleResolver.cpp (modified) (4 diffs)
• dom/QualifiedName.cpp (modified) (1 diff)
• dom/QualifiedName.h (modified) (1 diff)
• html/shadow/ContentDistributor.cpp (modified) (1 diff)
• html/shadow/ContentSelectorQuery.cpp (modified) (1 diff)
• html/shadow/HTMLContentElement.cpp (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2013-01-21  Andreas Kling  <akling@apple.com>
+
+        CSS: Make tag sub-selectors standalone CSSSelectors.
+        <http://webkit.org/b/107111>
+
+        Reviewed by Antti Koivisto.
+
+        TL;DR: Instead of storing a QualifiedName with every CSSSelector, special-case tag selectors
+               by promoting them to stand-alone CSSSelectors.
+               33% reduction in CSS selector memory usage, 4.77 MB progression on Membuster3.
+               Fixed some bugs in Shadow DOM that were exposed by these changes.
+
+        A selector like this:
+
+            div.tripp.trapp#trull { }
+
+        Would previously be represented by a chain of 3 CSSSelector objects like so:
+
+            [ Tag: "div",  Type: Class,  Value: "tripp" ]
+            [ Tag:     *,  Type: Class,  Value: "trapp" ]
+            [ Tag:     *,  Type: ID,     Value: "trull" ]
+
+        After this change, the memory layout becomes:
+
+            [ Type: Tag,    Value: "div"   ]
+            [ Type: Class,  Value: "tripp" ]
+            [ Type: Class,  Value: "trapp" ]
+            [ Type: ID,     Value: "trull" ]
+
+        This is a huge net memory win since the majority of selectors don't even have a tag name
+        and those that do now have a flat cost of one more CSSSelector.
+        Traversal is also slightly cleaner since any tag name will now be in a predictable place.
+
+        * css/SelectorChecker.cpp:
+        (WebCore::isFastCheckableMatch):
+        * html/shadow/HTMLContentElement.cpp:
+        (WebCore::validateSubSelector):
+
+            Renamed CSSSelector::None to CSSSelector::Tag.
+
+        * css/SelectorChecker.h:
+        (WebCore::SelectorChecker::tagMatches):
+        * css/StyleResolver.cpp:
+        (WebCore::StyleResolver::ruleMatches):
+
+            Changed SelectorChecker::tagMatches() to take a QualifiedName instead of a CSSSelector.
+
+        * dom/QualifiedName.cpp:
+        (WebCore::QualifiedName::deref):
+        (WebCore::QualifiedName::QualifiedNameImpl::~QualifiedNameImpl):
+        * dom/QualifiedName.h:
+        (QualifiedNameImpl):
+
+            Give QualifiedNameImpl a destructor so it can remove itself from the global cache instead of
+            having QualifiedName do it. This makes it possible to participate in ownership of QualifiedNames
+            via a QualifiedNameImpl pointer, as used by the union member in CSSSelector.
+
+        * css/CSSGrammar.y.in:
+        * css/CSSParser.cpp:
+        (WebCore::CSSParser::createFloatingSelectorWithTagName):
+        (WebCore::CSSParser::updateSpecifiersWithNamespaceIfNeeded):
+        (WebCore::CSSParser::updateSpecifiersWithElementName):
+        * css/CSSParser.h:
+        * css/CSSParserValues.h:
+        (CSSParserSelector):
+        * css/CSSParserValues.cpp:
+        (WebCore::CSSParserSelector::CSSParserSelector):
+        (WebCore::CSSParserSelector::prependTagSelector):
+
+            Make the CSS parser slap a CSSSelector with m_match=Tag at the head of all selectors that match
+            one or more of these criteria:
+
+            - The selector starts with a tag, e.g "div.foo" or just plain "span"
+            - There is a @namespace rule in effect, and the override namespace needs to be stored with the selector.
+              These will have CSSSelectors::m_isTagForNamespaceRule set, this is only so that selector serialization
+              can avoid outputting a '*' tag where we previously didn't.
+
+        (WebCore::CSSParserSelector::isSimple):
+
+            Merged the CSSSelector::isSimple() logic into CSSParserSelector, since it's only needed during parsing
+            to figure out if a selector is allowed within :not().
+
+        * css/CSSSelector.h:
+        (CSSSelector):
+        (WebCore::CSSSelector::setValue):
+        (WebCore::CSSSelector::CSSSelector):
+        (WebCore::CSSSelector::~CSSSelector):
+        (WebCore::CSSSelector::tagQName):
+        * css/CSSSelector.cpp:
+        (WebCore::CSSSelector::createRareData):
+        (WebCore::CSSSelector::operator==):
+
+            Add a QualifiedNameImpl* m_tagQName member to the CSSSelector data union. This union pointer is used
+            if m_match == Tag. tagQName() is used to retrieve the tag (renamed from tag().) 
+
+        (WebCore::CSSSelector::selectorText):
+
+            Only serialize Tag selector components that aren't namespace placeholders. This behavior is web-facing
+            so we make an effort to stay consistent.
+
+        (WebCore::CSSSelector::specificityForOneSelector):
+        (WebCore::CSSSelector::specificityForPage):
+        * css/CSSSelectorList.cpp:
+        (WebCore::SelectorNeedsNamespaceResolutionFunctor::operator()):
+        * css/RuleSet.cpp:
+        (WebCore::isSelectorMatchingHTMLBasedOnRuleHash):
+        * css/SelectorFilter.cpp:
+        (WebCore::collectDescendantSelectorIdentifierHashes):
+        (WebCore::SelectorFilter::collectIdentifierHashes):
+
+            Adapt algorithms to having Tag selectors.
+
+        (WebCore::selectorListContainsUncommonAttributeSelector):
+
+            Loop through all selector components when looking for uncommon attributes.
+
+        (WebCore::determinePropertyWhitelistType):
+
+            Loop through all selector components when looking for ::cue().
+
+        (WebCore::RuleSet::addRule):
+        (WebCore::RuleSet::findBestRuleSetAndAdd):
+
+            Break addRule into two methods to be able to peek ahead if the first selector is a Tag.
+            Otherwise we'd end up sticking most selectors in m_tagRules, breaking the class/ID/etc optimizations.
+
+        * css/SelectorChecker.cpp:
+        (WebCore::SelectorChecker::fastCheck):
+        (WebCore::SelectorChecker::fastCheckSingleSelector):
+
+            It's no longer necessary to check the tagQName for every selector component, so don't.
+            Also simplified the signature of the template argument function.
+
+        (WebCore::SelectorChecker::fastCheckRightmostSelector):
+
+            Updated for Tag selectors.
+
+        (WebCore::SelectorChecker::checkOne):
+        (WebCore::SelectorChecker::matches):
+        (WebCore::SelectorChecker::match):
+
+            Have match() take a SiblingTraversalStrategy so it can forward that to checkOne().
+            This is necessary for shadow DOM code that was incorrectly calling checkOne() instead of match().
+
+        * css/StyleResolver.cpp:
+        (WebCore::StyleResolver::ruleMatches):
+
+            The meaning of "single-part selector" changes a bit with this patch, and no longer includes "div.foo"
+            as that is now a Tag, followed by a Class. Given that, we can't assume the tag check is unnecessary
+            just because the rightmost descendant was found in one of the hashes.
+
+        (WebCore::StyleResolver::matchPageRulesForList):
+
+            Loop through all selector components when matching @page since pseudo types may not always be in
+            the first subselector now.
+
+        * html/shadow/ContentDistributor.cpp:
+        (WebCore::ContentDistributor::collectSelectFeatureSetFrom):
+
+            Collect feature information from subselectors to make sure nothing is missed. (This bug was exposed
+            by offsetting the subselectors.)
+
+        * html/shadow/ContentSelectorQuery.cpp:
+        (WebCore::ContentSelectorChecker::checkContentSelector):
+
+            Call SelectorChecker::match() instead of checkOne() to make subselector traversal work properly.
+
 2013-01-21  Levi Weintraub  <leviw@chromium.org>
 

trunk/Source/WebCore/css/CSSGrammar.y.in

@@ -841 +841 @@
 page_selector:
     IDENT {
-        $$ = parser->createFloatingSelector();
-        $$->setTag(QualifiedName(nullAtom, $1, parser->m_defaultNamespace));
+        $$ = parser->createFloatingSelectorWithTagName(QualifiedName(nullAtom, $1, parser->m_defaultNamespace));
         $$->setForPage();
     }
@@ -848 +847 @@
         $$ = $2;
         if ($$) {
-            $$->setTag(QualifiedName(nullAtom, $1, parser->m_defaultNamespace));
+            $$->prependTagSelector(QualifiedName(nullAtom, $1, parser->m_defaultNamespace));
             $$->setForPage();
         }
@@ -1148 +1147 @@
 simple_selector:
     element_name {
-        $$ = parser->createFloatingSelector();
-        $$->setTag(QualifiedName(nullAtom, $1, parser->m_defaultNamespace));
+        $$ = parser->createFloatingSelectorWithTagName(QualifiedName(nullAtom, $1, parser->m_defaultNamespace));
     }
     | element_name specifier_list {
@@ -1159 +1157 @@
         $$ = $1;
         if ($$)
-            parser->updateSpecifiersWithElementName(nullAtom, starAtom, $$);
+            parser->updateSpecifiersWithNamespaceIfNeeded($$);
     }
     | namespace_selector element_name {
-        $$ = parser->createFloatingSelector();
-        $$->setTag(parser->determineNameInNamespace($1, $2));
+        $$ = parser->createFloatingSelectorWithTagName(parser->determineNameInNamespace($1, $2));
     }
     | namespace_selector element_name specifier_list {

trunk/Source/WebCore/css/CSSParser.cpp

@@ -10549 +10549 @@
 }
 
+CSSParserSelector* CSSParser::createFloatingSelectorWithTagName(const QualifiedName& tagQName)
+{
+    CSSParserSelector* selector = new CSSParserSelector(tagQName);
+    m_floatingSelectors.add(selector);
+    return selector;
+}
+
 CSSParserSelector* CSSParser::createFloatingSelector()
 {
@@ -10904 +10911 @@
 }
 
-void CSSParser::updateSpecifiersWithElementName(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector* specifiers)
+void CSSParser::updateSpecifiersWithNamespaceIfNeeded(CSSParserSelector* specifiers)
+{
+    if (m_defaultNamespace != starAtom || specifiers->isCustomPseudoElement())
+        updateSpecifiersWithElementName(nullAtom, starAtom, specifiers, /*tagIsForNamespaceRule*/true);
+}
+
+void CSSParser::updateSpecifiersWithElementName(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector* specifiers, bool tagIsForNamespaceRule)
 {
     AtomicString determinedNamespace = namespacePrefix != nullAtom && m_styleSheet ? m_styleSheet->determineNamespace(namespacePrefix) : m_defaultNamespace;
-    QualifiedName tag = QualifiedName(namespacePrefix, elementName, determinedNamespace);
+    QualifiedName tag(namespacePrefix, elementName, determinedNamespace);
+
     if (!specifiers->isCustomPseudoElement()) {
+        if (tag == anyQName())
+            return;
 #if ENABLE(VIDEO_TRACK)
         if (!(specifiers->pseudoType() == CSSSelector::PseudoCue))
 #endif
-            specifiers->setTag(tag);
+            specifiers->prependTagSelector(tag, tagIsForNamespaceRule);
         return;
     }
@@ -10925 +10941 @@
 
     if (lastShadowDescendant->tagHistory()) {
-        lastShadowDescendant->tagHistory()->setTag(tag);
+        if (tag != anyQName())
+            lastShadowDescendant->tagHistory()->prependTagSelector(tag, tagIsForNamespaceRule);
         return;
     }
@@ -10931 +10948 @@
     // For shadow-ID pseudo-elements to be correctly matched, the ShadowDescendant combinator has to be used.
     // We therefore create a new Selector with that combinator here in any case, even if matching any (host) element in any namespace (i.e. '*').
-    OwnPtr<CSSParserSelector> elementNameSelector = adoptPtr(new CSSParserSelector);
-    elementNameSelector->setTag(tag);
+    OwnPtr<CSSParserSelector> elementNameSelector = adoptPtr(new CSSParserSelector(tag));
     lastShadowDescendant->setTagHistory(elementNameSelector.release());
     lastShadowDescendant->setRelation(CSSSelector::ShadowDescendant);

trunk/Source/WebCore/css/CSSParser.h

@@ -267 +267 @@
 
     CSSParserSelector* createFloatingSelector();
+    CSSParserSelector* createFloatingSelectorWithTagName(const QualifiedName&);
     PassOwnPtr<CSSParserSelector> sinkFloatingSelector(CSSParserSelector*);
 
@@ -317 +318 @@
     void addNamespace(const AtomicString& prefix, const AtomicString& uri);
     QualifiedName determineNameInNamespace(const AtomicString& prefix, const AtomicString& localName);
-    void updateSpecifiersWithElementName(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector*);
+    void updateSpecifiersWithElementName(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector*, bool isNamespacePlaceholder = false);
+    void updateSpecifiersWithNamespaceIfNeeded(CSSParserSelector*);
     CSSParserSelector* updateSpecifiers(CSSParserSelector*, CSSParserSelector*);
 

trunk/Source/WebCore/css/CSSParserValues.cpp

@@ -150 +150 @@
 }
 
+CSSParserSelector::CSSParserSelector(const QualifiedName& tagQName)
+    : m_selector(adoptPtr(new CSSSelector(tagQName)))
+{
+}
+
 CSSParserSelector::~CSSParserSelector()
 {
@@ -172 +177 @@
 }
 
+bool CSSParserSelector::isSimple() const
+{
+    if (m_selector->selectorList() || m_selector->matchesPseudoElement())
+        return false;
+
+    if (!m_tagHistory)
+        return true;
+
+    if (m_selector->m_match == CSSSelector::Tag) {
+        // We can't check against anyQName() here because namespace may not be nullAtom.
+        // Example:
+        //     @namespace "http://www.w3.org/2000/svg";
+        //     svg:not(:root) { ...
+        if (m_selector->tagQName().localName() == starAtom)
+            return m_tagHistory->isSimple();
+    }
+
+    return false;
+}
+
 void CSSParserSelector::insertTagHistory(CSSSelector::Relation before, PassOwnPtr<CSSParserSelector> selector, CSSSelector::Relation after)
 {
@@ -190 +215 @@
 }
 
-}
-
+void CSSParserSelector::prependTagSelector(const QualifiedName& tagQName, bool tagIsForNamespaceRule)
+{
+    OwnPtr<CSSParserSelector> second = adoptPtr(new CSSParserSelector);
+    second->m_selector = m_selector.release();
+    second->m_tagHistory = m_tagHistory.release();
+    m_tagHistory = second.release();
+
+    m_selector = adoptPtr(new CSSSelector(tagQName, tagIsForNamespaceRule));
+    m_selector->m_relation = CSSSelector::SubSelector;
+}
+
+}
+

trunk/Source/WebCore/css/CSSParserValues.h

@@ -173 +173 @@
 public:
     CSSParserSelector();
+    explicit CSSParserSelector(const QualifiedName&);
     ~CSSParserSelector();
 
     PassOwnPtr<CSSSelector> releaseSelector() { return m_selector.release(); }
 
-    void setTag(const QualifiedName& value) { m_selector->setTag(value); }
     void setValue(const AtomicString& value) { m_selector->setValue(value); }
     void setAttribute(const QualifiedName& value) { m_selector->setAttribute(value); }
@@ -190 +190 @@
     bool isCustomPseudoElement() const { return m_selector->isCustomPseudoElement(); }
 
-    bool isSimple() const { return !m_tagHistory && m_selector->isSimple(); }
+    bool isSimple() const;
     bool hasShadowDescendant() const;
 
@@ -197 +197 @@
     void insertTagHistory(CSSSelector::Relation before, PassOwnPtr<CSSParserSelector>, CSSSelector::Relation after);
     void appendTagHistory(CSSSelector::Relation, PassOwnPtr<CSSParserSelector>);
+    void prependTagSelector(const QualifiedName&, bool tagIsForNamespaceRule = false);
 
 private:

trunk/Source/WebCore/css/CSSSelector.cpp

@@ -42 +42 @@
 void CSSSelector::createRareData()
 {
+    ASSERT(m_match != Tag);
     if (m_hasRareData)
         return;
@@ -56 +57 @@
     static const unsigned classMask = 0xff00;
     static const unsigned elementMask = 0xff;
+
+    if (isForPage())
+        return specificityForPage() & maxValueMask;
+
     unsigned total = 0;
     unsigned temp = 0;
+
     for (const CSSSelector* selector = this; selector; selector = selector->tagHistory()) {
-        if (selector->m_isForPage)
-            return (total + selector->specificityForPage()) & maxValueMask;
         temp = total + selector->specificityForOneSelector();
         // Clamp each component to its max in the case of overflow.
@@ -79 +83 @@
     // FIXME: Pseudo-elements and pseudo-classes do not have the same specificity. This function
     // isn't quite correct.
-    unsigned s = (m_tag.localName() == starAtom ? 0 : 1);
     switch (m_match) {
     case Id:
-        s += 0x10000;
-        break;
+        return 0x10000;
     case Exact:
     case Class:
@@ -97 +99 @@
         // See http://lists.w3.org/Archives/Public/www-style/2010Sep/0530.html
         if (pseudoType() == PseudoNot && selectorList())
-            s += selectorList()->first()->specificityForOneSelector();
-        else
-            s += 0x100;
-    case None:
-        break;
-    }
-    return s;
+            return selectorList()->first()->specificityForOneSelector();
+        return 0x100;
+    case Tag:
+        return (tagQName().localName() != starAtom) ? 1 : 0;
+    case Unknown:
+        return 0;
+    }
+    ASSERT_NOT_REACHED();
+    return 0;
 }
 
@@ -109 +113 @@
 {
     // See http://dev.w3.org/csswg/css3-page/#cascading-and-page-context
-    unsigned s = (m_tag.localName() == starAtom ? 0 : 4);
-
-    switch (pseudoType()) {
-    case PseudoFirstPage:
-        s += 2;
-        break;
-    case PseudoLeftPage:
-    case PseudoRightPage:
-        s += 1;
-        break;
-    case PseudoNotParsed:
-        break;
-    default:
-        ASSERT_NOT_REACHED();
+    unsigned s = 0;
+
+    for (const CSSSelector* component = this; component; component = component->tagHistory()) {
+        switch (component->m_match) {
+        case Tag:
+            s += tagQName().localName() == starAtom ? 0 : 4;
+            break;
+        case PseudoClass:
+            switch (component->pseudoType()) {
+            case PseudoFirstPage:
+                s += 2;
+                break;
+            case PseudoLeftPage:
+            case PseudoRightPage:
+                s += 1;
+                break;
+            case PseudoNotParsed:
+                break;
+            default:
+                ASSERT_NOT_REACHED();
+            }
+            break;
+        default:
+            break;
+        }
     }
     return s;
@@ -552 +567 @@
 
     while (sel1 && sel2) {
-        if (sel1->m_tag != sel2->m_tag || sel1->attribute() != sel2->attribute() ||
-             sel1->relation() != sel2->relation() || sel1->m_match != sel2->m_match ||
-             sel1->value() != sel2->value() ||
-             sel1->pseudoType() != sel2->pseudoType() ||
-             sel1->argument() != sel2->argument())
+        if (sel1->attribute() != sel2->attribute()
+            || sel1->relation() != sel2->relation()
+            || sel1->m_match != sel2->m_match
+            || sel1->value() != sel2->value()
+            || sel1->pseudoType() != sel2->pseudoType()
+            || sel1->argument() != sel2->argument()) {
             return false;
+        }
+        if (sel1->m_match == Tag) {
+            if (sel1->tagQName() != sel2->tagQName())
+                return false;
+        }
         sel1 = sel1->tagHistory();
         sel2 = sel2->tagHistory();
@@ -572 +593 @@
     StringBuilder str;
 
-    const AtomicString& prefix = m_tag.prefix();
-    const AtomicString& localName = m_tag.localName();
-    if (m_match == CSSSelector::None || !prefix.isNull() || localName != starAtom) {
-        if (prefix.isNull())
-            str.append(localName);
+    if (m_match == CSSSelector::Tag && !m_tagIsForNamespaceRule) {
+        if (tagQName().prefix().isNull())
+            str.append(tagQName().localName());
         else {
-            str.append(prefix.string());
+            str.append(tagQName().prefix().string());
             str.append('|');
-            str.append(localName);
+            str.append(tagQName().localName());
         }
     }
@@ -725 +744 @@
 }
 
-bool CSSSelector::isSimple() const
-{
-    if (selectorList() || tagHistory() || matchesPseudoElement())
-        return false;
-
-    int numConditions = 0;
-
-    // hasTag() cannot be be used here because namespace may not be nullAtom.
-    // Example:
-    //     @namespace "http://www.w3.org/2000/svg";
-    //     svg:not(:root) { ...
-    if (m_tag != starAtom)
-        numConditions++;
-
-    if (m_match == Id || m_match == Class || m_match == PseudoClass)
-        numConditions++;
-
-    if (m_hasRareData && m_data.m_rareData->m_attribute != anyQName())
-        numConditions++;
-
-    // numConditions is 0 for a universal selector.
-    // numConditions is 1 for other simple selectors.
-    return numConditions <= 1;
-}
-
 CSSSelector::RareData::RareData(PassRefPtr<AtomicStringImpl> value)
     : m_value(value.leakRef())

trunk/Source/WebCore/css/CSSSelector.h

@@ -2 +2 @@
  * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
  *               1999 Waldo Bastian (bastian@kde.org)
- * Copyright (C) 2004, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ -38 +38 @@
         CSSSelector();
         CSSSelector(const CSSSelector&);
+        explicit CSSSelector(const QualifiedName&, bool tagIsForNamespaceRule = false);
 
         ~CSSSelector();
@@ -55 +56 @@
         /* how the attribute value has to match.... Default is Exact */
         enum Match {
-            None = 0,
+            Unknown = 0,
+            Tag,
             Id,
             Class,
@@ -199 +201 @@
         CSSSelector* tagHistory() const { return m_isLastInTagHistory ? 0 : const_cast<CSSSelector*>(this + 1); }
 
-        bool hasTag() const { return m_tag != anyQName(); }
-
-        const QualifiedName& tag() const { return m_tag; }
+        const QualifiedName& tagQName() const;
         // AtomicString is really just an AtomicStringImpl* so the cast below is safe.
         // FIXME: Perhaps call sites could be changed to accept AtomicStringImpl?
@@ -209 +209 @@
         CSSSelectorList* selectorList() const { return m_hasRareData ? m_data.m_rareData->m_selectorList.get() : 0; }
 
-        void setTag(const QualifiedName& value) { m_tag = value; }
         void setValue(const AtomicString&);
         void setAttribute(const QualifiedName&);
@@ -246 +245 @@
         bool m_hasRareData            : 1;
         bool m_isForPage              : 1;
+        bool m_tagIsForNamespaceRule  : 1;
 
         unsigned specificityForOneSelector() const;
@@ -276 +276 @@
             DataUnion() : m_value(0) { }
             AtomicStringImpl* m_value;
+            QualifiedName::QualifiedNameImpl* m_tagQName;
             RareData* m_rareData;
         } m_data;
-
-        QualifiedName m_tag;
     };
 
@@ -337 +336 @@
 inline void CSSSelector::setValue(const AtomicString& value)
 {
+    ASSERT(m_match != Tag);
     // Need to do ref counting manually for the union.
     if (m_hasRareData) {
@@ -361 +361 @@
 inline CSSSelector::CSSSelector()
     : m_relation(Descendant)
-    , m_match(None)
+    , m_match(Unknown)
     , m_pseudoType(PseudoNotParsed)
     , m_parsedNth(false)
@@ -368 +368 @@
     , m_hasRareData(false)
     , m_isForPage(false)
-    , m_tag(anyQName())
-{
+    , m_tagIsForNamespaceRule(false)
+{
+}
+
+inline CSSSelector::CSSSelector(const QualifiedName& tagQName, bool tagIsForNamespaceRule)
+    : m_relation(Descendant)
+    , m_match(Tag)
+    , m_pseudoType(PseudoNotParsed)
+    , m_parsedNth(false)
+    , m_isLastInSelectorList(false)
+    , m_isLastInTagHistory(true)
+    , m_hasRareData(false)
+    , m_isForPage(false)
+    , m_tagIsForNamespaceRule(tagIsForNamespaceRule)
+{
+    m_data.m_tagQName = tagQName.impl();
+    m_data.m_tagQName->ref();
 }
 
@@ -381 +396 @@
     , m_hasRareData(o.m_hasRareData)
     , m_isForPage(o.m_isForPage)
-    , m_tag(o.m_tag)
-{
-    if (o.m_hasRareData) {
+    , m_tagIsForNamespaceRule(o.m_tagIsForNamespaceRule)
+{
+    if (o.m_match == Tag) {
+        m_data.m_tagQName = o.m_data.m_tagQName;
+        m_data.m_tagQName->ref();
+    } else if (o.m_hasRareData) {
         m_data.m_rareData = o.m_data.m_rareData;
         m_data.m_rareData->ref();
@@ -394 +412 @@
 inline CSSSelector::~CSSSelector()
 {
-    if (m_hasRareData)
+    if (m_match == Tag)
+        m_data.m_tagQName->deref();
+    else if (m_hasRareData)
         m_data.m_rareData->deref();
     else if (m_data.m_value)
@@ -400 +420 @@
 }
 
+inline const QualifiedName& CSSSelector::tagQName() const
+{
+    ASSERT(m_match == Tag);
+    return *reinterpret_cast<const QualifiedName*>(&m_data.m_tagQName);
+}
+
 } // namespace WebCore
 

trunk/Source/WebCore/css/CSSSelectorList.cpp

@@ -184 +184 @@
     bool operator()(CSSSelector* selector)
     {
-        if (selector->hasTag() && selector->tag().prefix() != nullAtom && selector->tag().prefix() != starAtom)
+        if (selector->m_match == CSSSelector::Tag && selector->tagQName().prefix() != nullAtom && selector->tagQName().prefix() != starAtom)
             return true;
         if (selector->isAttributeSelector() && selector->attribute().prefix() != nullAtom && selector->attribute().prefix() != starAtom)

trunk/Source/WebCore/css/RuleSet.cpp

@@ -56 +56 @@
 static inline bool isSelectorMatchingHTMLBasedOnRuleHash(const CSSSelector* selector)
 {
-    const AtomicString& selectorNamespace = selector->tag().namespaceURI();
-    if (selectorNamespace != starAtom && selectorNamespace != xhtmlNamespaceURI)
-        return false;
-    if (selector->m_match == CSSSelector::None)
-        return true;
-    if (selector->tag() != starAtom)
-        return false;
+    ASSERT(selector);
+    if (selector->m_match == CSSSelector::Tag) {
+        const AtomicString& selectorNamespace = selector->tagQName().namespaceURI();
+        if (selectorNamespace != starAtom && selectorNamespace != xhtmlNamespaceURI)
+            return false;
+        if (selector->relation() == CSSSelector::SubSelector)
+            return isSelectorMatchingHTMLBasedOnRuleHash(selector->tagHistory());
+        return true;
+    }
     if (SelectorChecker::isCommonPseudoClassSelector(selector))
         return true;
@@ -73 +75 @@
     if (!selectorList)
         return false;
-    for (CSSSelector* subSelector = selectorList->first(); subSelector; subSelector = CSSSelectorList::next(subSelector)) {
-        if (subSelector->isAttributeSelector())
-            return true;
+    for (CSSSelector* selector = selectorList->first(); selector; selector = CSSSelectorList::next(selector)) {
+        for (CSSSelector* component = selector; component; component = component->tagHistory()) {
+            if (component->isAttributeSelector())
+                return true;
+        }
     }
     return false;
@@ -114 +118 @@
         return PropertyWhitelistRegion;
 #if ENABLE(VIDEO_TRACK)
-    if (selector->pseudoType() == CSSSelector::PseudoCue)
-        return PropertyWhitelistCue;
+    for (const CSSSelector* component = selector; component; component = component->tagHistory()) {
+        if (component->pseudoType() == CSSSelector::PseudoCue)
+            return PropertyWhitelistCue;
+    }
 #endif
     return PropertyWhitelistNone;
@@ -207 +213 @@
 }
 
-void RuleSet::addRule(StyleRule* rule, unsigned selectorIndex, AddRuleFlags addRuleFlags)
-{
-    RuleData ruleData(rule, selectorIndex, m_ruleCount++, addRuleFlags);
-
-    collectFeaturesFromRuleData(m_features, ruleData);
-
-    CSSSelector* selector = ruleData.selector();
-
-    if (selector->m_match == CSSSelector::Id) {
-        addToRuleSet(selector->value().impl(), m_idRules, ruleData);
-        return;
-    }
-    if (selector->m_match == CSSSelector::Class) {
-        addToRuleSet(selector->value().impl(), m_classRules, ruleData);
-        return;
-    }
-    if (selector->isCustomPseudoElement()) {
-        addToRuleSet(selector->value().impl(), m_shadowPseudoElementRules, ruleData);
-        return;
+bool RuleSet::findBestRuleSetAndAdd(const CSSSelector* component, RuleData& ruleData)
+{
+    if (component->m_match == CSSSelector::Id) {
+        addToRuleSet(component->value().impl(), m_idRules, ruleData);
+        return true;
+    }
+    if (component->m_match == CSSSelector::Class) {
+        addToRuleSet(component->value().impl(), m_classRules, ruleData);
+        return true;
+    }
+    if (component->isCustomPseudoElement()) {
+        addToRuleSet(component->value().impl(), m_shadowPseudoElementRules, ruleData);
+        return true;
     }
 #if ENABLE(VIDEO_TRACK)
-    if (selector->pseudoType() == CSSSelector::PseudoCue) {
+    if (component->pseudoType() == CSSSelector::PseudoCue) {
         m_cuePseudoRules.append(ruleData);
-        return;
-    }
-#endif
-    if (SelectorChecker::isCommonPseudoClassSelector(selector)) {
-        switch (selector->pseudoType()) {
+        return true;
+    }
+#endif
+    if (SelectorChecker::isCommonPseudoClassSelector(component)) {
+        switch (component->pseudoType()) {
         case CSSSelector::PseudoLink:
         case CSSSelector::PseudoVisited:
         case CSSSelector::PseudoAnyLink:
             m_linkPseudoClassRules.append(ruleData);
-            return;
+            return true;
         case CSSSelector::PseudoFocus:
             m_focusPseudoClassRules.append(ruleData);
-            return;
+            return true;
         default:
             ASSERT_NOT_REACHED();
-        }
-        return;
-    }
-    const AtomicString& localName = selector->tag().localName();
-    if (localName != starAtom) {
-        addToRuleSet(localName.impl(), m_tagRules, ruleData);
-        return;
-    }
-    m_universalRules.append(ruleData);
+            return true;
+        }
+    }
+
+    if (component->m_match == CSSSelector::Tag) {
+        if (component->tagQName().localName() != starAtom) {
+            // If this is part of a subselector chain, recurse ahead to find a narrower set (ID/class.)
+            if (component->relation() == CSSSelector::SubSelector
+                && (component->tagHistory()->m_match == CSSSelector::Class || component->tagHistory()->m_match == CSSSelector::Id || SelectorChecker::isCommonPseudoClassSelector(component->tagHistory()))
+                && findBestRuleSetAndAdd(component->tagHistory(), ruleData))
+                return true;
+
+            addToRuleSet(component->tagQName().localName().impl(), m_tagRules, ruleData);
+            return true;
+        }
+    }
+    return false;
+}
+
+void RuleSet::addRule(StyleRule* rule, unsigned selectorIndex, AddRuleFlags addRuleFlags)
+{
+    RuleData ruleData(rule, selectorIndex, m_ruleCount++, addRuleFlags);
+    collectFeaturesFromRuleData(m_features, ruleData);
+
+    if (!findBestRuleSetAndAdd(ruleData.selector(), ruleData)) {
+        // If we didn't find a specialized map to stick it in, file under universal rules.
+        m_universalRules.append(ruleData);
+    }
 }
 

trunk/Source/WebCore/css/RuleSet.h

@@ -139 +139 @@
 private:
     void addChildRules(const Vector<RefPtr<StyleRuleBase> >&, const MediaQueryEvaluator& medium, StyleResolver*, const ContainerNode* scope, bool hasDocumentSecurityOrigin, AddRuleFlags);
+    bool findBestRuleSetAndAdd(const CSSSelector*, RuleData&);
 
 public:

trunk/Source/WebCore/css/SelectorChecker.cpp

@@ -3 +3 @@
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
- * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
@@ -80 +80 @@
 
     PseudoId ignoreDynamicPseudo = NOPSEUDO;
-    return match(SelectorCheckingContext(sel, element, SelectorChecker::VisitedMatchDisabled), ignoreDynamicPseudo) == SelectorMatches;
+    return match(SelectorCheckingContext(sel, element, SelectorChecker::VisitedMatchDisabled), ignoreDynamicPseudo, DOMSiblingTraversalStrategy()) == SelectorMatches;
 }
 
 namespace {
 
-template <bool checkValue(const Element*, AtomicStringImpl*, const QualifiedName&), bool initAttributeName>
+template <bool checkValue(const Element*, const CSSSelector*)>
 inline bool fastCheckSingleSelector(const CSSSelector*& selector, const Element*& element, const CSSSelector*& topChildOrSubselector, const Element*& topChildOrSubselectorMatchElement)
 {
-    AtomicStringImpl* value = selector->value().impl();
-    const QualifiedName& attribute = initAttributeName ? selector->attribute() : anyQName();
     for (; element; element = element->parentElement()) {
-        if (checkValue(element, value, attribute) && SelectorChecker::tagMatches(element, selector)) {
+        if (checkValue(element, selector)) {
             if (selector->relation() == CSSSelector::Descendant)
                 topChildOrSubselector = 0;
@@ -121 +119 @@
 }
 
-inline bool checkClassValue(const Element* element, AtomicStringImpl* value, const QualifiedName&)
-{
-    return element->hasClass() && static_cast<const StyledElement*>(element)->classNames().contains(value);
-}
-
-inline bool checkIDValue(const Element* element, AtomicStringImpl* value, const QualifiedName&)
-{
-    return element->hasID() && element->idForStyleResolution().impl() == value;
-}
-
-inline bool checkExactAttributeValue(const Element* element, AtomicStringImpl* value, const QualifiedName& attributeName)
-{
-    return SelectorChecker::checkExactAttribute(element, attributeName, value);
-}
-
-inline bool checkTagValue(const Element*, AtomicStringImpl*, const QualifiedName&)
-{
-    return true;
+inline bool checkClassValue(const Element* element, const CSSSelector* selector)
+{
+    return element->hasClass() && static_cast<const StyledElement*>(element)->classNames().contains(selector->value().impl());
+}
+
+inline bool checkIDValue(const Element* element, const CSSSelector* selector)
+{
+    return element->hasID() && element->idForStyleResolution().impl() == selector->value().impl();
+}
+
+inline bool checkExactAttributeValue(const Element* element, const CSSSelector* selector)
+{
+    return SelectorChecker::checkExactAttribute(element, selector->attribute(), selector->value().impl());
+}
+
+inline bool checkTagValue(const Element* element, const CSSSelector* selector)
+{
+    return SelectorChecker::tagMatches(element, selector->tagQName());
 }
 
@@ -147 +145 @@
     ASSERT(isFastCheckableSelector(selector));
 
-    if (!SelectorChecker::tagMatches(element, selector))
-        return false;
     switch (selector->m_match) {
-    case CSSSelector::None:
-        return true;
+    case CSSSelector::Tag:
+        return checkTagValue(element, selector);
     case CSSSelector::Class:
-        return checkClassValue(element, selector->value().impl(), anyQName());
+        return checkClassValue(element, selector);
     case CSSSelector::Id:
-        return checkIDValue(element, selector->value().impl(), anyQName());
+        return checkIDValue(element, selector);
     case CSSSelector::Exact:
     case CSSSelector::Set:
-        return checkExactAttributeValue(element, selector->value().impl(), selector->attribute());
+        return checkExactAttributeValue(element, selector);
     case CSSSelector::PseudoClass:
         return commonPseudoClassSelectorMatches(element, selector, visitedMatchType);
@@ -185 +181 @@
         switch (selector->m_match) {
         case CSSSelector::Class:
-            if (!fastCheckSingleSelector<checkClassValue, false>(selector, element, topChildOrSubselector, topChildOrSubselectorMatchElement))
+            if (!fastCheckSingleSelector<checkClassValue>(selector, element, topChildOrSubselector, topChildOrSubselectorMatchElement))
                 return false;
             break;
         case CSSSelector::Id:
-            if (!fastCheckSingleSelector<checkIDValue, false>(selector, element, topChildOrSubselector, topChildOrSubselectorMatchElement))
-                return false;
-            break;
-        case CSSSelector::None:
-            if (!fastCheckSingleSelector<checkTagValue, false>(selector, element, topChildOrSubselector, topChildOrSubselectorMatchElement))
+            if (!fastCheckSingleSelector<checkIDValue>(selector, element, topChildOrSubselector, topChildOrSubselectorMatchElement))
+                return false;
+            break;
+        case CSSSelector::Tag:
+            if (!fastCheckSingleSelector<checkTagValue>(selector, element, topChildOrSubselector, topChildOrSubselectorMatchElement))
                 return false;
             break;
         case CSSSelector::Set:
         case CSSSelector::Exact:
-            if (!fastCheckSingleSelector<checkExactAttributeValue, true>(selector, element, topChildOrSubselector, topChildOrSubselectorMatchElement))
+            if (!fastCheckSingleSelector<checkExactAttributeValue>(selector, element, topChildOrSubselector, topChildOrSubselectorMatchElement))
                 return false;
             break;
@@ -222 +218 @@
     if (selector->m_match == CSSSelector::Exact)
         return selector->attribute() != styleAttr && !htmlAttributeHasCaseInsensitiveValue(selector->attribute());
-    return selector->m_match == CSSSelector::None || selector->m_match == CSSSelector::Id || selector->m_match == CSSSelector::Class;
+    return selector->m_match == CSSSelector::Tag || selector->m_match == CSSSelector::Id || selector->m_match == CSSSelector::Class;
 }
 
@@ -251 +247 @@
 // * SelectorFailsAllSiblings - the selector fails for e and any sibling of e
 // * SelectorFailsCompletely  - the selector fails for e and any sibling or ancestor of e
-SelectorChecker::Match SelectorChecker::match(const SelectorCheckingContext& context, PseudoId& dynamicPseudo) const
+template<typename SiblingTraversalStrategy>
+SelectorChecker::Match SelectorChecker::match(const SelectorCheckingContext& context, PseudoId& dynamicPseudo, const SiblingTraversalStrategy& siblingTraversalStrategy) const
 {
     // first selector has to match
-    if (!checkOne(context, DOMSiblingTraversalStrategy()))
+    if (!checkOne(context, siblingTraversalStrategy))
         return SelectorFailsLocally;
 
@@ -316 +313 @@
         nextContext.elementParentStyle = 0;
         for (; nextContext.element; nextContext.element = nextContext.element->parentElement()) {
-            Match match = this->match(nextContext, ignoreDynamicPseudo);
+            Match match = this->match(nextContext, ignoreDynamicPseudo, siblingTraversalStrategy);
             if (match == SelectorMatches || match == SelectorFailsCompletely)
                 return match;
@@ -331 +328 @@
         nextContext.elementStyle = 0;
         nextContext.elementParentStyle = 0;
-        return match(nextContext, ignoreDynamicPseudo);
+        return match(nextContext, ignoreDynamicPseudo, siblingTraversalStrategy);
 
     case CSSSelector::DirectAdjacent:
@@ -344 +341 @@
         nextContext.elementStyle = 0;
         nextContext.elementParentStyle = 0;
-        return match(nextContext, ignoreDynamicPseudo);
+        return match(nextContext, ignoreDynamicPseudo, siblingTraversalStrategy);
 
     case CSSSelector::IndirectAdjacent:
@@ -356 +353 @@
         nextContext.elementParentStyle = 0;
         for (; nextContext.element; nextContext.element = nextContext.element->previousElementSibling()) {
-            Match match = this->match(nextContext, ignoreDynamicPseudo);
+            Match match = this->match(nextContext, ignoreDynamicPseudo, siblingTraversalStrategy);
             if (match == SelectorMatches || match == SelectorFailsAllSiblings || match == SelectorFailsCompletely)
                 return match;
@@ -373 +370 @@
             return SelectorFailsCompletely;
         nextContext.isSubSelector = true;
-        return match(nextContext, dynamicPseudo);
+        return match(nextContext, dynamicPseudo, siblingTraversalStrategy);
 
     case CSSSelector::ShadowDescendant:
@@ -387 +384 @@
             nextContext.elementStyle = 0;
             nextContext.elementParentStyle = 0;
-            return match(nextContext, ignoreDynamicPseudo);
+            return match(nextContext, ignoreDynamicPseudo, siblingTraversalStrategy);
         }
     }
@@ -549 +546 @@
     ASSERT(selector);
 
-    if (!SelectorChecker::tagMatches(element, selector))
-        return false;
+    if (selector->m_match == CSSSelector::Tag)
+        return SelectorChecker::tagMatches(element, selector->tagQName());
 
     if (selector->m_match == CSSSelector::Class)
@@ -770 +767 @@
                 PseudoId ignoreDynamicPseudo = NOPSEUDO;
                 for (subContext.selector = selector->selectorList()->first(); subContext.selector; subContext.selector = CSSSelectorList::next(subContext.selector)) {
-                    if (match(subContext, ignoreDynamicPseudo) == SelectorMatches)
+                    if (match(subContext, ignoreDynamicPseudo, siblingTraversalStrategy) == SelectorMatches)
                         return true;
                 }
@@ -803 +800 @@
             // If we're in quirks mode, then hover should never match anchors with no
             // href and *:hover should not match anything. This is important for sites like wsj.com.
-            if (m_strictParsing || context.isSubSelector || (selector->hasTag() && !element->hasTagName(aTag)) || element->isLink()) {
+            if (m_strictParsing || context.isSubSelector || (selector->m_match == CSSSelector::Tag && selector->tagQName() != anyQName() && !element->hasTagName(aTag)) || element->isLink()) {
                 if (m_mode == ResolvingStyle) {
                     if (context.elementStyle)
@@ -817 +814 @@
             // If we're in quirks mode, then :active should never match anchors with no
             // href and *:active should not match anything.
-            if (m_strictParsing || context.isSubSelector || (selector->hasTag() && !element->hasTagName(aTag)) || element->isLink()) {
+            if (m_strictParsing || context.isSubSelector || (selector->m_match == CSSSelector::Tag && selector->tagQName() != anyQName() && !element->hasTagName(aTag)) || element->isLink()) {
                 if (m_mode == ResolvingStyle) {
                     if (context.elementStyle)
@@ -977 +974 @@
         CSSSelector* const & selector = context.selector;
         for (subContext.selector = selector->selectorList()->first(); subContext.selector; subContext.selector = CSSSelectorList::next(subContext.selector)) {
-            if (match(subContext, ignoreDynamicPseudo) == SelectorMatches)
+            if (match(subContext, ignoreDynamicPseudo, siblingTraversalStrategy) == SelectorMatches)
                 return true;
         }
@@ -1136 +1133 @@
 
 template
-bool SelectorChecker::checkOne(const SelectorChecker::SelectorCheckingContext&, const ShadowDOMSiblingTraversalStrategy&) const;
-
-}
+SelectorChecker::Match SelectorChecker::match(const SelectorCheckingContext&, PseudoId&, const DOMSiblingTraversalStrategy&) const;
+
+template
+SelectorChecker::Match SelectorChecker::match(const SelectorCheckingContext&, PseudoId&, const ShadowDOMSiblingTraversalStrategy&) const;
+
+}

trunk/Source/WebCore/css/SelectorChecker.h

@@ -3 +3 @@
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
- * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
@@ -79 +79 @@
 
     bool matches(CSSSelector*, Element*, bool isFastCheckableSelector = false) const;
-    Match match(const SelectorCheckingContext&, PseudoId&) const;
+    template<typename SiblingTraversalStrategy>
+    Match match(const SelectorCheckingContext&, PseudoId&, const SiblingTraversalStrategy&) const;
     template<typename SiblingTraversalStrategy>
     bool checkOne(const SelectorCheckingContext&, const SiblingTraversalStrategy&) const;
@@ -91 +92 @@
     void setMode(Mode mode) { m_mode = mode; }
 
-    static bool tagMatches(const Element*, const CSSSelector*);
+    static bool tagMatches(const Element*, const QualifiedName&);
     static bool isCommonPseudoClassSelector(const CSSSelector*);
     bool matchesFocusPseudoClass(const Element*) const;
@@ -130 +131 @@
 }
 
-inline bool SelectorChecker::tagMatches(const Element* element, const CSSSelector* selector)
+inline bool SelectorChecker::tagMatches(const Element* element, const QualifiedName& tagQName)
 {
-    if (!selector->hasTag())
+    if (tagQName == anyQName())
         return true;
-    const AtomicString& localName = selector->tag().localName();
+    const AtomicString& localName = tagQName.localName();
     if (localName != starAtom && localName != element->localName())
         return false;
-    const AtomicString& namespaceURI = selector->tag().namespaceURI();
+    const AtomicString& namespaceURI = tagQName.namespaceURI();
     return namespaceURI == starAtom || namespaceURI == element->namespaceURI();
 }

trunk/Source/WebCore/css/SelectorFilter.cpp

@@ -110 +110 @@
 }
 
-static inline void collectDescendantSelectorIdentifierHashes(const CSSSelector* selector, unsigned*& hash, const unsigned* end)
+static inline void collectDescendantSelectorIdentifierHashes(const CSSSelector* selector, unsigned*& hash)
 {
     switch (selector->m_match) {
@@ -121 +121 @@
             (*hash++) = selector->value().impl()->existingHash() * ClassAttributeSalt;
         break;
+    case CSSSelector::Tag:
+        if (selector->tagQName().localName() != starAtom)
+            (*hash++) = selector->tagQName().localName().impl()->existingHash() * TagNameSalt;
+        break;
     default:
         break;
     }
-    if (hash == end)
-        return;
-    const AtomicString& localName = selector->tag().localName();
-    if (localName != starAtom)
-        (*hash++) = localName.impl()->existingHash() * TagNameSalt;
 }
 
@@ -144 +143 @@
         case CSSSelector::SubSelector:
             if (!skipOverSubselectors)
-                collectDescendantSelectorIdentifierHashes(selector, hash, end);
+                collectDescendantSelectorIdentifierHashes(selector, hash);
             break;
         case CSSSelector::DirectAdjacent:
@@ -154 +153 @@
         case CSSSelector::Child:
             skipOverSubselectors = false;
-            collectDescendantSelectorIdentifierHashes(selector, hash, end);
+            collectDescendantSelectorIdentifierHashes(selector, hash);
             break;
         }

trunk/Source/WebCore/css/StyleResolver.cpp

@@ -3 +3 @@
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
- * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
@@ -2273 +2273 @@
             if (!ruleData.hasMultipartSelector())
                 return true;
-        } else if (!SelectorChecker::tagMatches(m_element, ruleData.selector()))
+        }
+        if (ruleData.selector()->m_match == CSSSelector::Tag && !SelectorChecker::tagMatches(m_element, ruleData.selector()->tagQName()))
             return false;
         if (!SelectorChecker::fastCheckRightmostAttributeSelector(m_element, ruleData.selector()))
@@ -2286 +2287 @@
     context.scope = scope;
     context.pseudoStyle = m_pseudoStyle;
-    SelectorChecker::Match match = m_selectorChecker.match(context, m_dynamicPseudo);
+    SelectorChecker::Match match = m_selectorChecker.match(context, m_dynamicPseudo, DOMSiblingTraversalStrategy());
     if (match != SelectorChecker::SelectorMatches)
         return false;
@@ -2602 +2603 @@
 }
 
-void StyleResolver::matchPageRulesForList(Vector<StyleRulePage*>& matchedRules, const Vector<StyleRulePage*>& rules, bool isLeftPage, bool isFirstPage, const String& pageName)
-{
-    unsigned size = rules.size();
-    for (unsigned i = 0; i < size; ++i) {
-        StyleRulePage* rule = rules[i];
-        const AtomicString& selectorLocalName = rule->selector()->tag().localName();
-        if (selectorLocalName != starAtom && selectorLocalName != pageName)
-            continue;
-        CSSSelector::PseudoType pseudoType = rule->selector()->pseudoType();
+static bool checkPageSelectorComponents(const CSSSelector* selector, bool isLeftPage, bool isFirstPage, const String& pageName)
+{
+    for (const CSSSelector* component = selector; component; component = component->tagHistory()) {
+        if (component->m_match == CSSSelector::Tag) {
+            const AtomicString& localName = component->tagQName().localName();
+            if (localName != starAtom && localName != pageName)
+                return false;
+        }
+
+        CSSSelector::PseudoType pseudoType = component->pseudoType();
         if ((pseudoType == CSSSelector::PseudoLeftPage && !isLeftPage)
             || (pseudoType == CSSSelector::PseudoRightPage && isLeftPage)
             || (pseudoType == CSSSelector::PseudoFirstPage && !isFirstPage))
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+void StyleResolver::matchPageRulesForList(Vector<StyleRulePage*>& matchedRules, const Vector<StyleRulePage*>& rules, bool isLeftPage, bool isFirstPage, const String& pageName)
+{
+    for (unsigned i = 0; i < rules.size(); ++i) {
+        StyleRulePage* rule = rules[i];
+
+        if (!checkPageSelectorComponents(rule->selector(), isLeftPage, isFirstPage, pageName))
             continue;
 

trunk/Source/WebCore/dom/QualifiedName.cpp

@@ -103 +103 @@
 #endif
     ASSERT(!isHashTableDeletedValue());
+    m_impl->deref();
+}
 
-    if (m_impl->hasOneRef())
-        gNameCache->remove(m_impl);
-    m_impl->deref();
+QualifiedName::QualifiedNameImpl::~QualifiedNameImpl()
+{
+    gNameCache->remove(this);
 }
 

trunk/Source/WebCore/dom/QualifiedName.h

@@ -44 +44 @@
             return adoptRef(new QualifiedNameImpl(prefix, localName, namespaceURI));
         }
+
+        ~QualifiedNameImpl();
 
         unsigned computeHash() const;

trunk/Source/WebCore/html/shadow/ContentDistributor.cpp

@@ -407 +407 @@
     if (ScopeContentDistribution::hasContentElement(root)) {
         for (Element* element = ElementTraversal::firstWithin(root); element; element = ElementTraversal::next(element)) {
-            if (isHTMLContentElement(element)) {
-                const CSSSelectorList& list = toHTMLContentElement(element)->selectorList();
-                for (CSSSelector* selector = list.first(); selector; selector = list.next(selector))
-                    m_selectFeatures.collectFeaturesFromSelector(selector);
+            if (!isHTMLContentElement(element))
+                continue;
+            const CSSSelectorList& list = toHTMLContentElement(element)->selectorList();
+            for (CSSSelector* selector = list.first(); selector; selector = CSSSelectorList::next(selector)) {
+                for (CSSSelector* component = selector; component; component = component->tagHistory())
+                    m_selectFeatures.collectFeaturesFromSelector(component);
             }
         }

trunk/Source/WebCore/html/shadow/ContentSelectorQuery.cpp

@@ -46 +46 @@
     SelectorChecker::SelectorCheckingContext context(selector, toElement(siblings[nth].get()), SelectorChecker::VisitedMatchEnabled);
     ShadowDOMSiblingTraversalStrategy strategy(siblings, nth);
-    return m_selectorChecker.checkOne(context, strategy);
+    PseudoId ignoreDynamicPseudo = NOPSEUDO;
+    return m_selectorChecker.match(context, ignoreDynamicPseudo, strategy) == SelectorChecker::SelectorMatches;
 }
 

trunk/Source/WebCore/html/shadow/HTMLContentElement.cpp

@@ -121 +121 @@
 {
     switch (selector->m_match) {
-    case CSSSelector::None:
+    case CSSSelector::Tag:
     case CSSSelector::Id:
     case CSSSelector::Class: