[WIP] Streaming CSS parser

third_party/WebKit/Source/core/css/parser/CSSParserImpl.h

 // 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.
 
 #ifndef CSSParserImpl_h
 #define CSSParserImpl_h
 
 #include "core/CSSPropertyNames.h"
 #include "core/css/CSSProperty.h"
 #include "core/css/CSSPropertySourceData.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/parser/CSSParserTokenRange.h"
+#include "core/css/parser/CSSParserTokenStream.h"
 #include "platform/heap/Handle.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 #include <memory>
 
 namespace blink {
 
 class CSSLazyParsingState;
 class CSSParserContext;
 class CSSParserObserver;
-class CSSParserObserverWrapper;
 class StyleRule;
 class StyleRuleBase;
 class StyleRuleCharset;
 class StyleRuleFontFace;
 class StyleRuleImport;
 class StyleRuleKeyframe;
 class StyleRuleKeyframes;
 class StyleRuleMedia;
 class StyleRuleNamespace;
 class StyleRulePage;
@@ skipping 47 matching lines @@
                                   StyleSheetContents*,
                                   AllowedRulesType);
   static void parseStyleSheet(const String&,
                               const CSSParserContext&,
                               StyleSheetContents*,
                               bool deferPropertyParsing = false);
   static CSSSelectorList parsePageSelector(CSSParserTokenRange,
                                            StyleSheetContents*);
 
   static ImmutableStylePropertySet* parseCustomPropertySet(CSSParserTokenRange);
+  // This will be removed when crbug.com/661854 is fixed. We need to use a
+  // stream for parsing @apply blocks so we can correctly store custom
+  // property values.
+  void consumeDeclarationListForAtApply(CSSParserTokenRange);
 
   static std::unique_ptr<Vector<double>> parseKeyframeKeyList(const String&);
 
   bool supportsDeclaration(CSSParserTokenRange&);
 
   static void parseDeclarationListForInspector(const String&,
                                                const CSSParserContext&,
                                                CSSParserObserver&);
   static void parseStyleSheetForInspector(const String&,
                                           const CSSParserContext&,
                                           StyleSheetContents*,
                                           CSSParserObserver&);
 
   static StylePropertySet* parseDeclarationListForLazyStyle(
-      CSSParserTokenRange block,
+      const String&,
+      size_t startOffset,
       const CSSParserContext&);
 
  private:
   enum RuleListType { TopLevelRuleList, RegularRuleList, KeyframesRuleList };
 
   // Returns whether the first encountered rule was valid
   template <typename T>
-  bool consumeRuleList(CSSParserTokenRange, RuleListType, T callback);
+  bool consumeRuleList(CSSParserTokenStream&, RuleListType, T callback);
 
-  // These two functions update the range they're given
-  StyleRuleBase* consumeAtRule(CSSParserTokenRange&, AllowedRulesType);
-  StyleRuleBase* consumeQualifiedRule(CSSParserTokenRange&, AllowedRulesType);
+  StyleRuleBase* consumeAtRule(CSSParserTokenStream&, AllowedRulesType);
+  // The start offset is needed when we use a CSSParserObserver
+  StyleRuleBase* consumeQualifiedRule(CSSParserTokenStream&,
+                                      AllowedRulesType,
+                                      size_t startOffset = 0);
 
   static StyleRuleCharset* consumeCharsetRule(CSSParserTokenRange prelude);
-  StyleRuleImport* consumeImportRule(CSSParserTokenRange prelude);
+  StyleRuleImport* consumeImportRule(CSSParserTokenRange prelude,
+                                     size_t startOffset,
+                                     size_t endOffset);
   StyleRuleNamespace* consumeNamespaceRule(CSSParserTokenRange prelude);
+  // The prelude runs from preludeStartOffset to block.offset() - 1
   StyleRuleMedia* consumeMediaRule(CSSParserTokenRange prelude,
-                                   CSSParserTokenRange block);
+                                   CSSParserTokenStream& block,
+                                   size_t preludeStartOffset);
   StyleRuleSupports* consumeSupportsRule(CSSParserTokenRange prelude,
-                                         CSSParserTokenRange block);
+                                         CSSParserTokenStream& block,
+                                         size_t preludeStartOffset);
   StyleRuleViewport* consumeViewportRule(CSSParserTokenRange prelude,
-                                         CSSParserTokenRange block);
+                                         CSSParserTokenStream& block,
+                                         size_t preludeStartOffset);
   StyleRuleFontFace* consumeFontFaceRule(CSSParserTokenRange prelude,
-                                         CSSParserTokenRange block);
+                                         CSSParserTokenStream& block,
+                                         size_t preludeStartOffset);
   StyleRuleKeyframes* consumeKeyframesRule(bool webkitPrefixed,
                                            CSSParserTokenRange prelude,
-                                           CSSParserTokenRange block);
+                                           CSSParserTokenStream& block,
+                                           size_t preludeStartOffset);
   StyleRulePage* consumePageRule(CSSParserTokenRange prelude,
-                                 CSSParserTokenRange block);
+                                 CSSParserTokenStream& block,
+                                 size_t preludeStartOffset);
   // Updates m_parsedProperties
   void consumeApplyRule(CSSParserTokenRange prelude);
 
   StyleRuleKeyframe* consumeKeyframeStyleRule(CSSParserTokenRange prelude,
-                                              CSSParserTokenRange block);
-  StyleRule* consumeStyleRule(CSSParserTokenRange prelude,
-                              CSSParserTokenRange block);
+                                              CSSParserTokenStream& block,
+                                              size_t preludeStartOffset);
+  StyleRule* consumeStyleRule(CSSParserTokenStream&, size_t startOffset);
 
-  void consumeDeclarationList(CSSParserTokenRange, StyleRule::RuleType);
-  void consumeDeclaration(CSSParserTokenRange, StyleRule::RuleType);
+  void consumeDeclarationList(CSSParserTokenStream&, StyleRule::RuleType);
+  void consumeDeclaration(CSSParserTokenStream&,
+                          StyleRule::RuleType,
+                          size_t declarationStartOffset);
+  void consumeDeclaration(CSSParserTokenRange,
+                          StyleRule::RuleType,
+                          size_t declarationStartOffset,
+                          size_t declarationEndOffset);
   void consumeDeclarationValue(CSSParserTokenRange,
                                CSSPropertyID,
                                bool important,
                                StyleRule::RuleType);
   void consumeVariableValue(CSSParserTokenRange,
                             const AtomicString& propertyName,
                             bool important,
                             bool isAnimationTainted);
 
   static std::unique_ptr<Vector<double>> consumeKeyframeKeyList(
       CSSParserTokenRange);
 
   // FIXME: Can we build StylePropertySets directly?
   // FIXME: Investigate using a smaller inline buffer
   HeapVector<CSSProperty, 256> m_parsedProperties;
   const CSSParserContext& m_context;
 
   Member<StyleSheetContents> m_styleSheet;
 
-  // For the inspector
-  CSSParserObserverWrapper* m_observerWrapper;
+  Member<CSSLazyParsingState> m_lazyState;
 
-  Member<CSSLazyParsingState> m_lazyState;
+  CSSParserObserver* m_observer = nullptr;
 };
 
 }  // namespace blink
 
 #endif  // CSSParserImpl_h