[WIP] Streaming CSS parser

third_party/WebKit/Source/core/css/parser/CSSLazyParsingState.cpp

 // Copyright 2016 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/CSSLazyParsingState.h"
 #include "core/css/parser/CSSLazyPropertyParserImpl.h"
 #include "core/css/parser/CSSParserTokenRange.h"
 #include "core/dom/Document.h"
 #include "core/frame/UseCounter.h"
 #include "platform/Histogram.h"
 
 namespace blink {
 
 CSSLazyParsingState::CSSLazyParsingState(const CSSParserContext& context,
-                                         Vector<String> escapedStrings,
                                          const String& sheetText,
                                          StyleSheetContents* contents)
     : m_context(context),
-      m_escapedStrings(std::move(escapedStrings)),
       m_sheetText(sheetText),
       m_owningContents(contents),
       m_parsedStyleRules(0),
       m_totalStyleRules(0),
       m_styleRulesNeededForNextMilestone(0),
       m_usage(UsageGe0),
       m_shouldUseCount(!!m_context.useCounter()) {
   recordUsageMetrics();
 }
 
 CSSLazyPropertyParserImpl* CSSLazyParsingState::createLazyParser(
-    const CSSParserTokenRange& block) {
+    size_t blockOffset) {
   ++m_totalStyleRules;
-  return new CSSLazyPropertyParserImpl(std::move(block), this);
+  return new CSSLazyPropertyParserImpl(blockOffset, this);
 }
 
 const CSSParserContext& CSSLazyParsingState::context() {
   DCHECK(m_owningContents);
   if (!m_shouldUseCount) {
     DCHECK(!m_context.useCounter());
     return m_context;
   }
 
   // Try as best as possible to grab a valid UseCounter if the underlying
@@ skipping 12 matching lines @@
 void CSSLazyParsingState::countRuleParsed() {
   ++m_parsedStyleRules;
   while (m_parsedStyleRules > m_styleRulesNeededForNextMilestone) {
     DCHECK_NE(UsageAll, m_usage);
     ++m_usage;
     recordUsageMetrics();
   }
 }
 
 bool CSSLazyParsingState::shouldLazilyParseProperties(
-    const CSSSelectorList& selectors,
-    const CSSParserTokenRange& block) const {
-  // Simple heuristic for an empty block. Note that |block| here does not
-  // include {} brackets. We avoid lazy parsing empty blocks so we can avoid
-  // considering them when possible for matching. Lazy blocks must always be
-  // considered. Three tokens is a reasonable minimum for a block:
-  // ident ':' <value>.
-  if (block.end() - block.begin() <= 2)
-    return false;
-
+    const CSSSelectorList& selectors) const {
   //  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.
   for (const auto* s = selectors.first(); s; s = CSSSelectorList::next(*s)) {
     for (const CSSSelector* current = s; current;
          current = current->tagHistory()) {
       const CSSSelector::PseudoType type(current->getPseudoType());
       if (type == CSSSelector::PseudoBefore || type == CSSSelector::PseudoAfter)
         return false;
@@ skipping 33 matching lines @@
 
   usageHistogram.count(m_usage);
 }
 
 DEFINE_TRACE(CSSLazyParsingState) {
   visitor->trace(m_owningContents);
   visitor->trace(m_document);
 }
 
 }  // namespace blink