[WIP] Streaming CSS parser

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/PropertyRegistry.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/CSSLazyParsingState.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"
 #include "core/dom/Element.h"
 #include "core/frame/Deprecation.h"
 #include "core/frame/UseCounter.h"
 #include "platform/instrumentation/tracing/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) {}
+    : m_context(context), m_styleSheet(styleSheet) {}
 
 MutableStylePropertySet::SetResult 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)
@@ skipping 99 matching lines @@
     const String& string,
     Element* element) {
   Document& document = element->document();
   CSSParserContext context =
       CSSParserContext(document.elementSheet().contents()->parserContext(),
                        UseCounter::getFrom(&document));
   CSSParserMode mode = element->isHTMLElement() && !document.inQuirksMode()
                            ? HTMLStandardMode
                            : HTMLQuirksMode;
   context.setMode(mode);
+  CSSTokenizer tokenizer(string);
+  CSSParserTokenStream stream(tokenizer);
   CSSParserImpl parser(context, document.elementSheet().contents());
-  CSSTokenizer tokenizer(string);
-  parser.consumeDeclarationList(tokenizer.tokenRange(), StyleRule::Style);
+  parser.consumeDeclarationList(stream, StyleRule::Style);
   return createStylePropertySet(parser.m_parsedProperties, mode);
 }
 
 bool CSSParserImpl::parseDeclarationList(MutableStylePropertySet* declaration,
                                          const String& string,
                                          const CSSParserContext& context) {
   CSSParserImpl parser(context);
   StyleRule::RuleType ruleType = StyleRule::Style;
   if (declaration->cssParserMode() == CSSViewportRuleMode)
     ruleType = StyleRule::Viewport;
   CSSTokenizer tokenizer(string);
-  parser.consumeDeclarationList(tokenizer.tokenRange(), ruleType);
+  CSSParserTokenStream stream(tokenizer);
+  parser.consumeDeclarationList(stream, ruleType);
   if (parser.m_parsedProperties.isEmpty())
     return false;
 
   std::bitset<numCSSProperties> seenProperties;
   size_t unusedEntries = parser.m_parsedProperties.size();
   HeapVector<CSSProperty, 256> results(unusedEntries);
   HashSet<AtomicString> seenCustomProperties;
   filterProperties(true, parser.m_parsedProperties, results, unusedEntries,
                    seenProperties, seenCustomProperties);
   filterProperties(false, parser.m_parsedProperties, results, unusedEntries,
                    seenProperties, seenCustomProperties);
   if (unusedEntries)
     results.remove(0, unusedEntries);
   return declaration->addParsedProperties(results);
 }
 
 StyleRuleBase* CSSParserImpl::parseRule(const String& string,
                                         const CSSParserContext& context,
                                         StyleSheetContents* styleSheet,
                                         AllowedRulesType allowedRules) {
   CSSParserImpl parser(context, styleSheet);
   CSSTokenizer tokenizer(string);
-  CSSParserTokenRange range = tokenizer.tokenRange();
-  range.consumeWhitespace();
-  if (range.atEnd())
+  CSSParserTokenStream stream(tokenizer);
+  stream.skipWhitespaceAndComments();
+  if (stream.atEnd())
     return nullptr;  // Parse error, empty rule
   StyleRuleBase* rule;
-  if (range.peek().type() == AtKeywordToken)
-    rule = parser.consumeAtRule(range, allowedRules);
+  if (stream.peek().type() == AtKeywordToken)
+    rule = parser.consumeAtRule(stream, allowedRules);
   else
-    rule = parser.consumeQualifiedRule(range, allowedRules);
+    rule = parser.consumeQualifiedRule(stream, allowedRules);
   if (!rule)
     return nullptr;  // Parse error, failed to consume rule
-  range.consumeWhitespace();
-  if (!rule || !range.atEnd())
+  stream.skipWhitespaceAndComments();
+  if (!rule || !stream.atEnd())
     return nullptr;  // Parse error, trailing garbage
   return rule;
 }
 
 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 tokenizer(string);
-  TRACE_EVENT_END0("blink,blink_style",
-                   "CSSParserImpl::parseStyleSheet.tokenize");
-
-  TRACE_EVENT_BEGIN0("blink,blink_style",
-                     "CSSParserImpl::parseStyleSheet.parse");
+  CSSParserTokenStream stream(tokenizer);
   CSSParserImpl parser(context, styleSheet);
   if (deferPropertyParsing) {
-    parser.m_lazyState = new CSSLazyParsingState(
-        context, tokenizer.takeEscapedStrings(), string, parser.m_styleSheet);
+    parser.m_lazyState =
+        new CSSLazyParsingState(context, string, parser.m_styleSheet);
   }
-  bool firstRuleValid =
-      parser.consumeRuleList(tokenizer.tokenRange(), TopLevelRuleList,
-                             [&styleSheet](StyleRuleBase* rule) {
-                               if (rule->isCharsetRule())
-                                 return;
-                               styleSheet->parserAppendRule(rule);
-                             });
+  bool firstRuleValid = parser.consumeRuleList(
+      stream, 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",
-                   "tokenCount", tokenizer.tokenCount(), "length",
-                   string.length());
+  TRACE_EVENT_END1("blink,blink_style", "CSSParserImpl::parseStyleSheet",
+                   "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 39 matching lines @@
 ImmutableStylePropertySet* CSSParserImpl::parseCustomPropertySet(
     CSSParserTokenRange range) {
   range.consumeWhitespace();
   if (range.peek().type() != LeftBraceToken)
     return nullptr;
   CSSParserTokenRange block = range.consumeBlock();
   range.consumeWhitespace();
   if (!range.atEnd())
     return nullptr;
   CSSParserImpl parser(strictCSSParserContext());
-  parser.consumeDeclarationList(block, StyleRule::Style);
-
-  // Drop nested @apply rules. Seems nicer to do this here instead of making
-  // a different StyleRule type
-  for (size_t i = parser.m_parsedProperties.size(); i--;) {
-    if (parser.m_parsedProperties[i].id() == CSSPropertyApplyAtRule)
-      parser.m_parsedProperties.remove(i);
-  }
-
+  parser.consumeDeclarationListForAtApply(block);
   return createStylePropertySet(parser.m_parsedProperties, HTMLStandardMode);
 }
 
 std::unique_ptr<Vector<double>> CSSParserImpl::parseKeyframeKeyList(
     const String& keyList) {
   return consumeKeyframeKeyList(CSSTokenizer(keyList).tokenRange());
 }
 
 bool CSSParserImpl::supportsDeclaration(CSSParserTokenRange& range) {
   ASSERT(m_parsedProperties.isEmpty());
-  consumeDeclaration(range, StyleRule::Style);
+  consumeDeclaration(range, StyleRule::Style, 0, 0);
   bool result = !m_parsedProperties.isEmpty();
   m_parsedProperties.clear();
   return result;
 }
 
 void CSSParserImpl::parseDeclarationListForInspector(
     const String& declaration,
     const CSSParserContext& context,
     CSSParserObserver& observer) {
-  CSSParserImpl parser(context);
-  CSSParserObserverWrapper wrapper(observer);
-  parser.m_observerWrapper = &wrapper;
-  CSSTokenizer tokenizer(declaration, wrapper);
   observer.startRuleHeader(StyleRule::Style, 0);
   observer.endRuleHeader(1);
-  parser.consumeDeclarationList(tokenizer.tokenRange(), StyleRule::Style);
+
+  CSSParserImpl parser(context);
+  parser.m_observer = &observer;
+  CSSTokenizer tokenizer(declaration);
+  CSSParserTokenStream stream(tokenizer);
+  parser.consumeDeclarationList(stream, StyleRule::Style);
 }
 
 void CSSParserImpl::parseStyleSheetForInspector(const String& string,
                                                 const CSSParserContext& context,
                                                 StyleSheetContents* styleSheet,
                                                 CSSParserObserver& observer) {
+  CSSTokenizer tokenizer(string);
+  CSSParserTokenStream stream(tokenizer);
   CSSParserImpl parser(context, styleSheet);
-  CSSParserObserverWrapper wrapper(observer);
-  parser.m_observerWrapper = &wrapper;
-  CSSTokenizer tokenizer(string, wrapper);
-  bool firstRuleValid =
-      parser.consumeRuleList(tokenizer.tokenRange(), TopLevelRuleList,
-                             [&styleSheet](StyleRuleBase* rule) {
-                               if (rule->isCharsetRule())
-                                 return;
-                               styleSheet->parserAppendRule(rule);
-                             });
+  parser.m_observer = &observer;
+  bool firstRuleValid = parser.consumeRuleList(
+      stream, TopLevelRuleList, [&styleSheet](StyleRuleBase* rule) {
+        if (rule->isCharsetRule())
+          return;
+        styleSheet->parserAppendRule(rule);
+      });
   styleSheet->setHasSyntacticallyValidCSSHeader(firstRuleValid);
 }
 
 StylePropertySet* CSSParserImpl::parseDeclarationListForLazyStyle(
-    CSSParserTokenRange block,
+    const String& string,
+    size_t startOffset,
     const CSSParserContext& context) {
+  CSSTokenizer tokenizer(string, startOffset);
+  CSSParserTokenStream stream(tokenizer);
+  stream.peek();
+  // We can't start the stream inside the block as the } wouldn't end the
+  // stream.
+  CSSParserTokenStream block(stream, CSSParserTokenStream::MakeSubStream);
   CSSParserImpl parser(context);
-  parser.consumeDeclarationList(std::move(block), StyleRule::Style);
+  parser.consumeDeclarationList(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())
     return CSSParserImpl::AllowNamespaceRules;
   return CSSParserImpl::RegularRules;
 }
 
 template <typename T>
-bool CSSParserImpl::consumeRuleList(CSSParserTokenRange range,
+bool CSSParserImpl::consumeRuleList(CSSParserTokenStream& stream,
                                     RuleListType ruleListType,
                                     const T callback) {
   AllowedRulesType allowedRules = RegularRules;
   switch (ruleListType) {
     case TopLevelRuleList:
       allowedRules = AllowCharsetRules;
       break;
     case RegularRuleList:
       allowedRules = RegularRules;
       break;
     case KeyframesRuleList:
       allowedRules = KeyframeRules;
       break;
     default:
       ASSERT_NOT_REACHED();
   }
 
   bool seenRule = false;
   bool firstRuleValid = false;
-  while (!range.atEnd()) {
+  while (true) {
     StyleRuleBase* rule;
-    switch (range.peek().type()) {
+    size_t qualifiedRuleStartOffset = stream.offsetAfterComments();
+    if (stream.atEnd())
+      break;
+    switch (stream.peek().type()) {
       case WhitespaceToken:
-        range.consumeWhitespace();
+        stream.consume();
         continue;
       case AtKeywordToken:
-        rule = consumeAtRule(range, allowedRules);
+        rule = consumeAtRule(stream, allowedRules);
+        stream.clean();
         break;
       case CDOToken:
       case CDCToken:
         if (ruleListType == TopLevelRuleList) {
-          range.consume();
+          stream.consume();
           continue;
         }
       // fallthrough
       default:
-        rule = consumeQualifiedRule(range, allowedRules);
+        rule = consumeQualifiedRule(stream, allowedRules,
+                                    qualifiedRuleStartOffset);
+        stream.clean();
         break;
     }
     if (!seenRule) {
       seenRule = true;
       firstRuleValid = rule;
     }
     if (rule) {
       allowedRules = computeNewAllowedRules(allowedRules, rule);
       callback(rule);
     }
   }
 
   return firstRuleValid;
 }
 
-StyleRuleBase* CSSParserImpl::consumeAtRule(CSSParserTokenRange& range,
+StyleRuleBase* CSSParserImpl::consumeAtRule(CSSParserTokenStream& stream,
                                             AllowedRulesType allowedRules) {
-  ASSERT(range.peek().type() == AtKeywordToken);
-  const StringView name = range.consumeIncludingWhitespace().value();
-  const CSSParserToken* preludeStart = &range.peek();
-  while (!range.atEnd() && range.peek().type() != LeftBraceToken &&
-         range.peek().type() != SemicolonToken)
-    range.consumeComponentValue();
+  DCHECK_EQ(stream.peek().type(), AtKeywordToken);
+  const StringView name = stream.peek().value();
+  stream.consume();
+  stream.skipWhitespaceAndComments();
+  size_t preludeStartOffset = stream.offset();
+  size_t preludeStart = stream.index();
+  stream.consumeUntilAtEndOrPeekedTypeIs<LeftBraceToken, SemicolonToken>();
 
-  CSSParserTokenRange prelude = range.makeSubRange(preludeStart, &range.peek());
+  CSSParserTokenRange prelude = stream.makeSubRangeFrom(preludeStart);
   CSSAtRuleID id = cssAtRuleID(name);
   if (id != CSSAtRuleInvalid && m_context.useCounter())
     countAtRule(m_context.useCounter(), id);
 
-  if (range.atEnd() || range.peek().type() == SemicolonToken) {
-    range.consume();
+  if (stream.atEnd() || stream.peek().type() == SemicolonToken) {
+    size_t preludeEndOffset = stream.previousOffset();
+    if (!stream.atEnd())
+      stream.consume();
     if (allowedRules == AllowCharsetRules && id == CSSAtRuleCharset)
       return consumeCharsetRule(prelude);
     if (allowedRules <= AllowImportRules && id == CSSAtRuleImport)
-      return consumeImportRule(prelude);
+      return consumeImportRule(prelude, preludeStartOffset, preludeEndOffset);
     if (allowedRules <= AllowNamespaceRules && id == CSSAtRuleNamespace)
       return consumeNamespaceRule(prelude);
     if (allowedRules == ApplyRules && id == CSSAtRuleApply) {
       consumeApplyRule(prelude);
       return nullptr;  // consumeApplyRule just updates m_parsedProperties
     }
     return nullptr;  // Parse error, unrecognised at-rule without block
   }
 
-  CSSParserTokenRange block = range.consumeBlock();
+  CSSParserTokenStream block(stream, CSSParserTokenStream::MakeSubStream);
   if (allowedRules == KeyframeRules)
     return nullptr;  // Parse error, no at-rules supported inside @keyframes
   if (allowedRules == NoRules || allowedRules == ApplyRules)
     return nullptr;  // Parse error, no at-rules with blocks supported inside
                      // declaration lists
 
   ASSERT(allowedRules <= RegularRules);
 
   switch (id) {
     case CSSAtRuleMedia:
-      return consumeMediaRule(prelude, block);
+      return consumeMediaRule(prelude, block, preludeStartOffset);
     case CSSAtRuleSupports:
-      return consumeSupportsRule(prelude, block);
+      return consumeSupportsRule(prelude, block, preludeStartOffset);
     case CSSAtRuleViewport:
-      return consumeViewportRule(prelude, block);
+      return consumeViewportRule(prelude, block, preludeStartOffset);
     case CSSAtRuleFontFace:
-      return consumeFontFaceRule(prelude, block);
+      return consumeFontFaceRule(prelude, block, preludeStartOffset);
     case CSSAtRuleWebkitKeyframes:
-      return consumeKeyframesRule(true, prelude, block);
+      return consumeKeyframesRule(true, prelude, block, preludeStartOffset);
     case CSSAtRuleKeyframes:
-      return consumeKeyframesRule(false, prelude, block);
+      return consumeKeyframesRule(false, prelude, block, preludeStartOffset);
     case CSSAtRulePage:
-      return consumePageRule(prelude, block);
+      return consumePageRule(prelude, block, preludeStartOffset);
     default:
       return nullptr;  // Parse error, unrecognised at-rule with block
   }
 }
 
 StyleRuleBase* CSSParserImpl::consumeQualifiedRule(
-    CSSParserTokenRange& range,
-    AllowedRulesType allowedRules) {
-  const CSSParserToken* preludeStart = &range.peek();
-  while (!range.atEnd() && range.peek().type() != LeftBraceToken)
-    range.consumeComponentValue();
+    CSSParserTokenStream& stream,
+    AllowedRulesType allowedRules,
+    size_t startOffset) {
+  if (allowedRules <= RegularRules)
+    return consumeStyleRule(stream, startOffset);
 
-  if (range.atEnd())
+  size_t preludeStart = stream.index();
+  stream.consumeUntilAtEndOrPeekedTypeIs<LeftBraceToken>();
+
+  if (stream.atEnd())
     return nullptr;  // Parse error, EOF instead of qualified rule block
 
-  CSSParserTokenRange prelude = range.makeSubRange(preludeStart, &range.peek());
-  CSSParserTokenRange block = range.consumeBlock();
-
-  if (allowedRules <= RegularRules)
-    return consumeStyleRule(prelude, block);
-  if (allowedRules == KeyframeRules)
-    return consumeKeyframeStyleRule(prelude, block);
-
-  ASSERT_NOT_REACHED();
-  return nullptr;
+  CSSParserTokenRange prelude = stream.makeSubRangeFrom(preludeStart);
+  CSSParserTokenStream block(stream, CSSParserTokenStream::MakeSubStream);
+  DCHECK(allowedRules == KeyframeRules);
+  return consumeKeyframeStyleRule(prelude, block, startOffset);
 }
 
 // This may still consume tokens if it fails
 static AtomicString consumeStringOrURI(CSSParserTokenRange& range) {
   const CSSParserToken& token = range.peek();
 
   if (token.type() == StringToken || token.type() == UrlToken)
     return range.consumeIncludingWhitespace().value().toAtomicString();
 
   if (token.type() != FunctionToken ||
       !equalIgnoringASCIICase(token.value(), "url"))
     return AtomicString();
 
   CSSParserTokenRange contents = range.consumeBlock();
   const CSSParserToken& uri = contents.consumeIncludingWhitespace();
   if (uri.type() == BadStringToken || !contents.atEnd())
     return AtomicString();
   DCHECK_EQ(uri.type(), StringToken);
   return uri.value().toAtomicString();
 }
 
 StyleRuleCharset* CSSParserImpl::consumeCharsetRule(
     CSSParserTokenRange prelude) {
   const CSSParserToken& string = prelude.consumeIncludingWhitespace();
   if (string.type() != StringToken || !prelude.atEnd())
     return nullptr;  // Parse error, expected a single string
   return StyleRuleCharset::create();
 }
 
-StyleRuleImport* CSSParserImpl::consumeImportRule(CSSParserTokenRange prelude) {
+StyleRuleImport* CSSParserImpl::consumeImportRule(CSSParserTokenRange prelude,
+                                                  size_t startOffset,
+                                                  size_t endOffset) {
   AtomicString uri(consumeStringOrURI(prelude));
   if (uri.isNull())
     return nullptr;  // Parse error, expected string or URI
 
-  if (m_observerWrapper) {
-    unsigned endOffset = m_observerWrapper->endOffset(prelude);
-    m_observerWrapper->observer().startRuleHeader(
-        StyleRule::Import, m_observerWrapper->startOffset(prelude));
-    m_observerWrapper->observer().endRuleHeader(endOffset);
-    m_observerWrapper->observer().startRuleBody(endOffset);
-    m_observerWrapper->observer().endRuleBody(endOffset);
+  if (m_observer) {
+    m_observer->startRuleHeader(StyleRule::Import, startOffset);
+    m_observer->endRuleHeader(endOffset);
+    m_observer->startRuleBody(endOffset);
+    m_observer->endRuleBody(endOffset);
   }
 
   return StyleRuleImport::create(uri,
                                  MediaQueryParser::parseMediaQuerySet(prelude));
 }
 
 StyleRuleNamespace* CSSParserImpl::consumeNamespaceRule(
     CSSParserTokenRange prelude) {
   AtomicString namespacePrefix;
   if (prelude.peek().type() == IdentToken)
     namespacePrefix =
         prelude.consumeIncludingWhitespace().value().toAtomicString();
 
   AtomicString uri(consumeStringOrURI(prelude));
   if (uri.isNull() || !prelude.atEnd())
     return nullptr;  // Parse error, expected string or URI
 
   return StyleRuleNamespace::create(namespacePrefix, uri);
 }
 
 StyleRuleMedia* CSSParserImpl::consumeMediaRule(CSSParserTokenRange prelude,
-                                                CSSParserTokenRange block) {
+                                                CSSParserTokenStream& block,
+                                                size_t preludeStartOffset) {
   HeapVector<Member<StyleRuleBase>> rules;
 
-  if (m_observerWrapper) {
-    m_observerWrapper->observer().startRuleHeader(
-        StyleRule::Media, m_observerWrapper->startOffset(prelude));
-    m_observerWrapper->observer().endRuleHeader(
-        m_observerWrapper->endOffset(prelude));
-    m_observerWrapper->observer().startRuleBody(
-        m_observerWrapper->previousTokenStartOffset(block));
+  if (m_observer) {
+    m_observer->startRuleHeader(StyleRule::Media, preludeStartOffset);
+    m_observer->endRuleHeader(block.offset() - 1);
+    m_observer->startRuleBody(block.offset() - 1);
   }
 
   if (m_styleSheet)
     m_styleSheet->setHasMediaQueries();
 
   consumeRuleList(block, RegularRuleList,
                   [&rules](StyleRuleBase* rule) { rules.push_back(rule); });
 
-  if (m_observerWrapper)
-    m_observerWrapper->observer().endRuleBody(
-        m_observerWrapper->endOffset(block));
+  if (m_observer)
+    m_observer->endRuleBody(block.offset());
 
   return StyleRuleMedia::create(MediaQueryParser::parseMediaQuerySet(prelude),
                                 rules);
 }
 
 StyleRuleSupports* CSSParserImpl::consumeSupportsRule(
     CSSParserTokenRange prelude,
-    CSSParserTokenRange block) {
+    CSSParserTokenStream& block,
+    size_t preludeStartOffset) {
   CSSSupportsParser::SupportsResult supported =
       CSSSupportsParser::supportsCondition(prelude, *this);
   if (supported == CSSSupportsParser::Invalid)
     return nullptr;  // Parse error, invalid @supports condition
 
-  if (m_observerWrapper) {
-    m_observerWrapper->observer().startRuleHeader(
-        StyleRule::Supports, m_observerWrapper->startOffset(prelude));
-    m_observerWrapper->observer().endRuleHeader(
-        m_observerWrapper->endOffset(prelude));
-    m_observerWrapper->observer().startRuleBody(
-        m_observerWrapper->previousTokenStartOffset(block));
+  if (m_observer) {
+    m_observer->startRuleHeader(StyleRule::Supports, preludeStartOffset);
+    m_observer->endRuleHeader(block.offset() - 1);
+    m_observer->startRuleBody(block.offset() - 1);
   }
 
   HeapVector<Member<StyleRuleBase>> rules;
   consumeRuleList(block, RegularRuleList,
                   [&rules](StyleRuleBase* rule) { rules.push_back(rule); });
 
-  if (m_observerWrapper)
-    m_observerWrapper->observer().endRuleBody(
-        m_observerWrapper->endOffset(block));
+  if (m_observer)
+    m_observer->endRuleBody(block.offset());
 
   return StyleRuleSupports::create(prelude.serialize().stripWhiteSpace(),
                                    supported, rules);
 }
 
 StyleRuleViewport* CSSParserImpl::consumeViewportRule(
     CSSParserTokenRange prelude,
-    CSSParserTokenRange block) {
+    CSSParserTokenStream& block,
+    size_t preludeStartOffset) {
   // Allow @viewport rules from UA stylesheets even if the feature is disabled.
   if (!RuntimeEnabledFeatures::cssViewportEnabled() &&
       !isUASheetBehavior(m_context.mode()))
     return nullptr;
 
   if (!prelude.atEnd())
     return nullptr;  // Parser error; @viewport prelude should be empty
 
-  if (m_observerWrapper) {
-    unsigned endOffset = m_observerWrapper->endOffset(prelude);
-    m_observerWrapper->observer().startRuleHeader(
-        StyleRule::Viewport, m_observerWrapper->startOffset(prelude));
-    m_observerWrapper->observer().endRuleHeader(endOffset);
-    m_observerWrapper->observer().startRuleBody(endOffset);
-    m_observerWrapper->observer().endRuleBody(endOffset);
+  if (m_observer) {
+    m_observer->startRuleHeader(StyleRule::Viewport, preludeStartOffset);
+    m_observer->endRuleHeader(block.offset() - 1);
+    m_observer->startRuleBody(block.offset() - 1);
+    m_observer->endRuleBody(block.offset() - 1);
   }
 
   if (m_styleSheet)
     m_styleSheet->setHasViewportRule();
 
   consumeDeclarationList(block, StyleRule::Viewport);
   return StyleRuleViewport::create(
       createStylePropertySet(m_parsedProperties, CSSViewportRuleMode));
 }
 
 StyleRuleFontFace* CSSParserImpl::consumeFontFaceRule(
     CSSParserTokenRange prelude,
-    CSSParserTokenRange block) {
+    CSSParserTokenStream& block,
+    size_t preludeStartOffset) {
   if (!prelude.atEnd())
     return nullptr;  // Parse error; @font-face prelude should be empty
 
-  if (m_observerWrapper) {
-    unsigned endOffset = m_observerWrapper->endOffset(prelude);
-    m_observerWrapper->observer().startRuleHeader(
-        StyleRule::FontFace, m_observerWrapper->startOffset(prelude));
-    m_observerWrapper->observer().endRuleHeader(endOffset);
-    m_observerWrapper->observer().startRuleBody(endOffset);
-    m_observerWrapper->observer().endRuleBody(endOffset);
+  if (m_observer) {
+    m_observer->startRuleHeader(StyleRule::FontFace, preludeStartOffset);
+    m_observer->endRuleHeader(block.offset() - 1);
+    m_observer->startRuleBody(block.offset() - 1);
+    m_observer->endRuleBody(block.offset() - 1);
   }
 
   if (m_styleSheet)
     m_styleSheet->setHasFontFaceRule();
 
   consumeDeclarationList(block, StyleRule::FontFace);
   return StyleRuleFontFace::create(
       createStylePropertySet(m_parsedProperties, CSSFontFaceRuleMode));
 }
 
 StyleRuleKeyframes* CSSParserImpl::consumeKeyframesRule(
     bool webkitPrefixed,
     CSSParserTokenRange prelude,
-    CSSParserTokenRange block) {
-  CSSParserTokenRange rangeCopy = prelude;  // For inspector callbacks
+    CSSParserTokenStream& block,
+    size_t preludeStartOffset) {
   const CSSParserToken& nameToken = prelude.consumeIncludingWhitespace();
   if (!prelude.atEnd())
     return nullptr;  // Parse error; expected single non-whitespace token in
                      // @keyframes header
 
   String name;
   if (nameToken.type() == IdentToken) {
     name = nameToken.value().toString();
   } else if (nameToken.type() == StringToken && webkitPrefixed) {
     if (m_context.useCounter())
       m_context.useCounter()->count(UseCounter::QuotedKeyframesRule);
     name = nameToken.value().toString();
   } else {
     return nullptr;  // Parse error; expected ident token in @keyframes header
   }
 
-  if (m_observerWrapper) {
-    m_observerWrapper->observer().startRuleHeader(
-        StyleRule::Keyframes, m_observerWrapper->startOffset(rangeCopy));
-    m_observerWrapper->observer().endRuleHeader(
-        m_observerWrapper->endOffset(prelude));
-    m_observerWrapper->observer().startRuleBody(
-        m_observerWrapper->previousTokenStartOffset(block));
-    m_observerWrapper->observer().endRuleBody(
-        m_observerWrapper->endOffset(block));
+  if (m_observer) {
+    m_observer->startRuleHeader(StyleRule::Keyframes, preludeStartOffset);
+    m_observer->endRuleHeader(block.offset() - 1);
+    m_observer->startRuleBody(block.offset() - 1);
   }
 
   StyleRuleKeyframes* keyframeRule = StyleRuleKeyframes::create();
   consumeRuleList(
       block, KeyframesRuleList, [keyframeRule](StyleRuleBase* keyframe) {
         keyframeRule->parserAppendKeyframe(toStyleRuleKeyframe(keyframe));
       });
   keyframeRule->setName(name);
   keyframeRule->setVendorPrefixed(webkitPrefixed);
+
+  if (m_observer)
+    m_observer->endRuleBody(block.offset());
+
   return keyframeRule;
 }
 
 StyleRulePage* CSSParserImpl::consumePageRule(CSSParserTokenRange prelude,
-                                              CSSParserTokenRange block) {
+                                              CSSParserTokenStream& block,
+                                              size_t preludeStartOffset) {
   CSSSelectorList selectorList = parsePageSelector(prelude, m_styleSheet);
   if (!selectorList.isValid())
     return nullptr;  // Parse error, invalid @page selector
 
-  if (m_observerWrapper) {
-    unsigned endOffset = m_observerWrapper->endOffset(prelude);
-    m_observerWrapper->observer().startRuleHeader(
-        StyleRule::Page, m_observerWrapper->startOffset(prelude));
-    m_observerWrapper->observer().endRuleHeader(endOffset);
+  if (m_observer) {
+    m_observer->startRuleHeader(StyleRule::Page, preludeStartOffset);
+    m_observer->endRuleHeader(block.offset() - 1);
   }
 
   consumeDeclarationList(block, StyleRule::Style);
 
   return StyleRulePage::create(
       std::move(selectorList),
       createStylePropertySet(m_parsedProperties, m_context.mode()));
 }
 
 void CSSParserImpl::consumeApplyRule(CSSParserTokenRange prelude) {
   ASSERT(RuntimeEnabledFeatures::cssApplyAtRulesEnabled());
 
   const CSSParserToken& ident = prelude.consumeIncludingWhitespace();
   if (!prelude.atEnd() || !CSSVariableParser::isValidVariableName(ident))
     return;  // Parse error, expected a single custom property name
   m_parsedProperties.push_back(CSSProperty(
       CSSPropertyApplyAtRule,
       *CSSCustomIdentValue::create(ident.value().toAtomicString())));
 }
 
 StyleRuleKeyframe* CSSParserImpl::consumeKeyframeStyleRule(
     CSSParserTokenRange prelude,
-    CSSParserTokenRange block) {
+    CSSParserTokenStream& block,
+    size_t preludeStartOffset) {
   std::unique_ptr<Vector<double>> keyList = consumeKeyframeKeyList(prelude);
   if (!keyList)
     return nullptr;
 
-  if (m_observerWrapper) {
-    m_observerWrapper->observer().startRuleHeader(
-        StyleRule::Keyframe, m_observerWrapper->startOffset(prelude));
-    m_observerWrapper->observer().endRuleHeader(
-        m_observerWrapper->endOffset(prelude));
+  if (m_observer) {
+    m_observer->startRuleHeader(StyleRule::Keyframe, preludeStartOffset);
+    m_observer->endRuleHeader(block.offset() - 1);
   }
 
   consumeDeclarationList(block, StyleRule::Keyframe);
   return StyleRuleKeyframe::create(
       std::move(keyList),
       createStylePropertySet(m_parsedProperties, m_context.mode()));
 }
 
-static void observeSelectors(CSSParserObserverWrapper& wrapper,
-                             CSSParserTokenRange selectors) {
-  // This is easier than hooking into the CSSSelectorParser
-  selectors.consumeWhitespace();
-  CSSParserTokenRange originalRange = selectors;
-  wrapper.observer().startRuleHeader(StyleRule::Style,
-                                     wrapper.startOffset(originalRange));
+StyleRule* CSSParserImpl::consumeStyleRule(CSSParserTokenStream& stream,
+                                           size_t startOffset) {
+  if (m_observer)
+    m_observer->startRuleHeader(StyleRule::Style, startOffset);
+  CSSSelectorList selectorList = CSSSelectorParser::consumeSelector(
+      stream, m_context, m_styleSheet, startOffset, m_observer);
 
-  while (!selectors.atEnd()) {
-    const CSSParserToken* selectorStart = &selectors.peek();
-    while (!selectors.atEnd() && selectors.peek().type() != CommaToken)
-      selectors.consumeComponentValue();
-    CSSParserTokenRange selector =
-        selectors.makeSubRange(selectorStart, &selectors.peek());
-    selectors.consumeIncludingWhitespace();
+  if (!selectorList.isValid())
+    stream.consumeUntilAtEndOrPeekedTypeIs<LeftBraceToken>();
 
-    wrapper.observer().observeSelector(wrapper.startOffset(selector),
-                                       wrapper.endOffset(selector));
+  DCHECK(stream.atEnd() || stream.peek().type() == LeftBraceToken);
+
+  if (m_observer)
+    m_observer->endRuleHeader(stream.previousOffset());
+
+  if (!selectorList.isValid()) {
+    if (!stream.atEnd())
+      stream.skipBlock();
+    return nullptr;  // Parse error, invalid selector list
   }
 
-  wrapper.observer().endRuleHeader(wrapper.endOffset(originalRange));
-}
+  if (m_lazyState && m_lazyState->shouldLazilyParseProperties(selectorList)) {
+    DCHECK(m_styleSheet);
+    size_t blockOffset = stream.previousOffset();
+    stream.skipBlock();
+    return StyleRule::createLazy(std::move(selectorList),
+                                 m_lazyState->createLazyParser(blockOffset));
+  }
 
-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
-
-  // 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, block)) {
-    DCHECK(m_styleSheet);
-    return StyleRule::createLazy(std::move(selectorList),
-                                 m_lazyState->createLazyParser(block));
-  }
+  CSSParserTokenStream block(stream, CSSParserTokenStream::MakeSubStream);
   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));
-    m_observerWrapper->skipCommentsBefore(range, true);
-  }
-
+void CSSParserImpl::consumeDeclarationListForAtApply(
+    CSSParserTokenRange range) {
+  DCHECK(m_parsedProperties.isEmpty());
+  DCHECK(RuntimeEnabledFeatures::cssApplyAtRulesEnabled());
+  DCHECK(!m_observer);
   while (!range.atEnd()) {
     switch (range.peek().type()) {
       case WhitespaceToken:
       case SemicolonToken:
         range.consume();
         break;
       case IdentToken: {
         const CSSParserToken* declarationStart = &range.peek();
-
-        if (useObserver)
-          m_observerWrapper->yieldCommentsBefore(range);
-
         while (!range.atEnd() && range.peek().type() != SemicolonToken)
           range.consumeComponentValue();
+        consumeDeclaration(range.makeSubRange(declarationStart, &range.peek()),
+                           StyleRule::Style, 0, 0);
+        break;
+      }
+      case AtKeywordToken:
+        range.consume();
+        while (!range.atEnd() && range.peek().type() != LeftBraceToken &&
+               range.peek().type() != SemicolonToken)
+          range.consumeComponentValue();
+        range.consumeComponentValue();
+        break;
+      default:  // Parse error, unexpected token in declaration list
+        while (!range.atEnd() && range.peek().type() != SemicolonToken)
+          range.consumeComponentValue();
+        break;
+    }
+  }
+}
 
-        consumeDeclaration(range.makeSubRange(declarationStart, &range.peek()),
-                           ruleType);
+void CSSParserImpl::consumeDeclarationList(CSSParserTokenStream& stream,
+                                           StyleRule::RuleType ruleType) {
+  DCHECK(m_parsedProperties.isEmpty());
 
-        if (useObserver)
-          m_observerWrapper->skipCommentsBefore(range, false);
+  bool useObserver = m_observer && (ruleType == StyleRule::Style ||
+                                    ruleType == StyleRule::Keyframe);
+  if (useObserver)
+    m_observer->startRuleBody(stream.offset() ? stream.offset() - 1 : 0);
+
+  while (true) {
+    if (useObserver)
+      stream.yieldComments(*m_observer);
+    size_t declarationStartOffset = stream.offset();
+    if (stream.atEnd())
+      break;
+    switch (stream.peek().type()) {
+      case WhitespaceToken:
+      case SemicolonToken:
+        stream.consume();
+        break;
+      case IdentToken: {
+        consumeDeclaration(stream, ruleType, declarationStartOffset);
+        if (!stream.atEnd())
+          stream.consume();
         break;
       }
       case AtKeywordToken: {
         AllowedRulesType allowedRules =
             ruleType == StyleRule::Style &&
                     RuntimeEnabledFeatures::cssApplyAtRulesEnabled()
                 ? ApplyRules
                 : NoRules;
-        StyleRuleBase* rule = consumeAtRule(range, allowedRules);
+        StyleRuleBase* rule = consumeAtRule(stream, allowedRules);
         DCHECK(!rule);
         break;
       }
       default:  // Parse error, unexpected token in declaration list
-        while (!range.atEnd() && range.peek().type() != SemicolonToken)
-          range.consumeComponentValue();
+        stream.consumeUntilAtEndOrPeekedTypeIs<SemicolonToken>();
+        if (!stream.atEnd())
+          stream.consume();
         break;
     }
   }
 
-  // Yield remaining comments
-  if (useObserver) {
-    m_observerWrapper->yieldCommentsBefore(range);
-    m_observerWrapper->observer().endRuleBody(
-        m_observerWrapper->endOffset(range));
-  }
+  if (useObserver)
+    m_observer->endRuleBody(stream.offset());
+}
+
+void CSSParserImpl::consumeDeclaration(CSSParserTokenStream& stream,
+                                       StyleRule::RuleType ruleType,
+                                       size_t declarationStartOffset) {
+  DCHECK_EQ(stream.peek().type(), IdentToken);
+  size_t startIndex = stream.index();
+  stream.consume();
+  stream.consumeUntilAtEndOrPeekedTypeIs<SemicolonToken>();
+  consumeDeclaration(stream.makeSubRangeFrom(startIndex), ruleType,
+                     declarationStartOffset, stream.previousOffset());
+  stream.clean();
 }
 
 void CSSParserImpl::consumeDeclaration(CSSParserTokenRange range,
-                                       StyleRule::RuleType ruleType) {
-  CSSParserTokenRange rangeCopy = range;  // For inspector callbacks
-
+                                       StyleRule::RuleType ruleType,
+                                       size_t declarationStartOffset,
+                                       size_t declarationEndOffset) {
   ASSERT(range.peek().type() == IdentToken);
   const CSSParserToken& token = range.consumeIncludingWhitespace();
   CSSPropertyID unresolvedProperty = token.parseAsUnresolvedCSSPropertyID();
   if (range.consume().type() != ColonToken)
     return;  // Parse error
 
   bool important = false;
   const CSSParserToken* declarationValueEnd = range.end();
   const CSSParserToken* last = range.end() - 1;
   while (last->type() == WhitespaceToken)
@@ skipping 24 matching lines @@
                          variableName, important, isAnimationTainted);
   } else if (unresolvedProperty != CSSPropertyInvalid) {
     if (m_styleSheet && m_styleSheet->singleOwnerDocument())
       Deprecation::warnOnDeprecatedProperties(
           m_styleSheet->singleOwnerDocument()->frame(), unresolvedProperty);
     consumeDeclarationValue(
         range.makeSubRange(&range.peek(), declarationValueEnd),
         unresolvedProperty, important, ruleType);
   }
 
-  if (m_observerWrapper &&
+  if (m_observer &&
       (ruleType == StyleRule::Style || ruleType == StyleRule::Keyframe)) {
-    m_observerWrapper->observer().observeProperty(
-        m_observerWrapper->startOffset(rangeCopy),
-        m_observerWrapper->endOffset(rangeCopy), important,
-        m_parsedProperties.size() != propertiesCount);
+    m_observer->observeProperty(declarationStartOffset, declarationEndOffset,
+                                important,
+                                m_parsedProperties.size() != propertiesCount);
   }
 }
 
 void CSSParserImpl::consumeVariableValue(CSSParserTokenRange range,
                                          const AtomicString& variableName,
                                          bool important,
                                          bool isAnimationTainted) {
   if (CSSCustomPropertyDeclaration* value =
           CSSVariableParser::parseDeclarationValue(variableName, range,
                                                    isAnimationTainted))
@@ skipping 27 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