CSSStyleSheet::insertRule should respect the default namespace

Source/core/css/parser/CSSParserImpl.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/CSSParserImpl.h"
 
 #include "core/css/CSSKeyframesRule.h"
 #include "core/css/CSSStyleSheet.h"
 #include "core/css/StylePropertySet.h"
@@ skipping 12 matching lines @@
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/frame/UseCounter.h"
 #include "platform/TraceEvent.h"
 #include "wtf/BitArray.h"
 
 namespace blink {
 
 CSSParserImpl::CSSParserImpl(const CSSParserContext& context, StyleSheetContents* styleSheet)
 : m_context(context)
-, m_defaultNamespace(starAtom)
 , m_styleSheet(styleSheet)
 , m_observerWrapper(nullptr)
 {
 }
 
 bool CSSParserImpl::parseValue(MutableStylePropertySet* declaration, CSSPropertyID unresolvedProperty, const String& string, bool important, const CSSParserContext& context)
 {
     CSSParserImpl parser(context);
     StyleRule::Type ruleType = StyleRule::Style;
     if (declaration->cssParserMode() == CSSViewportRuleMode)
@@ skipping 337 matching lines @@
     prelude.consumeWhitespace();
     AtomicString namespacePrefix;
     if (prelude.peek().type() == IdentToken)
         namespacePrefix = prelude.consumeIncludingWhitespace().value();
 
     AtomicString uri(consumeStringOrURI(prelude));
     prelude.consumeWhitespace();
     if (uri.isNull() || !prelude.atEnd())
         return nullptr; // Parse error, expected string or URI
 
-    if (namespacePrefix.isNull())
-        m_defaultNamespace = uri;
     return StyleRuleNamespace::create(namespacePrefix, uri);
 }
 
 PassRefPtrWillBeRawPtr<StyleRuleMedia> CSSParserImpl::consumeMediaRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
 {
     WillBeHeapVector<RefPtrWillBeMember<StyleRuleBase>> rules;
 
     if (m_observerWrapper) {
         CSSParserTokenRange preludeWithoutWhitespace = prelude;
         preludeWithoutWhitespace.consumeWhitespace();
@@ skipping 128 matching lines @@
             return nullptr; // Parse error; expected ident token following colon in @page header
         pseudo = prelude.consume().value();
     }
 
     prelude.consumeWhitespace();
     if (!prelude.atEnd())
         return nullptr; // Parse error; extra tokens in @page header
 
     OwnPtr<CSSParserSelector> selector;
     if (!typeSelector.isNull() && pseudo.isNull()) {
-        selector = CSSParserSelector::create(QualifiedName(nullAtom, typeSelector, m_defaultNamespace));
+        selector = CSSParserSelector::create(QualifiedName(nullAtom, typeSelector, m_styleSheet->defaultNamespace()));
     } else {
         selector = CSSParserSelector::create();
         if (!pseudo.isNull()) {
             selector->setMatch(CSSSelector::PagePseudoClass);
             selector->updatePseudoType(pseudo.lower());
             if (selector->pseudoType() == CSSSelector::PseudoUnknown)
                 return nullptr; // Parse error; unknown page pseudo-class
         }
         if (!typeSelector.isNull())
-            selector->prependTagSelector(QualifiedName(nullAtom, typeSelector, m_defaultNamespace));
+            selector->prependTagSelector(QualifiedName(nullAtom, typeSelector, m_styleSheet->defaultNamespace()));
     }
 
     if (m_observerWrapper) {
         unsigned endOffset = m_observerWrapper->endOffset(prelude);
         m_observerWrapper->observer().startRuleHeader(StyleRule::Page, m_observerWrapper->startOffset(prelude));
         m_observerWrapper->observer().endRuleHeader(endOffset);
     }
 
     selector->setForPage();
     Vector<OwnPtr<CSSParserSelector>> selectorVector;
@@ skipping 32 matching lines @@
         wrapper.observer().observeSelector(wrapper.startOffset(selector), wrapper.endOffset(selector));
     }
 
     wrapper.observer().endRuleHeader(wrapper.endOffset(originalRange));
 }
 
 
 PassRefPtrWillBeRawPtr<StyleRule> CSSParserImpl::consumeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
 {
     CSSSelectorList selectorList;
-    CSSSelectorParser::parseSelector(prelude, m_context, m_defaultNamespace, m_styleSheet, selectorList);
+    CSSSelectorParser::parseSelector(prelude, m_context, m_styleSheet, selectorList);
     if (!selectorList.isValid())
         return nullptr; // Parse error, invalid selector list
 
     if (m_observerWrapper)
         observeSelectors(*m_observerWrapper, prelude);
 
     consumeDeclarationList(block, StyleRule::Style);
 
     return StyleRule::create(selectorList, createStylePropertySet(m_parsedProperties, m_context.mode()));
 }
@@ skipping 114 matching lines @@
         else
             return nullptr; // Parser error, invalid value in keyframe selector
         if (range.atEnd())
             return result.release();
         if (range.consume().type() != CommaToken)
             return nullptr; // Parser error
     }
 }
 
 } // namespace blink