Clean up empty namespace handling and fix empty namespaces in compound selectors

Source/core/css/parser/CSSSelectorParser.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/css/parser/CSSSelectorParser.h"
 
 #include "core/css/CSSSelectorList.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/frame/UseCounter.h"
@@ skipping 124 matching lines @@
 
     return selector.release();
 }
 
 PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumeCompoundSelector(CSSParserTokenRange& range)
 {
     OwnPtr<CSSParserSelector> compoundSelector;
 
     AtomicString namespacePrefix;
     AtomicString elementName;
-    bool hasNamespace;
-    if (!consumeName(range, elementName, namespacePrefix, hasNamespace)) {
+    if (!consumeName(range, elementName, namespacePrefix)) {
         compoundSelector = consumeSimpleSelector(range);
         if (!compoundSelector)
             return nullptr;
     }
     if (m_context.isHTMLDocument())
         elementName = elementName.lower();
 
     while (OwnPtr<CSSParserSelector> simpleSelector = consumeSimpleSelector(range)) {
         if (compoundSelector)
             compoundSelector = addSimpleSelectorToCompound(compoundSelector.release(), simpleSelector.release());
         else
             compoundSelector = simpleSelector.release();
     }
 
-    if (!compoundSelector) {
-        if (hasNamespace)
-            return CSSParserSelector::create(determineNameInNamespace(namespacePrefix, elementName));
-        return CSSParserSelector::create(QualifiedName(nullAtom, elementName, defaultNamespace()));
-    }
+    if (!compoundSelector)
+        return CSSParserSelector::create(determineNameInNamespace(namespacePrefix, elementName));
     prependTypeSelectorIfNeeded(namespacePrefix, elementName, compoundSelector.get());
     return compoundSelector.release();
 }
 
 PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumeSimpleSelector(CSSParserTokenRange& range)
 {
     const CSSParserToken& token = range.peek();
     OwnPtr<CSSParserSelector> selector;
     if (token.type() == HashToken)
         selector = consumeId(range);
     else if (token.type() == DelimiterToken && token.delimiter() == '.')
         selector = consumeClass(range);
     else if (token.type() == LeftBracketToken)
         selector = consumeAttribute(range);
     else if (token.type() == ColonToken)
         selector = consumePseudo(range);
     else
         return nullptr;
     if (!selector)
         m_failedParsing = true;
     return selector.release();
 }
 
-bool CSSSelectorParser::consumeName(CSSParserTokenRange& range, AtomicString& name, AtomicString& namespacePrefix, bool& hasNamespace)
+bool CSSSelectorParser::consumeName(CSSParserTokenRange& range, AtomicString& name, AtomicString& namespacePrefix)
 {
     name = nullAtom;
     namespacePrefix = nullAtom;
-    hasNamespace = false;
 
     const CSSParserToken& firstToken = range.peek();
     if (firstToken.type() == IdentToken) {
         name = firstToken.value();
         range.consume();
     } else if (firstToken.type() == DelimiterToken && firstToken.delimiter() == '*') {
         name = starAtom;
         range.consume();
     } else if (firstToken.type() == DelimiterToken && firstToken.delimiter() == '|') {
-        // No namespace
+        // This is an empty namespace, which'll get assigned this value below
+        name = emptyAtom;
     } else {
         return false;
     }
 
     if (range.peek().type() != DelimiterToken || range.peek().delimiter() != '|')
         return true;
     range.consume();
 
-    hasNamespace = true;
     namespacePrefix = name;
     const CSSParserToken& nameToken = range.consume();
     if (nameToken.type() == IdentToken) {
         name = nameToken.value();
     } else if (nameToken.type() == DelimiterToken && nameToken.delimiter() == '*') {
         name = starAtom;
     } else {
         name = nullAtom;
         namespacePrefix = nullAtom;
         return false;
@@ skipping 35 matching lines @@
 }
 
 PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumeAttribute(CSSParserTokenRange& range)
 {
     ASSERT(range.peek().type() == LeftBracketToken);
     CSSParserTokenRange block = range.consumeBlock();
     block.consumeWhitespace();
 
     AtomicString namespacePrefix;
     AtomicString attributeName;
-    bool hasNamespace;
-    if (!consumeName(block, attributeName, namespacePrefix, hasNamespace))
+    if (!consumeName(block, attributeName, namespacePrefix))
         return nullptr;
     block.consumeWhitespace();
 
     if (m_context.isHTMLDocument())
         attributeName = attributeName.lower();
 
-    QualifiedName qualifiedName = hasNamespace
-        ? determineNameInNamespace(namespacePrefix, attributeName)
-        : QualifiedName(nullAtom, attributeName, nullAtom);
+    QualifiedName qualifiedName = namespacePrefix.isNull()
+        ? QualifiedName(nullAtom, attributeName, nullAtom)
+        : determineNameInNamespace(namespacePrefix, attributeName);
 
     OwnPtr<CSSParserSelector> selector = CSSParserSelector::create();
 
     if (block.atEnd()) {
         selector->setAttribute(qualifiedName, CSSSelector::CaseSensitive);
         selector->setMatch(CSSSelector::AttributeSet);
         return selector.release();
     }
 
     selector->setMatch(consumeAttributeMatch(block));
@@ skipping 259 matching lines @@
         return QualifiedName(prefix, localName, defaultNamespace());
     return QualifiedName(prefix, localName, m_styleSheet->determineNamespace(prefix));
 }
 
 void CSSSelectorParser::prependTypeSelectorIfNeeded(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector* compoundSelector)
 {
     if (elementName.isNull() && defaultNamespace() == starAtom && !compoundSelector->crossesTreeScopes())
         return;
 
     AtomicString determinedElementName = elementName.isNull() ? starAtom : elementName;
-    AtomicString determinedNamespace = namespacePrefix != nullAtom && m_styleSheet ? m_styleSheet->determineNamespace(namespacePrefix) : defaultNamespace();
-    QualifiedName tag(namespacePrefix, determinedElementName, determinedNamespace);
+    QualifiedName tag = determineNameInNamespace(namespacePrefix, determinedElementName);
 
     if (compoundSelector->crossesTreeScopes())
         return rewriteSpecifiersWithElementNameForCustomPseudoElement(tag, compoundSelector, elementName.isNull());
 
     if (compoundSelector->pseudoType() == CSSSelector::PseudoContent)
         return rewriteSpecifiersWithElementNameForContentPseudoElement(tag, compoundSelector, elementName.isNull());
 
     // *:host never matches, so we can't discard the * otherwise we can't tell the
     // difference between *:host and just :host.
     if (tag == anyQName() && !compoundSelector->hasHostPseudoSelector())
@@ skipping 90 matching lines @@
         compoundSelector->insertTagHistory(CSSSelector::SubSelector, simpleSelector, relation);
         return compoundSelector;
     }
 
     // All other simple selectors are added to the end of the compound.
     compoundSelector->appendTagHistory(CSSSelector::SubSelector, simpleSelector);
     return compoundSelector;
 }
 
 } // namespace blink