Serialize namespaced type/* selectors according to CSSOM spec.

third_party/WebKit/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 "core/css/parser/CSSSelectorParser.h"
 
 #include "core/css/CSSSelectorList.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/frame/UseCounter.h"
 #include "platform/RuntimeEnabledFeatures.h"
@@ skipping 290 matching lines @@
         else
             compoundSelector = simpleSelector.release();
     }
 
     if (!compoundSelector) {
         AtomicString namespaceURI = determineNamespace(namespacePrefix);
         if (namespaceURI.isNull()) {
             m_failedParsing = true;
             return nullptr;
         }
+        if (namespaceURI == defaultNamespace())
+            namespacePrefix = nullAtom;
         return CSSParserSelector::create(QualifiedName(namespacePrefix, elementName, namespaceURI));
     }
     prependTypeSelectorIfNeeded(namespacePrefix, elementName, compoundSelector.get());
     return splitCompoundAtImplicitShadowCrossingCombinator(compoundSelector.release());
 }
 
 PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumeSimpleSelector(CSSParserTokenRange& range)
 {
     const CSSParserToken& token = range.peek();
     OwnPtr<CSSParserSelector> selector;
@@ skipping 397 matching lines @@
 {
     if (elementName.isNull() && defaultNamespace() == starAtom && !compoundSelector->needsImplicitShadowCombinatorForMatching())
         return;
 
     AtomicString determinedElementName = elementName.isNull() ? starAtom : elementName;
     AtomicString namespaceURI = determineNamespace(namespacePrefix);
     if (namespaceURI.isNull()) {
         m_failedParsing = true;
         return;
     }
-    QualifiedName tag = QualifiedName(namespacePrefix, determinedElementName, namespaceURI);
+    AtomicString determinedPrefix = namespacePrefix;
+    if (namespaceURI == defaultNamespace())
+        determinedPrefix = nullAtom;
+    QualifiedName tag = QualifiedName(determinedPrefix, determinedElementName, namespaceURI);
 
     // *:host/*:host-context never matches, so we can't discard the *,
     // otherwise we can't tell the difference between *:host and just :host.
     //
     // Also, selectors where we use a ShadowPseudo combinator between the
     // element and the pseudo element for matching (custom pseudo elements,
     // ::cue, ::shadow), we need a universal selector to set the combinator
     // (relation) on in the cases where there are no simple selectors preceding
     // the pseudo element.
-    if (tag != anyQName() || compoundSelector->isHostPseudoSelector() || compoundSelector->needsImplicitShadowCombinatorForMatching())
-        compoundSelector->prependTagSelector(tag, elementName.isNull());
+    bool explicitForHost = compoundSelector->isHostPseudoSelector() && !elementName.isNull();
+    if (tag != anyQName() || explicitForHost || compoundSelector->needsImplicitShadowCombinatorForMatching())
+        compoundSelector->prependTagSelector(tag, determinedPrefix == nullAtom && determinedElementName == starAtom && !explicitForHost);
 }
 
 PassOwnPtr<CSSParserSelector> CSSSelectorParser::addSimpleSelectorToCompound(PassOwnPtr<CSSParserSelector> compoundSelector, PassOwnPtr<CSSParserSelector> simpleSelector)
 {
     compoundSelector->appendTagHistory(CSSSelector::SubSelector, simpleSelector);
     return compoundSelector;
 }
 
 PassOwnPtr<CSSParserSelector> CSSSelectorParser::splitCompoundAtImplicitShadowCrossingCombinator(PassOwnPtr<CSSParserSelector> compoundSelector)
 {
@@ skipping 21 matching lines @@
 
     if (!splitAfter || !splitAfter->tagHistory())
         return compoundSelector;
 
     OwnPtr<CSSParserSelector> secondCompound = splitAfter->releaseTagHistory();
     secondCompound->appendTagHistory(secondCompound->pseudoType() == CSSSelector::PseudoSlotted ? CSSSelector::ShadowSlot : CSSSelector::ShadowPseudo, compoundSelector);
     return secondCompound.release();
 }
 
 } // namespace blink