Lazy Parse CSS

third_party/WebKit/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 "core/css/parser/CSSParserImpl.h"
 
 #include "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSCustomPropertyDeclaration.h"
 #include "core/css/CSSKeyframesRule.h"
 #include "core/css/CSSStyleSheet.h"
@@ skipping 16 matching lines @@
 #include "core/dom/Element.h"
 #include "core/frame/Deprecation.h"
 #include "core/frame/UseCounter.h"
 #include "platform/TraceEvent.h"
 #include "wtf/PtrUtil.h"
 #include <bitset>
 #include <memory>
 
 namespace blink {
 
-CSSParserImpl::CSSParserImpl(const CSSParserContext& context, StyleSheetContents* styleSheet)
+CSSParserImpl::CSSParserImpl(const CSSParserContext& context, StyleSheetContents* styleSheet, bool deferPropertyParsing)
 : m_context(context)
 , m_styleSheet(styleSheet)
 , m_observerWrapper(nullptr)
+, m_deferPropertyParsing(deferPropertyParsing)
 {
 }
 
 bool CSSParserImpl::parseValue(MutableStylePropertySet* declaration, CSSPropertyID unresolvedProperty, const String& string, bool important, const CSSParserContext& context)
 {
     CSSParserImpl parser(context);
     StyleRule::RuleType ruleType = StyleRule::Style;
     if (declaration->cssParserMode() == CSSViewportRuleMode)
         ruleType = StyleRule::Viewport;
     CSSTokenizer::Scope scope(string);
@@ skipping 101 matching lines @@
     else
         rule = parser.consumeQualifiedRule(range, allowedRules);
     if (!rule)
         return nullptr; // Parse error, failed to consume rule
     range.consumeWhitespace();
     if (!rule || !range.atEnd())
         return nullptr; // Parse error, trailing garbage
     return rule;
 }
 
-void CSSParserImpl::parseStyleSheet(const String& string, const CSSParserContext& context, StyleSheetContents* styleSheet)
+void CSSParserImpl::parseStyleSheet(const String& string, const CSSParserContext& context, StyleSheetContents* styleSheet, bool deferPropertyParsing)
 {
     TRACE_EVENT_BEGIN2(
         "blink,blink_style", "CSSParserImpl::parseStyleSheet",
         "baseUrl", context.baseURL().getString().utf8(),
         "mode", context.mode());
 
     TRACE_EVENT_BEGIN0("blink,blink_style", "CSSParserImpl::parseStyleSheet.tokenize");
     CSSTokenizer::Scope scope(string);
     TRACE_EVENT_END0("blink,blink_style", "CSSParserImpl::parseStyleSheet.tokenize");
 
     TRACE_EVENT_BEGIN0("blink,blink_style", "CSSParserImpl::parseStyleSheet.parse");
-    CSSParserImpl parser(context, styleSheet);
+    CSSParserImpl parser(context, styleSheet, deferPropertyParsing);
     bool firstRuleValid = parser.consumeRuleList(scope.tokenRange(), TopLevelRuleList, [&styleSheet](StyleRuleBase* rule) {
         if (rule->isCharsetRule())
             return;
         styleSheet->parserAppendRule(rule);
     });
     styleSheet->setHasSyntacticallyValidCSSHeader(firstRuleValid);
+
+    // For lazy parsing the owning contents requires ownership of strings the
+    // scope allocates.
+    if (deferPropertyParsing)
+        styleSheet->takeEscapedStrings(scope.releaseEscapedStrings());
+
     TRACE_EVENT_END0("blink,blink_style", "CSSParserImpl::parseStyleSheet.parse");
 
     TRACE_EVENT_END2(
         "blink,blink_style", "CSSParserImpl::parseStyleSheet",
         "tokenCount", scope.tokenCount(),
         "length", string.length());
 }
 
 CSSSelectorList CSSParserImpl::parsePageSelector(CSSParserTokenRange range, StyleSheetContents* styleSheet)
 {
@@ skipping 483 matching lines @@
     wrapper.observer().endRuleHeader(wrapper.endOffset(originalRange));
 }
 
 
 StyleRule* CSSParserImpl::consumeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
 {
     CSSSelectorList selectorList = CSSSelectorParser::parseSelector(prelude, m_context, m_styleSheet);
     if (!selectorList.isValid())
         return nullptr; // Parse error, invalid selector list
 
-    if (m_observerWrapper)
+    // TODO(csharrison): How should we lazily parse css that needs the observer?
+    if (m_observerWrapper) {
         observeSelectors(*m_observerWrapper, prelude);
+    } else if (m_deferPropertyParsing) {
+        DCHECK(m_styleSheet);
+        bool forceStrict = false;
+        StyleRule* rule = StyleRule::createLazy(std::move(selectorList), createDeferredPropertiesClosure(block, m_context, &forceStrict));
+        if (forceStrict)
+            rule->properties();
+        return rule;
+    }
 
     consumeDeclarationList(block, StyleRule::Style);
-
     return StyleRule::create(std::move(selectorList), createStylePropertySet(m_parsedProperties, m_context.mode()));
 }
 
 void CSSParserImpl::consumeDeclarationList(CSSParserTokenRange range, StyleRule::RuleType ruleType)
 {
     ASSERT(m_parsedProperties.isEmpty());
 
     bool useObserver = m_observerWrapper && (ruleType == StyleRule::Style || ruleType == StyleRule::Keyframe);
     if (useObserver) {
         m_observerWrapper->observer().startRuleBody(m_observerWrapper->previousTokenStartOffset(range));
@@ skipping 114 matching lines @@
             result->append(1);
         else
             return nullptr; // Parser error, invalid value in keyframe selector
         if (range.atEnd())
             return result;
         if (range.consume().type() != CommaToken)
             return nullptr; // Parser error
     }
 }
 
+// The closure created here must not outlive the underlying StyleSheetContents,
+// as it has non retaining references to the strings backing the tokens, as
+// well as the parser context.
+// Sets forceStrict to true if we should bail out on lazy parsing. This occurs
+// for:
+//  - attr() functions (which require invalidation set propogation)
+//  - Empty property sets (so that emptiness can be established without forcing
+//  a strict point in general.
+std::unique_ptr<CSSParser::DeferredPropertiesClosure> CSSParserImpl::createDeferredPropertiesClosure(CSSParserTokenRange block, const CSSParserContext& context, bool* forceStrict)
+{
+    // TODO(csharrison): A slightly more complex design could have the
+    // StyleSheetContents own the tokens. This would mean we don't have to copy
+    // them to a local vector here.
+    size_t length = block.end() - block.begin();
+    std::unique_ptr<Vector<CSSParserToken>> tokens = WTF::wrapUnique(new Vector<CSSParserToken>);
+    tokens->reserveInitialCapacity(length);
+    while (!block.atEnd()) {
+        const CSSParserToken& token = block.consume();
+        if (token.type() == CSSParserTokenType::FunctionToken && token.value() == "attr") {

[Timothy Loh, 2016/09/26 05:18:00]

I think attr is case insensitive.

[Charlie Harrison, 2016/09/26 22:14:45]

I've moved the check to checking "before/after" in selectors which is faster and
simplifies this method.

+            *forceStrict = true;
+        }
+        tokens->append(token);

[Timothy Loh, 2016/09/26 05:18:01]

Probably nicer to use Vector::append(const U*, size_t) and copy the entire range
at once (looking at the VectorCopier code, I think just does a memcpy).

[Charlie Harrison, 2016/09/26 22:14:45]

Cool :) Done.

+    }
+    if (tokens->isEmpty())
+        *forceStrict = true;
+
+    return WTF::bind(&CSSParserImpl::parseDeclarationListForLazyStyle, WTF::passed(std::move(tokens)), WTF::unretained(&context));
+}
+
+StylePropertySet* CSSParserImpl::parseDeclarationListForLazyStyle(std::unique_ptr<Vector<CSSParserToken>> block, const CSSParserContext* context)
+{
+    CSSParserImpl parser(*context);
+    parser.consumeDeclarationList(*block, StyleRule::Style);
+    return createStylePropertySet(parser.m_parsedProperties, context->mode());
+}
+
+
 } // namespace blink