[WIP] Streaming CSS parser

third_party/WebKit/Source/core/css/parser/CSSSelectorParser.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/CSSSelectorParser.h"
 
 #include "core/css/CSSSelectorList.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/parser/CSSParserContext.h"
+#include "core/css/parser/CSSParserObserver.h"
+#include "core/css/parser/CSSParserTokenStream.h"
 #include "core/frame/UseCounter.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 static void recordSelectorStats(const CSSParserContext& context,
                                 const CSSSelectorList& selectorList) {
   if (!context.useCounter())
@@ skipping 79 matching lines @@
   CSSSelectorParser parser(context, styleSheet);
   range.consumeWhitespace();
   CSSSelectorList result = parser.consumeComplexSelectorList(range);
   if (!range.atEnd())
     return CSSSelectorList();
 
   recordSelectorStats(context, result);
   return result;
 }
 
+CSSSelectorList CSSSelectorParser::consumeSelector(
+    CSSParserTokenStream& stream,
+    const CSSParserContext& context,
+    StyleSheetContents* styleSheet,
+    size_t startOffset,
+    CSSParserObserver* observer) {
+  CSSSelectorParser parser(context, styleSheet);
+  DCHECK_NE(stream.peek().type(), WhitespaceToken);
+  CSSSelectorList result =
+      parser.consumeComplexSelectorList(stream, startOffset, observer);
+
+  recordSelectorStats(context, result);
+  return result;
+}
+
 CSSSelectorParser::CSSSelectorParser(const CSSParserContext& context,
                                      StyleSheetContents* styleSheet)
     : m_context(context), m_styleSheet(styleSheet) {}
 
 CSSSelectorList CSSSelectorParser::consumeComplexSelectorList(
+    CSSParserTokenStream& stream,
+    size_t startOffset,
+    CSSParserObserver* observer) {
+  Vector<std::unique_ptr<CSSParserSelector>> selectorList;
+
+  while (true) {
+    size_t selectorStart = stream.index();
+    stream.consumeUntilAtEndOrPeekedTypeIs<LeftBraceToken, CommaToken>();
+    if (stream.atEnd())
+      return CSSSelectorList();
+
+    CSSParserTokenRange complexSelector =
+        stream.makeSubRangeFrom(selectorStart);
+    std::unique_ptr<CSSParserSelector> selector =
+        consumeComplexSelector(complexSelector);
+    if (observer)
+      observer->observeSelector(startOffset, stream.previousOffset());
+    stream.clean();
+
+    if (!selector || m_failedParsing || !complexSelector.atEnd())
+      return CSSSelectorList();
+
+    selectorList.append(std::move(selector));
+    if (stream.peek().type() == LeftBraceToken)
+      break;
+    DCHECK_EQ(stream.peek().type(), CommaToken);
+    stream.consume();
+    stream.skipWhitespaceAndComments();
+    startOffset = stream.offset();
+  }
+
+  return CSSSelectorList::adoptSelectorVector(selectorList);

[Charlie Harrison, 2017/01/09 21:35:07]

Not new code, but why do we allocate some selectors on the stack, then copy them
into a separate CSSSelectorList?

Context: I am seeing the fastMalloc (and other things) in adoptSelectorVector in
profiles as a non-significant chunk of time here.

+}
+
+CSSSelectorList CSSSelectorParser::consumeComplexSelectorList(
     CSSParserTokenRange& range) {
   Vector<std::unique_ptr<CSSParserSelector>> selectorList;
   std::unique_ptr<CSSParserSelector> selector = consumeComplexSelector(range);
   if (!selector)
     return CSSSelectorList();
   selectorList.push_back(std::move(selector));
   while (!range.atEnd() && range.peek().type() == CommaToken) {
     range.consumeIncludingWhitespace();
     selector = consumeComplexSelector(range);
     if (!selector)
@@ skipping 750 matching lines @@
       splitAfter->releaseTagHistory();
   secondCompound->appendTagHistory(
       secondCompound->pseudoType() == CSSSelector::PseudoSlotted
           ? CSSSelector::ShadowSlot
           : CSSSelector::ShadowPseudo,
       std::move(compoundSelector));
   return secondCompound;
 }
 
 }  // namespace blink