Changeset 114217 in webkit


Ignore:
Timestamp:
Apr 15, 2012 7:40:23 PM (12 years ago)
Author:
Antti Koivisto
Message:

Capture CSS parser context
​https://bugs.webkit.org/show_bug.cgi?id=83998

Source/WebCore:

Reviewed by Andreas Kling.

Currently the CSS parser calls to the Document and StyleSheetInternal objects to get settings, base URL etc.
The required information should be passed in on parser construction instead. The parser should not need to
know about the document at all.

The patch adds CSSParserContext struct that captures the parsing context. StyleSheetInternal saves the
parsing context and reuses it for any further parsing.

If the same stylesheet source is parsed with an identical context then the resulting stylesheet structure will
be identical. This will allow sharing parsed stylesheets in the future.

  • css/CSSGrammar.y:
  • css/CSSImportRule.cpp:

(WebCore::StyleRuleImport::setCSSStyleSheet):

  • css/CSSMediaRule.cpp:

(WebCore::CSSMediaRule::insertRule):

  • css/CSSPageRule.cpp:

(WebCore::CSSPageRule::setSelectorText):

  • css/CSSParser.cpp:

(WebCore):
(WebCore::strictCSSParserContext):
(WebCore::CSSParserContext::CSSParserContext):
(WebCore::CSSParser::CSSParser):
(WebCore::CSSParser::parseKeyframeRule):
(WebCore::CSSParser::parseValue):
(WebCore::CSSParser::parseSelector):
(WebCore::CSSParser::completeURL):
(WebCore::CSSParser::parseContent):
(WebCore::CSSParser::parseAttr):
(WebCore::CSSParser::parseFillImage):
(WebCore::CSSParser::parseFontFaceSrcURI):
(WebCore::CSSParser::parseFontFaceSrc):
(WebCore::CSSParser::parseBorderImage):
(WebCore::CSSParser::parseImageSet):
(WebCore::CSSParser::parseCustomFilter):
(WebCore::CSSParser::parseFilter):
(WebCore::CSSParser::cssRegionsEnabled):
(WebCore::CSSParser::parseFlowThread):
(WebCore::CSSParser::createMediaRule):
(WebCore::CSSParser::createStyleRule):
(WebCore::CSSParser::createFontFaceRule):
(WebCore::CSSParser::createPageRule):
(WebCore::CSSParser::createKeyframe):

  • css/CSSParser.h:

(CSSParser):
(WebCore::CSSParser::inStrictMode):
(WebCore::CSSParser::inQuirksMode):
(WebCore::CSSParser::validUnit):

  • css/CSSParserMode.h:

(WebCore):
(CSSParserContext):

  • css/CSSRule.h:

(WebCore::CSSRule::parserContext):
(CSSRule):

  • css/CSSStyleRule.cpp:

(WebCore::CSSStyleRule::setSelectorText):

  • css/CSSStyleSheet.cpp:

(WebCore::StyleSheetInternal::StyleSheetInternal):
(WebCore::StyleSheetInternal::parseString):
(WebCore::StyleSheetInternal::parseStringAtLine):
(WebCore):
(WebCore::StyleSheetInternal::updateBaseURL):
(WebCore::StyleSheetInternal::completeURL):
(WebCore::CSSStyleSheet::insertRule):

  • css/CSSStyleSheet.h:

(StyleSheetInternal):
(WebCore::StyleSheetInternal::parserContext):
(WebCore::StyleSheetInternal::charset):
(WebCore::StyleSheetInternal::setFinalURL):
(WebCore::StyleSheetInternal::baseURL):

  • css/CSSValuePool.cpp:
  • css/StylePropertySet.cpp:

(WebCore::StylePropertySet::parseDeclaration):

  • css/WebKitCSSKeyframesRule.cpp:

(WebCore::WebKitCSSKeyframesRule::insertRule):

  • dom/Document.cpp:

(WebCore::Document::webkitGetFlowByName):
(WebCore::Document::pageUserSheet):
(WebCore::Document::pageGroupUserSheets):

  • dom/Element.cpp:

(WebCore::Element::webkitMatchesSelector):

  • dom/Node.cpp:

(WebCore::Node::querySelector):
(WebCore::Node::querySelectorAll):

  • dom/ProcessingInstruction.cpp:

(WebCore::ProcessingInstruction::parseStyleSheet):

  • dom/StyleElement.cpp:

(WebCore::StyleElement::createSheet):

  • html/HTMLLinkElement.cpp:

(WebCore::HTMLLinkElement::setCSSStyleSheet):

  • html/shadow/ContentSelectorQuery.cpp:

(WebCore::ContentSelectorQuery::ContentSelectorQuery):

  • inspector/InspectorStyleSheet.cpp:

(WebCore::InspectorStyle::setPropertyText):
(WebCore::InspectorStyleSheet::reparseStyleSheet):
(WebCore::InspectorStyleSheet::ensureSourceData):
(WebCore::InspectorStyleSheetForInlineStyle::getStyleAttributeRanges):

LayoutTests:

Reviewed by Andreas Kling.

Modify the tests so that they don't expect settings changes to apply to already existing stylesheets.

  • css3/filters/script-tests/custom-filter-property-parsing.js:
  • fast/regions/script-tests/css-regions-disabled.js:
Location:
trunk
Files:
27 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r114212 r114217  
     12012-04-15  Antti Koivisto  <antti@apple.com>
     2
     3        Capture CSS parser context
     4        https://bugs.webkit.org/show_bug.cgi?id=83998
     5
     6        Reviewed by Andreas Kling.
     7       
     8        Modify the tests so that they don't expect settings changes to apply to already existing stylesheets.
     9
     10        * css3/filters/script-tests/custom-filter-property-parsing.js:
     11        * fast/regions/script-tests/css-regions-disabled.js:
     12
    1132012-04-15  Raphael Kubo da Costa  <rakuco@webkit.org>
    214

  • trunk/LayoutTests/css3/filters/script-tests/custom-filter-property-parsing.js

    r111610 r114217  
    3333}
    3434
     35var styleElement = document.createElement("style");
     36document.head.appendChild(styleElement);
     37
    3538// These have to be global for the test helpers to see them.
    36 var stylesheet, cssRule, declaration, filterRule, subRule;
     39var cssRule, declaration, filterRule, subRule;
     40var stylesheet = styleElement.sheet;
    3741
    3842function testFilterRule(description, rule, expectedValue, expectedTypes, expectedTexts)
    … …  
    4145    debug(description + " : " + rule);
    4246
    43     stylesheet = document.styleSheets.item(0);
    4447    stylesheet.insertRule("body { -webkit-filter: " + rule + "; }", 0);
    4548    cssRule = stylesheet.cssRules.item(0);

  • trunk/LayoutTests/fast/regions/script-tests/css-regions-disabled.js

    r109015 r114217  
    6565
    6666// Test that region styling rules are not parsed.
    67 stylesheet = document.styleSheets.item(0);
     67var styleElement = document.createElement("style");
     68document.head.appendChild(styleElement);
     69var stylesheet = styleElement.sheet;
    6870webkitRegionRuleIndex = -1;
    6971try {

  • trunk/Source/WebCore/ChangeLog

    r114216 r114217  
     12012-04-15  Antti Koivisto  <antti@apple.com>
     2
     3        Capture CSS parser context
     4        https://bugs.webkit.org/show_bug.cgi?id=83998
     5
     6        Reviewed by Andreas Kling.
     7
     8        Currently the CSS parser calls to the Document and StyleSheetInternal objects to get settings, base URL etc.
     9        The required information should be passed in on parser construction instead. The parser should not need to
     10        know about the document at all.
     11       
     12        The patch adds CSSParserContext struct that captures the parsing context. StyleSheetInternal saves the
     13        parsing context and reuses it for any further parsing.
     14       
     15        If the same stylesheet source is parsed with an identical context then the resulting stylesheet structure will
     16        be identical. This will allow sharing parsed stylesheets in the future.
     17
     18        * css/CSSGrammar.y:
     19        * css/CSSImportRule.cpp:
     20        (WebCore::StyleRuleImport::setCSSStyleSheet):
     21        * css/CSSMediaRule.cpp:
     22        (WebCore::CSSMediaRule::insertRule):
     23        * css/CSSPageRule.cpp:
     24        (WebCore::CSSPageRule::setSelectorText):
     25        * css/CSSParser.cpp:
     26        (WebCore):
     27        (WebCore::strictCSSParserContext):
     28        (WebCore::CSSParserContext::CSSParserContext):
     29        (WebCore::CSSParser::CSSParser):
     30        (WebCore::CSSParser::parseKeyframeRule):
     31        (WebCore::CSSParser::parseValue):
     32        (WebCore::CSSParser::parseSelector):
     33        (WebCore::CSSParser::completeURL):
     34        (WebCore::CSSParser::parseContent):
     35        (WebCore::CSSParser::parseAttr):
     36        (WebCore::CSSParser::parseFillImage):
     37        (WebCore::CSSParser::parseFontFaceSrcURI):
     38        (WebCore::CSSParser::parseFontFaceSrc):
     39        (WebCore::CSSParser::parseBorderImage):
     40        (WebCore::CSSParser::parseImageSet):
     41        (WebCore::CSSParser::parseCustomFilter):
     42        (WebCore::CSSParser::parseFilter):
     43        (WebCore::CSSParser::cssRegionsEnabled):
     44        (WebCore::CSSParser::parseFlowThread):
     45        (WebCore::CSSParser::createMediaRule):
     46        (WebCore::CSSParser::createStyleRule):
     47        (WebCore::CSSParser::createFontFaceRule):
     48        (WebCore::CSSParser::createPageRule):
     49        (WebCore::CSSParser::createKeyframe):
     50        * css/CSSParser.h:
     51        (CSSParser):
     52        (WebCore::CSSParser::inStrictMode):
     53        (WebCore::CSSParser::inQuirksMode):
     54        (WebCore::CSSParser::validUnit):
     55        * css/CSSParserMode.h:
     56        (WebCore):
     57        (CSSParserContext):
     58        * css/CSSRule.h:
     59        (WebCore::CSSRule::parserContext):
     60        (CSSRule):
     61        * css/CSSStyleRule.cpp:
     62        (WebCore::CSSStyleRule::setSelectorText):
     63        * css/CSSStyleSheet.cpp:
     64        (WebCore::StyleSheetInternal::StyleSheetInternal):
     65        (WebCore::StyleSheetInternal::parseString):
     66        (WebCore::StyleSheetInternal::parseStringAtLine):
     67        (WebCore):
     68        (WebCore::StyleSheetInternal::updateBaseURL):
     69        (WebCore::StyleSheetInternal::completeURL):
     70        (WebCore::CSSStyleSheet::insertRule):
     71        * css/CSSStyleSheet.h:
     72        (StyleSheetInternal):
     73        (WebCore::StyleSheetInternal::parserContext):
     74        (WebCore::StyleSheetInternal::charset):
     75        (WebCore::StyleSheetInternal::setFinalURL):
     76        (WebCore::StyleSheetInternal::baseURL):
     77        * css/CSSValuePool.cpp:
     78        * css/StylePropertySet.cpp:
     79        (WebCore::StylePropertySet::parseDeclaration):
     80        * css/WebKitCSSKeyframesRule.cpp:
     81        (WebCore::WebKitCSSKeyframesRule::insertRule):
     82        * dom/Document.cpp:
     83        (WebCore::Document::webkitGetFlowByName):
     84        (WebCore::Document::pageUserSheet):
     85        (WebCore::Document::pageGroupUserSheets):
     86        * dom/Element.cpp:
     87        (WebCore::Element::webkitMatchesSelector):
     88        * dom/Node.cpp:
     89        (WebCore::Node::querySelector):
     90        (WebCore::Node::querySelectorAll):
     91        * dom/ProcessingInstruction.cpp:
     92        (WebCore::ProcessingInstruction::parseStyleSheet):
     93        * dom/StyleElement.cpp:
     94        (WebCore::StyleElement::createSheet):
     95        * html/HTMLLinkElement.cpp:
     96        (WebCore::HTMLLinkElement::setCSSStyleSheet):
     97        * html/shadow/ContentSelectorQuery.cpp:
     98        (WebCore::ContentSelectorQuery::ContentSelectorQuery):
     99        * inspector/InspectorStyleSheet.cpp:
     100        (WebCore::InspectorStyle::setPropertyText):
     101        (WebCore::InspectorStyleSheet::reparseStyleSheet):
     102        (WebCore::InspectorStyleSheet::ensureSourceData):
     103        (WebCore::InspectorStyleSheetForInlineStyle::getStyleAttributeRanges):
     104
    11052012-04-15  Noel Gordon  <noel.gordon@gmail.com>
    2106

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

    r114168 r114217  
    10021002        CSSParserString& str = $1;
    10031003        CSSParser* p = static_cast<CSSParser*>(parser);
    1004         Document* doc = p->findDocument();
    1005         if (doc && doc->isHTMLDocument())
     1004        if (p->m_context.isHTMLDocument)
    10061005            str.lower();
    10071006        $$ = str;
    … …  
    10341033        $$ = p->createFloatingSelector();
    10351034        $$->setMatch(CSSSelector::Id);
    1036         if (p->m_cssParserMode == CSSQuirksMode)
     1035        if (p->m_context.mode == CSSQuirksMode)
    10371036            $1.lower();
    10381037        $$->setValue($1);
    … …  
    10451044            $$ = p->createFloatingSelector();
    10461045            $$->setMatch(CSSSelector::Id);
    1047             if (p->m_cssParserMode == CSSQuirksMode)
     1046            if (p->m_context.mode == CSSQuirksMode)
    10481047                $1.lower();
    10491048            $$->setValue($1);
    … …  
    10601059        $$ = p->createFloatingSelector();
    10611060        $$->setMatch(CSSSelector::Class);
    1062         if (p->m_cssParserMode == CSSQuirksMode)
     1061        if (p->m_context.mode == CSSQuirksMode)
    10631062            $2.lower();
    10641063        $$->setValue($2);
    … …  
    10701069        CSSParserString& str = $1;
    10711070        CSSParser* p = static_cast<CSSParser*>(parser);
    1072         Document* doc = p->findDocument();
    1073         if (doc && doc->isHTMLDocument())
     1071        if (p->m_context.isHTMLDocument)
    10741072            str.lower();
    10751073        $$ = str;

  • trunk/Source/WebCore/css/CSSImportRule.cpp

    r114006 r114217  
    6868    bool crossOriginCSS = false;
    6969    bool validMIMEType = false;
    70     CSSParserMode cssParserMode = m_parentStyleSheet ? m_parentStyleSheet->cssParserMode() : CSSStrictMode;
     70    CSSParserMode cssParserMode = m_parentStyleSheet ? m_parentStyleSheet->parserContext().mode : CSSStrictMode;
    7171    bool enforceMIMEType = isStrictParserMode(cssParserMode);
    7272    Document* document = m_parentStyleSheet ? m_parentStyleSheet->findDocument() : 0;
    … …  
    8282
    8383    String sheetText = sheet->sheetText(enforceMIMEType, &validMIMEType);
    84     m_styleSheet->parseString(sheetText, cssParserMode);
     84    m_styleSheet->parseString(sheetText);
    8585
    8686    if (!document || !document->securityOrigin()->canRequest(baseURL))

  • trunk/Source/WebCore/css/CSSMediaRule.cpp

    r113922 r114217  
    5959    }
    6060
     61    CSSParser parser(parserContext());
    6162    CSSStyleSheet* styleSheet = parentStyleSheet();
    62     CSSParser parser(styleSheet ? styleSheet->internal()->cssParserMode() : CSSStrictMode);
    6363    RefPtr<StyleRuleBase> newRule = parser.parseRule(styleSheet ? styleSheet->internal() : 0, ruleString);
    6464    if (!newRule) {

  • trunk/Source/WebCore/css/CSSPageRule.cpp

    r112923 r114217  
    7272        return;
    7373   
    74     CSSParser p;
     74    CSSParser parser(parserContext());
    7575    CSSSelectorList selectorList;
    76     p.parseSelector(selectorText, doc, selectorList);
     76    parser.parseSelector(selectorText, selectorList);
    7777    if (!selectorList.first())
    7878        return;

  • trunk/Source/WebCore/css/CSSParser.cpp

    r114020 r114217  
    22 * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
    33 * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
    4  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
     4 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
    55 * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
    66 * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
    … …  
    7878#include "StylePropertyShorthand.h"
    7979#include "StyleRule.h"
     80#include "TextEncoding.h"
    8081#if ENABLE(CSS_FILTERS)
    8182#include "WebKitCSSFilterValue.h"
    … …  
    174175    return false;
    175176}
    176 
    177 CSSParser::CSSParser(CSSParserMode cssParserMode)
    178     : m_cssParserMode(cssParserMode)
     177   
     178const CSSParserContext& strictCSSParserContext()
     179{
     180    DEFINE_STATIC_LOCAL(CSSParserContext, strictContext, (CSSStrictMode));
     181    return strictContext;
     182}
     183   
     184CSSParserContext::CSSParserContext(CSSParserMode mode)
     185    : mode(mode)
     186    , isHTMLDocument(false)
     187    , isCSSCustomFilterEnabled(false)
     188    , isCSSRegionsEnabled(false)
     189{
     190}
     191
     192CSSParserContext::CSSParserContext(Document* document)
     193    : baseURL(document->baseURL())
     194    , mode(document->inQuirksMode() ? CSSQuirksMode : CSSStrictMode)
     195    , isHTMLDocument(document->isHTMLDocument())
     196    , isCSSCustomFilterEnabled(document->settings() ? document->settings()->isCSSCustomFilterEnabled() : false)
     197    , isCSSRegionsEnabled(document->cssRegionsEnabled())
     198{
     199}
     200
     201CSSParser::CSSParser(const CSSParserContext& context)
     202    : m_context(context)
    179203    , m_important(false)
    180204    , m_id(CSSPropertyInvalid)
    … …  
    281305}
    282306
    283 PassRefPtr<StyleKeyframe> CSSParser::parseKeyframeRule(StyleSheetInternal* sheet, const String &string)
     307PassRefPtr<StyleKeyframe> CSSParser::parseKeyframeRule(StyleSheetInternal* sheet, const String& string)
    284308{
    285309    setStyleSheet(sheet);
    … …  
    933957    if (parseKeywordValue(declaration, propertyID, string, important))
    934958        return true;
    935     CSSParser parser(cssParserMode);
     959
     960    CSSParserContext context(cssParserMode);
     961    if (contextStyleSheet) {
     962        context = contextStyleSheet->parserContext();
     963        context.mode = cssParserMode;
     964    }
     965    CSSParser parser(context);
    936966    return parser.parseValue(declaration, propertyID, string, important, contextStyleSheet);
    937967}
    … …  
    10131043}
    10141044
    1015 void CSSParser::parseSelector(const String& string, Document* doc, CSSSelectorList& selectorList)
    1016 {
    1017     RefPtr<StyleSheetInternal> dummyStyleSheet = StyleSheetInternal::create(doc);
    1018 
     1045void CSSParser::parseSelector(const String& string, CSSSelectorList& selectorList)
     1046{
     1047    RefPtr<StyleSheetInternal> dummyStyleSheet = StyleSheetInternal::create();
    10191048    setStyleSheet(dummyStyleSheet.get());
    10201049    m_selectorListForParseSelector = &selectorList;
    … …  
    11121141}
    11131142
    1114 Document* CSSParser::findDocument() const
    1115 {
    1116     if (!m_styleSheet)
    1117         return 0;
    1118     return m_styleSheet->findDocument();
     1143KURL CSSParser::completeURL(const CSSParserContext& context, const String& url)
     1144{
     1145    if (url.isNull())
     1146        return KURL();
     1147    if (context.charset.isEmpty())
     1148        return KURL(context.baseURL, url);
     1149    return KURL(context.baseURL, url, context.charset);
     1150}
     1151
     1152KURL CSSParser::completeURL(const String& url) const
     1153{
     1154    return completeURL(m_context, url);
    11191155}
    11201156
    … …  
    15761612                hotSpot = IntPoint(coords[0], coords[1]);
    15771613
    1578             if (!uri.isNull() && m_styleSheet) {
    1579                 // FIXME: The completeURL call should be done when using the CSSCursorImageValue,
    1580                 // not when creating it.
    1581                 list->append(CSSCursorImageValue::create(m_styleSheet->completeURL(uri), hotSpot));
    1582             }
     1614            if (!uri.isNull())
     1615                list->append(CSSCursorImageValue::create(completeURL(uri), hotSpot));
    15831616
    15841617            if ((inStrictMode() && !value) || (value && !(value->unit == CSSParserValue::Operator && value->iValue == ',')))
    … …  
    16611694            m_valueList->next();
    16621695        } else if (value->unit == CSSPrimitiveValue::CSS_URI) {
    1663             if (m_styleSheet) {
    1664                 // FIXME: The completeURL call should be done when using the CSSImageValue,
    1665                 // not when creating it.
    1666                 parsedValue = CSSImageValue::create(m_styleSheet->completeURL(value->string));
    1667                 m_valueList->next();
    1668             }
     1696            parsedValue = CSSImageValue::create(completeURL(value->string));
     1697            m_valueList->next();
    16691698        } else if (isGeneratedImageValue(value)) {
    16701699            if (parseGeneratedImage(m_valueList.get(), parsedValue))
    … …  
    30253054    while (CSSParserValue* val = m_valueList->current()) {
    30263055        RefPtr<CSSValue> parsedValue;
    3027         if (val->unit == CSSPrimitiveValue::CSS_URI && m_styleSheet) {
     3056        if (val->unit == CSSPrimitiveValue::CSS_URI) {
    30283057            // url
    3029             // FIXME: The completeURL call should be done when using the CSSImageValue,
    3030             // not when creating it.
    3031             parsedValue = CSSImageValue::create(m_styleSheet->completeURL(val->string));
     3058            parsedValue = CSSImageValue::create(completeURL(val->string));
    30323059        } else if (val->unit == CSSParserValue::Function) {
    30333060            // attr(X) | counter(X [,Y]) | counters(X, Y, [,Z]) | -webkit-gradient(...)
    … …  
    31113138        return 0;
    31123139
    3113     Document* document = findDocument();
    3114     if (document && document->isHTMLDocument())
     3140    if (m_context.isHTMLDocument)
    31153141        attrName = attrName.lower();
    31163142
    … …  
    31343160    }
    31353161    if (valueList->current()->unit == CSSPrimitiveValue::CSS_URI) {
    3136         // FIXME: The completeURL call should be done when using the CSSImageValue,
    3137         // not when creating it.
    3138         if (m_styleSheet)
    3139             value = CSSImageValue::create(m_styleSheet->completeURL(valueList->current()->string));
     3162        value = CSSImageValue::create(completeURL(valueList->current()->string));
    31403163        return true;
    31413164    }
    … …  
    46194642bool CSSParser::parseFontFaceSrcURI(CSSValueList* valueList)
    46204643{
    4621     // FIXME: The completeURL call should be done when using the CSSFontFaceSrcValue,
    4622     // not when creating it.
    4623     RefPtr<CSSFontFaceSrcValue> uriValue(CSSFontFaceSrcValue::create(m_styleSheet->completeURL(m_valueList->current()->string)));
     4644    RefPtr<CSSFontFaceSrcValue> uriValue(CSSFontFaceSrcValue::create(completeURL(m_valueList->current()->string)));
    46244645
    46254646    CSSParserValue* value = m_valueList->next();
    … …  
    46834704
    46844705    while (CSSParserValue* value = m_valueList->current()) {
    4685         if (value->unit == CSSPrimitiveValue::CSS_URI && m_styleSheet) {
     4706        if (value->unit == CSSPrimitiveValue::CSS_URI) {
    46864707            if (!parseFontFaceSrcURI(values.get()))
    46874708                return false;
    … …  
    56695690
    56705691        if (!context.canAdvance() && context.allowImage()) {
    5671             if (val->unit == CSSPrimitiveValue::CSS_URI && m_styleSheet) {
    5672                 // FIXME: The completeURL call should be done when using the CSSImageValue,
    5673                 // not when creating it.
    5674                 context.commitImage(CSSImageValue::create(m_styleSheet->completeURL(val->string)));
    5675             } else if (isGeneratedImageValue(val)) {
     5692            if (val->unit == CSSPrimitiveValue::CSS_URI)
     5693                context.commitImage(CSSImageValue::create(completeURL(val->string)));
     5694            else if (isGeneratedImageValue(val)) {
    56765695                RefPtr<CSSValue> value;
    56775696                if (parseGeneratedImage(m_valueList.get(), value))
    … …  
    67386757            return 0;
    67396758
    6740         RefPtr<CSSImageValue> image = CSSImageValue::create(m_styleSheet->completeURL(arg->string));
     6759        RefPtr<CSSImageValue> image = CSSImageValue::create(completeURL(arg->string));
    67416760        imageSet->append(image);
    67426761   
    … …  
    70217040            value = cssValuePool().createIdentifierValue(CSSValueNone);
    70227041        else if (arg->unit == CSSPrimitiveValue::CSS_URI) {
    7023             KURL shaderURL = m_styleSheet ? m_styleSheet->completeURL(arg->string) : KURL();
     7042            KURL shaderURL = completeURL(arg->string);
    70247043            value = WebKitCSSShaderValue::create(shaderURL.string());
    70257044            hadAtLeastOneCustomShader = true;
    … …  
    72417260            if (filterType == WebKitCSSFilterValue::CustomFilterOperation) {
    72427261                // Make sure parsing fails if custom filters are disabled.
    7243                 if (Document* document = findDocument()) {
    7244                     Settings* settings = document->settings();
    7245                     if (!settings || !settings->isCSSCustomFilterEnabled())
    7246                         return 0;
    7247                 }
     7262                if (!m_context.isCSSCustomFilterEnabled)
     7263                    return 0;
    72487264               
    72497265                RefPtr<WebKitCSSFilterValue> filterValue = parseCustomFilter(value);
    … …  
    72817297bool CSSParser::cssRegionsEnabled() const
    72827298{
    7283     if (Document* document = findDocument())
    7284         return document->cssRegionsEnabled();
    7285 
    7286     return false;
    7287 }
    7288 
    7289 bool CSSParser::parseFlowThread(const String& flowName, Document* doc)
    7290 {
    7291     ASSERT(doc);
    7292     ASSERT(doc->cssRegionsEnabled());
    7293 
    7294     RefPtr<StyleSheetInternal> dummyStyleSheet = StyleSheetInternal::create(doc);
     7299    return m_context.isCSSRegionsEnabled;
     7300}
     7301
     7302bool CSSParser::parseFlowThread(const String& flowName)
     7303{
     7304    RefPtr<StyleSheetInternal> dummyStyleSheet = StyleSheetInternal::create();
    72957305    setStyleSheet(dummyStyleSheet.get());
    72967306
    … …  
    90229032StyleRuleBase* CSSParser::createMediaRule(MediaQuerySet* media, RuleList* rules)
    90239033{
    9024     if (!media || !rules || !m_styleSheet)
     9034    if (!media || !rules)
    90259035        return 0;
    90269036    m_allowImportRules = m_allowNamespaceDeclarations = false;
    … …  
    90599069        if (m_hasFontFaceOnlyValues)
    90609070            deleteFontFaceOnlyValues();
    9061         rule->setProperties(StylePropertySet::create(m_parsedProperties.data(), m_parsedProperties.size(), m_cssParserMode));
     9071        rule->setProperties(StylePropertySet::create(m_parsedProperties.data(), m_parsedProperties.size(), m_context.mode));
    90629072        result = rule.get();
    90639073        m_parsedRules.append(rule.release());
    … …  
    90959105    }
    90969106    RefPtr<StyleRuleFontFace> rule = StyleRuleFontFace::create();
    9097     rule->setProperties(StylePropertySet::create(m_parsedProperties.data(), m_parsedProperties.size(), m_cssParserMode));
     9107    rule->setProperties(StylePropertySet::create(m_parsedProperties.data(), m_parsedProperties.size(), m_context.mode));
    90989108    clearProperties();
    90999109    StyleRuleFontFace* result = rule.get();
    … …  
    91669176        selectorVector.append(pageSelector);
    91679177        rule->parserAdoptSelectorVector(selectorVector);
    9168         rule->setProperties(StylePropertySet::create(m_parsedProperties.data(), m_parsedProperties.size(), m_cssParserMode));
     9178        rule->setProperties(StylePropertySet::create(m_parsedProperties.data(), m_parsedProperties.size(), m_context.mode));
    91699179        pageRule = rule.get();
    91709180        m_parsedRules.append(rule.release());
    … …  
    92449254    RefPtr<StyleKeyframe> keyframe = StyleKeyframe::create();
    92459255    keyframe->setKeyText(keyString);
    9246     keyframe->setProperties(StylePropertySet::create(m_parsedProperties.data(), m_parsedProperties.size(), m_cssParserMode));
     9256    keyframe->setProperties(StylePropertySet::create(m_parsedProperties.data(), m_parsedProperties.size(), m_context.mode));
    92479257
    92489258    clearProperties();

  • trunk/Source/WebCore/css/CSSParser.h

    r113922 r114217  
    6767class CSSParser {
    6868public:
    69     CSSParser(CSSParserMode = CSSStrictMode);
     69    CSSParser(const CSSParserContext&);
    7070
    7171    ~CSSParser();
    … …  
    8282    PassOwnPtr<MediaQuery> parseMediaQuery(const String&);
    8383
    84     Document* findDocument() const;
    85 
    8684    void addProperty(CSSPropertyID, PassRefPtr<CSSValue>, bool important, bool implicit = false);
    8785    void rollbackLastProperties(int num);
    … …  
    156154    PassRefPtr<CSSPrimitiveValue> parseColor(CSSParserValue* = 0);
    157155    bool parseColorFromValue(CSSParserValue*, RGBA32&);
    158     void parseSelector(const String&, Document* doc, CSSSelectorList&);
     156    void parseSelector(const String&, CSSSelectorList&);
    159157
    160158    static bool fastParseColor(RGBA32&, const String&, bool strict);
    … …  
    222220
    223221    bool cssRegionsEnabled() const;
    224     bool parseFlowThread(const String& flowName, Document*);
     222    bool parseFlowThread(const String& flowName);
    225223    bool parseFlowThread(CSSPropertyID, bool important);
    226224    bool parseRegionThread(CSSPropertyID, bool important);
    … …  
    284282    void clearProperties();
    285283
    286     CSSParserMode m_cssParserMode;
     284    CSSParserContext m_context;
     285
    287286    bool m_important;
    288287    CSSPropertyID m_id;
    … …  
    327326    PassRefPtr<CSSPrimitiveValue> createPrimitiveNumericValue(CSSParserValue*);
    328327    PassRefPtr<CSSPrimitiveValue> createPrimitiveStringValue(CSSParserValue*);
    329        
     328
     329    static KURL completeURL(const CSSParserContext&, const String& url);
     330
    330331private:
    331332    inline bool isIdentifierStart();
    … …  
    348349    void setStyleSheet(StyleSheetInternal*);
    349350
    350     inline bool inStrictMode() const { return m_cssParserMode == CSSStrictMode || m_cssParserMode == SVGAttributeMode; }
    351     inline bool inQuirksMode() const { return m_cssParserMode == CSSQuirksMode; }
     351    inline bool inStrictMode() const { return m_context.mode == CSSStrictMode || m_context.mode == SVGAttributeMode; }
     352    inline bool inQuirksMode() const { return m_context.mode == CSSQuirksMode; }
     353   
     354    KURL completeURL(const String& url) const;
    352355
    353356    void recheckAtKeyword(const UChar* str, int len);
    … …  
    441444    bool shouldAcceptUnitLessValues(CSSParserValue*, Units, CSSParserMode);
    442445
    443     inline bool validUnit(CSSParserValue* value, Units unitflags) { return validUnit(value, unitflags, m_cssParserMode); }
     446    inline bool validUnit(CSSParserValue* value, Units unitflags) { return validUnit(value, unitflags, m_context.mode); }
    444447    bool validUnit(CSSParserValue*, Units, CSSParserMode);
    445448

  • trunk/Source/WebCore/css/CSSParserMode.h

    r112769 r114217  
    11/*
    22 * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
     3 * Copyright (C) 2012 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    3132#define CSSParserMode_h
    3233
     34#include "KURL.h"
     35
     36namespace WebCore {
     37
     38class Document;
     39
    3340enum CSSParserMode {
    3441    CSSQuirksMode,
    … …  
    4855}
    4956
     57struct CSSParserContext {
     58    CSSParserContext(CSSParserMode);
     59    CSSParserContext(Document*);
     60
     61    KURL baseURL;
     62    String charset;
     63    CSSParserMode mode;
     64    bool isHTMLDocument;
     65    bool isCSSCustomFilterEnabled;
     66    bool isCSSRegionsEnabled;
     67};
     68
     69const CSSParserContext& strictCSSParserContext();
     70
     71};
     72
    5073#endif // CSSParserMode_h

  • trunk/Source/WebCore/css/CSSRule.h

    r113922 r114217  
    111111    void setHasCachedSelectorText(bool hasCachedSelectorText) const { m_hasCachedSelectorText = hasCachedSelectorText; }
    112112
     113    const CSSParserContext& parserContext() const
     114    {
     115        CSSStyleSheet* styleSheet = parentStyleSheet();
     116        return styleSheet ? styleSheet->internal()->parserContext() : strictCSSParserContext();
     117    }
     118
    113119private:
    114120    mutable unsigned m_hasCachedSelectorText : 1;

  • trunk/Source/WebCore/css/CSSStyleRule.cpp

    r113099 r114217  
    9898        return;
    9999
    100     CSSParser p;
     100    CSSParser p(parserContext());
    101101    CSSSelectorList selectorList;
    102     p.parseSelector(selectorText, doc, selectorList);
     102    p.parseSelector(selectorText, selectorList);
    103103    if (!selectorList.first())
    104104        return;

  • trunk/Source/WebCore/css/CSSStyleSheet.cpp

    r114168 r114217  
    3939#include "StylePropertySet.h"
    4040#include "StyleRule.h"
    41 #include "TextEncoding.h"
    4241#include <wtf/Deque.h>
    4342
    … …  
    8079    , m_originalURL(originalURL)
    8180    , m_finalURL(finalURL)
    82     , m_charset(charset)
    8381    , m_loadCompleted(false)
    84     , m_cssParserMode(CSSQuirksMode)
    8582    , m_isUserStyleSheet(false)
    8683    , m_hasSyntacticallyValidCSSHeader(true)
    8784    , m_didLoadErrorOccur(false)
    8885    , m_usesRemUnits(false)
     86    , m_parserContext(parentNode->document())
    8987{
    9088    ASSERT(isAcceptableCSSStyleSheetParent(parentNode));
     89
     90    updateBaseURL();
     91    m_parserContext.charset = charset;
    9192}
    9293
    … …  
    9697    , m_originalURL(originalURL)
    9798    , m_finalURL(finalURL)
    98     , m_charset(charset)
    9999    , m_loadCompleted(false)
    100     , m_cssParserMode((ownerRule && ownerRule->parentStyleSheet()) ? ownerRule->parentStyleSheet()->cssParserMode() : CSSStrictMode)
    101100    , m_hasSyntacticallyValidCSSHeader(true)
    102101    , m_didLoadErrorOccur(false)
    103102    , m_usesRemUnits(false)
     103    , m_parserContext((ownerRule && ownerRule->parentStyleSheet()) ? ownerRule->parentStyleSheet()->parserContext() : CSSStrictMode)
    104104{
    105105    StyleSheetInternal* parentSheet = ownerRule ? ownerRule->parentStyleSheet() : 0;
    106     m_isUserStyleSheet = parentSheet ? parentSheet->isUserStyleSheet() : false;
     106    m_isUserStyleSheet = parentSheet && parentSheet->isUserStyleSheet();
     107
     108    updateBaseURL();
     109    m_parserContext.charset = charset;
    107110}
    108111
    … …  
    264267}
    265268
    266 bool StyleSheetInternal::parseString(const String &string, CSSParserMode cssParserMode)
    267 {
    268     return parseStringAtLine(string, cssParserMode, 0);
    269 }
    270 
    271 bool StyleSheetInternal::parseStringAtLine(const String& string, CSSParserMode cssParserMode, int startLineNumber)
    272 {
    273     setCSSParserMode(cssParserMode);
    274     CSSParser p(cssParserMode);
     269bool StyleSheetInternal::parseString(const String &string)
     270{
     271    return parseStringAtLine(string, 0);
     272}
     273
     274bool StyleSheetInternal::parseStringAtLine(const String& string, int startLineNumber)
     275{
     276    CSSParser p(parserContext());
    275277    p.parseSheet(this, string, startLineNumber);
    276278    return true;
    … …  
    354356        documentToUpdate->styleSelectorChanged(DeferRecalcStyle);
    355357}
    356    
    357 KURL StyleSheetInternal::baseURL() const
    358 {
    359     if (!m_finalURL.isNull())
    360         return m_finalURL;
    361     if (StyleSheetInternal* parentSheet = parentStyleSheet())
    362         return parentSheet->baseURL();
    363     if (!m_ownerNode)
    364         return KURL();
    365     return m_ownerNode->document()->baseURL();
     358
     359void StyleSheetInternal::updateBaseURL()
     360{
     361    if (!m_finalURL.isNull()) {
     362        m_parserContext.baseURL = m_finalURL;
     363        return;
     364    }
     365    if (StyleSheetInternal* parentSheet = parentStyleSheet()) {
     366        m_parserContext.baseURL = parentSheet->baseURL();
     367        return;
     368    }
     369    if (m_ownerNode) {
     370        m_parserContext.baseURL = m_ownerNode->document()->baseURL();
     371        return;
     372    }
     373    m_parserContext.baseURL = KURL();
    366374}
    367375
    368376KURL StyleSheetInternal::completeURL(const String& url) const
    369377{
    370     // Always return a null URL when passed a null string.
    371     // FIXME: Should we change the KURL constructor to have this behavior?
    372     // See also Document::completeURL(const String&)
    373     if (url.isNull())
    374         return KURL();
    375     if (m_charset.isEmpty())
    376         return KURL(baseURL(), url);
    377     const TextEncoding encoding = TextEncoding(m_charset);
    378     return KURL(baseURL(), url, encoding);
     378    return CSSParser::completeURL(m_parserContext, url);
    379379}
    380380
    … …  
    483483        return 0;
    484484    }
    485     CSSParser p(m_internal->cssParserMode());
     485    CSSParser p(m_internal->parserContext());
    486486    RefPtr<StyleRuleBase> rule = p.parseRule(m_internal.get(), ruleString);
    487487

  • trunk/Source/WebCore/css/CSSStyleSheet.h

    r114168 r114217  
    6767
    6868    ~StyleSheetInternal();
     69   
     70    const CSSParserContext& parserContext() const { return m_parserContext; }
    6971
    7072    void addNamespace(CSSParser*, const AtomicString& prefix, const AtomicString& uri);
    … …  
    7375    void styleSheetChanged();
    7476
    75     bool parseString(const String&, CSSParserMode = CSSStrictMode);
    76 
    77     bool parseStringAtLine(const String&, CSSParserMode, int startLineNumber);
     77    bool parseString(const String&);
     78
     79    bool parseStringAtLine(const String&, int startLineNumber);
    7880
    7981    bool isLoading() const;
    … …  
    8587    Document* findDocument();
    8688
    87     const String& charset() const { return m_charset; }
     89    const String& charset() const { return m_parserContext.charset; }
    8890
    8991    bool loadCompleted() const { return m_loadCompleted; }
    … …  
    9193    KURL completeURL(const String& url) const;
    9294    void addSubresourceStyleURLs(ListHashSet<KURL>&);
    93 
    94     void setCSSParserMode(CSSParserMode cssParserMode) { m_cssParserMode = cssParserMode; }
    95     CSSParserMode cssParserMode() const { return m_cssParserMode; }
    9695
    9796    void setIsUserStyleSheet(bool b) { m_isUserStyleSheet = b; }
    … …  
    128127    void setTitle(const String& title) { m_title = title; }
    129128   
    130     void setFinalURL(const KURL& finalURL) { m_finalURL = finalURL; }
     129    void setFinalURL(const KURL& finalURL) { m_finalURL = finalURL; updateBaseURL(); }
    131130    const KURL& finalURL() const { return m_finalURL; }
    132     KURL baseURL() const;
     131    const KURL& baseURL() const { return m_parserContext.baseURL; }
    133132
    134133    unsigned ruleCount() const;
    … …  
    147146    void clearCharsetRule();
    148147    bool hasCharsetRule() const { return !m_encodingFromCharsetRule.isNull(); }
     148   
     149    void updateBaseURL();
    149150
    150151    Node* m_ownerNode;
    … …  
    159160    Vector<RefPtr<StyleRuleBase> > m_childRules;
    160161    OwnPtr<CSSNamespace> m_namespaces;
    161     String m_charset;
    162162    RefPtr<MediaQuerySet> m_mediaQueries;
    163163
    164164    bool m_loadCompleted : 1;
    165     CSSParserMode m_cssParserMode;
    166165    bool m_isUserStyleSheet : 1;
    167166    bool m_hasSyntacticallyValidCSSHeader : 1;
    168167    bool m_didLoadErrorOccur : 1;
    169168    bool m_usesRemUnits : 1;
     169   
     170    CSSParserContext m_parserContext;
    170171};
    171172

  • trunk/Source/WebCore/css/CSSValuePool.cpp

    r113922 r114217  
    2828
    2929#include "CSSParser.h"
     30#include "CSSStyleSheet.h"
    3031#include "CSSValueKeywords.h"
    3132#include "CSSValueList.h"

  • trunk/Source/WebCore/css/StylePropertySet.cpp

    r114207 r114217  
    537537{
    538538    m_properties.clear();
    539     CSSParser parser(cssParserMode());
     539
     540    CSSParserContext context(cssParserMode());
     541    if (contextStyleSheet) {
     542        context = contextStyleSheet->parserContext();
     543        context.mode = cssParserMode();
     544    }
     545    CSSParser parser(context);
    540546    parser.parseDeclaration(this, styleDeclaration, 0, contextStyleSheet);
    541547}

  • trunk/Source/WebCore/css/WebKitCSSKeyframesRule.cpp

    r113922 r114217  
    110110    ASSERT(m_childRuleCSSOMWrappers.size() == m_keyframesRule->keyframes().size());
    111111
     112    CSSParser parser(parserContext());
    112113    CSSStyleSheet* styleSheet = parentStyleSheet();
    113     CSSParser parser(styleSheet ? styleSheet->internal()->cssParserMode() : CSSStrictMode);
    114114    RefPtr<StyleKeyframe> keyframe = parser.parseKeyframeRule(styleSheet ? styleSheet->internal() : 0, ruleText);
    115115    if (!keyframe)

  • trunk/Source/WebCore/dom/Document.cpp

    r114189 r114217  
    10881088
    10891089        // Make a slower check for invalid flow name.
    1090         CSSParser parser(CSSStrictMode);
    1091         if (!parser.parseFlowThread(flowName, this))
     1090        CSSParser parser(document());
     1091        if (!parser.parseFlowThread(flowName))
    10921092            return 0;
    10931093    }
    … …  
    27172717    m_pageUserSheet = StyleSheetInternal::createInline(this, settings()->userStyleSheetLocation());
    27182718    m_pageUserSheet->setIsUserStyleSheet(true);
    2719     m_pageUserSheet->parseString(userSheetText, strictToCSSParserMode(!inQuirksMode()));
     2719    m_pageUserSheet->parseString(userSheetText);
    27202720    return m_pageUserSheet.get();
    27212721}
    … …  
    27632763            RefPtr<StyleSheetInternal> parsedSheet = StyleSheetInternal::createInline(const_cast<Document*>(this), sheet->url());
    27642764            parsedSheet->setIsUserStyleSheet(sheet->level() == UserStyleUserLevel);
    2765             parsedSheet->parseString(sheet->source(), strictToCSSParserMode(!inQuirksMode()));
     2765            parsedSheet->parseString(sheet->source());
    27662766            if (!m_pageGroupUserSheets)
    27672767                m_pageGroupUserSheets = adoptPtr(new Vector<RefPtr<StyleSheetInternal> >);

  • trunk/Source/WebCore/dom/Element.cpp

    r114189 r114217  
    17571757        return false;
    17581758    }
    1759 
    1760     bool strictParsing = !document()->inQuirksMode();
    1761     CSSParser p(strictToCSSParserMode(strictParsing));
    1762 
     1759    CSSParserContext parserContext(document());
     1760    CSSParser parser(parserContext);
    17631761    CSSSelectorList selectorList;
    1764     p.parseSelector(selector, document(), selectorList);
     1762    parser.parseSelector(selector, selectorList);
    17651763
    17661764    if (!selectorList.first()) {
    … …  
    17751773    }
    17761774
    1777     SelectorChecker selectorChecker(document(), strictParsing);
     1775    SelectorChecker selectorChecker(document(), parserContext.mode == CSSStrictMode);
    17781776    for (CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(selector)) {
    17791777        if (selectorChecker.checkSelector(selector, this))

  • trunk/Source/WebCore/dom/Node.cpp

    r113897 r114217  
    16711671        return 0;
    16721672    }
    1673     bool strictParsing = !document()->inQuirksMode();
    1674     CSSParser p(strictToCSSParserMode(strictParsing));
    1675 
     1673    CSSParser parser(document());
    16761674    CSSSelectorList querySelectorList;
    1677     p.parseSelector(selectors, document(), querySelectorList);
     1675    parser.parseSelector(selectors, querySelectorList);
    16781676
    16791677    if (!querySelectorList.first() || querySelectorList.hasUnknownPseudoElements()) {
    … …  
    16981696        return 0;
    16991697    }
    1700     bool strictParsing = !document()->inQuirksMode();
    1701     CSSParser p(strictToCSSParserMode(strictParsing));
    1702 
     1698    CSSParser p(document());
    17031699    CSSSelectorList querySelectorList;
    1704     p.parseSelector(selectors, document(), querySelectorList);
     1700    p.parseSelector(selectors, querySelectorList);
    17051701
    17061702    if (!querySelectorList.first() || querySelectorList.hasUnknownPseudoElements()) {

  • trunk/Source/WebCore/dom/ProcessingInstruction.cpp

    r113925 r114217  
    236236{
    237237    if (m_isCSS)
    238         static_cast<CSSStyleSheet*>(m_sheet.get())->internal()->parseString(sheet, CSSStrictMode);
     238        static_cast<CSSStyleSheet*>(m_sheet.get())->internal()->parseString(sheet);
    239239#if ENABLE(XSLT)
    240240    else if (m_isXSL)

  • trunk/Source/WebCore/dom/StyleElement.cpp

    r113922 r114217  
    170170            m_loading = true;
    171171            RefPtr<StyleSheetInternal> styleSheet = StyleSheetInternal::create(e, String(), KURL(), document->inputEncoding());
    172             styleSheet->parseStringAtLine(text, strictToCSSParserMode(!document->inQuirksMode()), startLineNumber);
     172            styleSheet->parseStringAtLine(text, startLineNumber);
    173173            styleSheet->setMediaQueries(mediaQueries.release());
    174174            styleSheet->setTitle(e->title());

  • trunk/Source/WebCore/html/HTMLLinkElement.cpp

    r113922 r114217  
    312312
    313313    String sheetText = sheet->sheetText(enforceMIMEType, &validMIMEType);
    314     styleSheet->parseString(sheetText, strictToCSSParserMode(strictParsing));
     314    styleSheet->parseString(sheetText);
    315315
    316316    // If we're loading a stylesheet cross-origin, and the MIME type is not

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

    r112537 r114217  
    4545    }
    4646
    47     CSSParser parser(CSSStrictMode);
    48     parser.parseSelector(insertionPoint->select(), insertionPoint->document(), m_selectorList);
     47    CSSParser parser(insertionPoint->document());
     48    parser.parseSelector(insertionPoint->select(), m_selectorList);
    4949
    5050    m_isValidSelector = ContentSelectorQuery::validateSelectorList();

  • trunk/Source/WebCore/inspector/InspectorStyleSheet.cpp

    r113922 r114217  
    314314        RefPtr<StylePropertySet> tempMutableStyle = StylePropertySet::create();
    315315        RefPtr<CSSStyleSourceData> sourceData = CSSStyleSourceData::create();
    316         CSSParser p;
     316        CSSParser p(CSSStrictMode);
    317317        p.parseDeclaration(tempMutableStyle.get(), propertyText + " " + bogusPropertyName + ": none", &sourceData, m_style->parentStyleSheet()->internal());
    318318        Vector<CSSPropertySourceData>& propertyData = sourceData->propertyData;
    … …  
    720720{
    721721    m_pageStyleSheet->internal()->clearRules();
    722     m_pageStyleSheet->internal()->parseString(text, m_pageStyleSheet->internal()->cssParserMode());
     722    m_pageStyleSheet->internal()->parseString(text);
    723723    m_pageStyleSheet->clearChildRuleCSSOMWrappers();
    724724    m_pageStyleSheet->styleSheetChanged();
    … …  
    10901090
    10911091    RefPtr<StyleSheetInternal> newStyleSheet = StyleSheetInternal::create();
    1092     CSSParser p;
     1092    CSSParser p(CSSStrictMode);
    10931093    StyleRuleRangeMap ruleRangeMap;
    10941094    p.parseSheet(newStyleSheet.get(), m_parsedStyleSheet->text(), 0, &ruleRangeMap);
    … …  
    14151415
    14161416    RefPtr<StylePropertySet> tempDeclaration = StylePropertySet::create();
    1417     CSSParser p;
     1417    CSSParser p(m_element->document());
    14181418    p.parseDeclaration(tempDeclaration.get(), m_styleText, result, m_element->document()->elementSheet()->internal());
    14191419    return true;

  • trunk/Source/WebKit/chromium/src/WebDocument.cpp

    r113922 r114217  
    181181    RefPtr<StyleSheetInternal> parsedSheet = StyleSheetInternal::create(document.get());
    182182    parsedSheet->setIsUserStyleSheet(level == UserStyleUserLevel);
    183     parsedSheet->parseString(sourceCode, strictToCSSParserMode(!document->inQuirksMode()));
     183    parsedSheet->parseString(sourceCode);
    184184    document->addUserSheet(parsedSheet.release());
    185185}
Note: See TracChangeset for help on using the changeset viewer.