CSS Lazy Parsing perf jobs

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 17 matching lines @@
 #include "core/frame/Deprecation.h"
 #include "core/frame/UseCounter.h"
 #include "platform/tracing/TraceEvent.h"
 #include "wtf/PtrUtil.h"
 #include <bitset>
 #include <memory>
 
 namespace blink {
 
 CSSParserImpl::CSSParserImpl(const CSSParserContext& context,
-                             StyleSheetContents* styleSheet)
+                             StyleSheetContents* styleSheet,
+                             bool deferPropertyParsing)
     : m_context(context),
       m_styleSheet(styleSheet),
-      m_observerWrapper(nullptr) {}
+      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;
@@ skipping 133 matching lines @@
   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) {
+                                    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);
+  styleSheet->m_scope = CSSTokenizer::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) {
+      styleSheet->m_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(styleSheet->m_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());
+                   "tokenCount", styleSheet->m_scope.tokenCount(), "length", string.length());
 }
 
 CSSSelectorList CSSParserImpl::parsePageSelector(
     CSSParserTokenRange range,
     StyleSheetContents* styleSheet) {
   // We only support a small subset of the css-page spec.
   range.consumeWhitespace();
   AtomicString typeSelector;
   if (range.peek().type() == IdentToken)
     typeSelector = range.consume().value().toAtomicString();
@@ skipping 528 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 &&
+             shouldLazilyParseProperties(selectorList)) {
+    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 ||
@@ skipping 148 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) {
+  return WTF::bind(&CSSParserImpl::parseDeclarationListForLazyStyle, block,
+                   WTF::unretained(&sheetContext), WTF::unretained(counter));
+}
+
+StylePropertySet* CSSParserImpl::parseDeclarationListForLazyStyle(
+    CSSParserTokenRange 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.
+//
+//  Note: another optimization might be to disallow lazy parsing for rules which
+//  will end up being empty. This is hard to know without parsing but we may be
+//  able to catch the {}, { } cases. This would be to hit
+//  StyleRule::shouldConsiderForMatchingRules more.
+bool CSSParserImpl::shouldLazilyParseProperties(
+    const CSSSelectorList& selectors) {
+  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