CSSStyleSheet::insertRule should respect the default namespace

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 32 matching lines @@
                 break;
             }
             if (feature != UseCounter::NumberOfFeatures)
                 context.useCounter()->count(feature);
             if (current->selectorList())
                 recordSelectorStats(context, *current->selectorList());
         }
     }
 }
 
-void CSSSelectorParser::parseSelector(CSSParserTokenRange range, const CSSParserContext& context, const AtomicString& defaultNamespace, StyleSheetContents* styleSheet, CSSSelectorList& output)
+void CSSSelectorParser::parseSelector(CSSParserTokenRange range, const CSSParserContext& context, StyleSheetContents* styleSheet, CSSSelectorList& output)
 {
-    CSSSelectorParser parser(context, defaultNamespace, styleSheet);
+    CSSSelectorParser parser(context, styleSheet);
     range.consumeWhitespace();
     CSSSelectorList result;
     parser.consumeComplexSelectorList(range, result);
     if (range.atEnd()) {
         output.adopt(result);
         recordSelectorStats(context, output);
     }
     ASSERT(!(output.isValid() && parser.m_failedParsing));
 }
 
-CSSSelectorParser::CSSSelectorParser(const CSSParserContext& context, const AtomicString& defaultNamespace, StyleSheetContents* styleSheet)
+CSSSelectorParser::CSSSelectorParser(const CSSParserContext& context, StyleSheetContents* styleSheet)
 : m_context(context)
-, m_defaultNamespace(defaultNamespace)
 , m_styleSheet(styleSheet)
 , m_failedParsing(false)
 {
 }
 
 void CSSSelectorParser::consumeComplexSelectorList(CSSParserTokenRange& range, CSSSelectorList& output)
 {
     Vector<OwnPtr<CSSParserSelector>> selectorList;
     OwnPtr<CSSParserSelector> selector = consumeComplexSelector(range);
     if (!selector)
@@ skipping 76 matching lines @@
     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, m_defaultNamespace));
+        return CSSParserSelector::create(QualifiedName(nullAtom, elementName, defaultNamespace()));
     }
     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)
@@ skipping 353 matching lines @@
     if (b.type() != NumberToken || b.numericValueType() != IntegerValueType)
         return false;
     if ((b.numericSign() == NoSign) == (sign == NoSign))
         return false;
     result.second = b.numericValue();
     if (sign == MinusSign)
         result.second = -result.second;
     return true;
 }
 
+const AtomicString& CSSSelectorParser::defaultNamespace() const
+{
+    if (!m_styleSheet)
+        return starAtom;
+    return m_styleSheet->defaultNamespace();
+}
+
 QualifiedName CSSSelectorParser::determineNameInNamespace(const AtomicString& prefix, const AtomicString& localName)
 {
     if (!m_styleSheet)
-        return QualifiedName(prefix, localName, m_defaultNamespace);
+        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() && m_defaultNamespace == starAtom && !compoundSelector->crossesTreeScopes())
+    if (elementName.isNull() && defaultNamespace() == starAtom && !compoundSelector->crossesTreeScopes())
         return;
 
     AtomicString determinedElementName = elementName.isNull() ? starAtom : elementName;
-    AtomicString determinedNamespace = namespacePrefix != nullAtom && m_styleSheet ? m_styleSheet->determineNamespace(namespacePrefix) : m_defaultNamespace;
+    AtomicString determinedNamespace = namespacePrefix != nullAtom && m_styleSheet ? m_styleSheet->determineNamespace(namespacePrefix) : defaultNamespace();
     QualifiedName tag(namespacePrefix, determinedElementName, determinedNamespace);
 
     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.
@@ skipping 91 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