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"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRuleImport.h"
 #include "core/css/StyleRuleKeyframe.h"
 #include "core/css/StyleRuleNamespace.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/parser/CSSAtRuleID.h"
+#include "core/css/parser/CSSLazyPropertyParserImpl.h"
 #include "core/css/parser/CSSParserObserver.h"
 #include "core/css/parser/CSSParserObserverWrapper.h"
 #include "core/css/parser/CSSParserSelector.h"
 #include "core/css/parser/CSSPropertyParser.h"
 #include "core/css/parser/CSSSelectorParser.h"
 #include "core/css/parser/CSSSupportsParser.h"
 #include "core/css/parser/CSSTokenizer.h"
 #include "core/css/parser/CSSVariableParser.h"
 #include "core/css/parser/MediaQueryParser.h"
 #include "core/dom/Document.h"
@@ skipping 158 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);
   TRACE_EVENT_END0("blink,blink_style",
                    "CSSParserImpl::parseStyleSheet.tokenize");
 
   TRACE_EVENT_BEGIN0("blink,blink_style",
                      "CSSParserImpl::parseStyleSheet.parse");
   CSSParserImpl parser(context, styleSheet);
+  if (deferPropertyParsing) {
+    parser.m_lazyState =
+        new CSSLazyParsingState(context, scope.releaseEscapedStrings(), string);

[esprehn, 2016/10/24 21:20:21]

std::move(scope.takeEscapedStrings()) ?

[Charlie Harrison, 2016/10/25 15:56:55]

Done.

[Charlie Harrison, 2016/10/25 15:56:55]

Done, but takeEscapedStrings() implies that we're moving them already, so the
std::move() here can be removed.

+  }
   bool firstRuleValid = parser.consumeRuleList(
       scope.tokenRange(), TopLevelRuleList, [&styleSheet](StyleRuleBase* rule) {
         if (rule->isCharsetRule())
           return;
         styleSheet->parserAppendRule(rule);
       });
   styleSheet->setHasSyntacticallyValidCSSHeader(firstRuleValid);
   TRACE_EVENT_END0("blink,blink_style", "CSSParserImpl::parseStyleSheet.parse");
 
   TRACE_EVENT_END2("blink,blink_style", "CSSParserImpl::parseStyleSheet",
@@ skipping 105 matching lines @@
   CSSTokenizer::Scope scope(string, wrapper);
   bool firstRuleValid = parser.consumeRuleList(
       scope.tokenRange(), TopLevelRuleList, [&styleSheet](StyleRuleBase* rule) {
         if (rule->isCharsetRule())
           return;
         styleSheet->parserAppendRule(rule);
       });
   styleSheet->setHasSyntacticallyValidCSSHeader(firstRuleValid);
 }
 
+StylePropertySet* CSSParserImpl::parseDeclarationListForLazyStyle(
+    CSSParserTokenRange block,
+    const CSSParserContext& context) {
+  CSSParserImpl parser(context);
+  parser.consumeDeclarationList(std::move(block), StyleRule::Style);
+  return createStylePropertySet(parser.m_parsedProperties, context.mode());
+}
+
 static CSSParserImpl::AllowedRulesType computeNewAllowedRules(
     CSSParserImpl::AllowedRulesType allowedRules,
     StyleRuleBase* rule) {
   if (!rule || allowedRules == CSSParserImpl::KeyframeRules ||
       allowedRules == CSSParserImpl::NoRules)
     return allowedRules;
   ASSERT(allowedRules <= CSSParserImpl::RegularRules);
   if (rule->isCharsetRule() || rule->isImportRule())
     return CSSParserImpl::AllowImportRules;
   if (rule->isNamespaceRule())
@@ skipping 414 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_lazyState &&
+             m_lazyState->shouldLazilyParseProperties(selectorList)) {
+    DCHECK(m_styleSheet);
+    return StyleRule::createLazy(
+        std::move(selectorList),
+        new CSSLazyPropertyParserImpl(block, m_lazyState));
+  }
   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 149 matching lines @@
     else
       return nullptr;  // Parser error, invalid value in keyframe selector
     if (range.atEnd())
       return result;
     if (range.consume().type() != CommaToken)
       return nullptr;  // Parser error
   }
 }
 
 }  // namespace blink