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)
-: m_context(context)
-, m_styleSheet(styleSheet)
-, m_observerWrapper(nullptr)
+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 476 matching lines @@
             selectors.consumeComponentValue();
         CSSParserTokenRange selector = selectors.makeSubRange(selectorStart, &selectors.peek());
         selectors.consumeIncludingWhitespace();
 
         wrapper.observer().observeSelector(wrapper.startOffset(selector), wrapper.endOffset(selector));
     }
 
     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 && shouldLazilyParseProperties(selectorList, block)) {
+        DCHECK(m_styleSheet);
+        return StyleRule::createLazy(std::move(selectorList), createDeferredPropertiesClosure(block, m_styleSheet->parserContext(), m_context.useCounter()));
+    }
     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.
+std::unique_ptr<DeferredPropertiesClosure> CSSParserImpl::createDeferredPropertiesClosure(CSSParserTokenRange block, const CSSParserContext& sheetContext, UseCounter* counter)
+{
+    // Note: there may be optimizations to be had in allocating so many Vectors
+    // to store the token copies. One idea is to allocate a large Vector in
+    // parseStyleSheet and immediately free it, so we don't go through the slow
+    // path in PartitionAlloc.
+    Vector<CSSParserToken, 0u> tokens;
+
+    // Reserve capacity to minimize heap bloat.
+    size_t length = block.end() - block.begin();
+    tokens.reserveCapacity(length);
+    tokens.append(block.begin(), length);
+
+    return WTF::bind(&CSSParserImpl::parseDeclarationListForLazyStyle, WTF::passed(std::move(tokens)), WTF::unretained(&sheetContext), WTF::unretained(counter));
+}
+
+StylePropertySet* CSSParserImpl::parseDeclarationListForLazyStyle(Vector<CSSParserToken> block, const CSSParserContext* sheetContext, UseCounter* counter)
+{
+    CSSParserContext context(*sheetContext, counter);
+    CSSParserImpl parser(context);
+    parser.consumeDeclarationList(block, StyleRule::Style);
+    return createStylePropertySet(parser.m_parsedProperties, context.mode());
+}
+
+//  Disallow lazy parsing for blocks which have
+//  - before/after in their selector list. This ensures we don't cause a
+//  collectFeatures() when we trigger parsing for attr() functions which would
+//  trigger expensive invalidation propagation.
+//  - Empty property sets (so that emptiness can be established without forcing
+//  a strict point.
+bool CSSParserImpl::shouldLazilyParseProperties(const CSSSelectorList& selectors, CSSParserTokenRange block)

[Timothy Loh, 2016/09/27 05:15:45]

Could just be static and not on CSSParserImpl I guess

[Charlie Harrison, 2016/09/27 13:22:01]

Do you mean in an anonymous namespace? It's already static.

+{
+    if (static_cast<size_t>(block.end() - block.begin()) == 0)

[Timothy Loh, 2016/09/27 05:15:45]

if (block.atEnd()), but see other comment.

[Charlie Harrison, 2016/09/27 13:22:01]

Deleted this code.

+        return false;
+    for (const auto* s = selectors.first(); s; s = CSSSelectorList::next(*s)) {
+        const CSSSelector::PseudoType type(s->getPseudoType());
+        if (type == CSSSelector::PseudoBefore || type == CSSSelector::PseudoAfter)
+            return false;
+    }
+    return true;
+}
+
 } // namespace blink