[Experimental] CSSSerializer Proof-of-concept

third_party/WebKit/Source/core/css/StyleRule.h

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * (C) 2002-2003 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2002, 2006, 2008, 2012, 2013 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 13 matching lines @@
 
 #include "core/CoreExport.h"
 #include "core/css/CSSSelectorList.h"
 #include "core/css/MediaList.h"
 #include "core/css/StylePropertySet.h"
 #include "platform/heap/Handle.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
+class CSSDeserializeStream;
 class CSSRule;
 class CSSStyleSheet;
+class CSSSerializeStream;
 
 class CORE_EXPORT StyleRuleBase : public RefCountedWillBeGarbageCollectedFinalized<StyleRuleBase> {
     USING_FAST_MALLOC_WITH_TYPE_NAME_WILL_BE_REMOVED(blink::StyleRuleBase);
 public:
     enum Type {
         Charset,
         Style,
         Import,
         Media,
         FontFace,
@@ skipping 12 matching lines @@
     bool isKeyframesRule() const { return type() == Keyframes; }
     bool isKeyframeRule() const { return type() == Keyframe; }
     bool isNamespaceRule() const { return type() == Namespace; }
     bool isMediaRule() const { return type() == Media; }
     bool isPageRule() const { return type() == Page; }
     bool isStyleRule() const { return type() == Style; }
     bool isSupportsRule() const { return type() == Supports; }
     bool isViewportRule() const { return type() == Viewport; }
     bool isImportRule() const { return type() == Import; }
 
+    static PassRefPtrWillBeRawPtr<StyleRuleBase> deserialize(CSSDeserializeStream*);
     PassRefPtrWillBeRawPtr<StyleRuleBase> copy() const;
 
 #if !ENABLE(OILPAN)
     void deref()
     {
         if (derefBase())
             destroy();
     }
 #endif // !ENABLE(OILPAN)
 
     // FIXME: There shouldn't be any need for the null parent version.
     PassRefPtrWillBeRawPtr<CSSRule> createCSSOMWrapper(CSSStyleSheet* parentSheet = 0) const;
     PassRefPtrWillBeRawPtr<CSSRule> createCSSOMWrapper(CSSRule* parentRule) const;
 
+    void serialize(CSSSerializeStream*) const;
+
     DECLARE_TRACE();
     DEFINE_INLINE_TRACE_AFTER_DISPATCH() { }
     void finalizeGarbageCollectedObject();
 
     // ~StyleRuleBase should be public, because non-public ~StyleRuleBase
     // causes C2248 error : 'blink::StyleRuleBase::~StyleRuleBase' : cannot
     // access protected member declared in class 'blink::StyleRuleBase' when
     // compiling 'source\wtf\refcounted.h' by using msvc.
     ~StyleRuleBase() { }
 
@@ skipping 23 matching lines @@
     const CSSSelectorList& selectorList() const { return m_selectorList; }
     const StylePropertySet& properties() const { return *m_properties; }
     MutableStylePropertySet& mutableProperties();
 
     void wrapperAdoptSelectorList(CSSSelectorList selectors) { m_selectorList = std::move(selectors); }
 
     PassRefPtrWillBeRawPtr<StyleRule> copy() const { return adoptRefWillBeNoop(new StyleRule(*this)); }
 
     static unsigned averageSizeInBytes();
 
+    static PassRefPtrWillBeRawPtr<StyleRule> deserializeAfterDispatch(CSSDeserializeStream*);
+    void serializeAfterDispatch(CSSSerializeStream*) const;
+
     DECLARE_TRACE_AFTER_DISPATCH();
 
 private:
     StyleRule(CSSSelectorList, PassRefPtrWillBeRawPtr<StylePropertySet>);
     StyleRule(const StyleRule&);
 
     RefPtrWillBeMember<StylePropertySet> m_properties; // Cannot be null.
     CSSSelectorList m_selectorList;
 };
 
 class StyleRuleFontFace : public StyleRuleBase {
 public:
     static PassRefPtrWillBeRawPtr<StyleRuleFontFace> create(PassRefPtrWillBeRawPtr<StylePropertySet> properties)
     {
         return adoptRefWillBeNoop(new StyleRuleFontFace(properties));
     }
+    static PassRefPtrWillBeRawPtr<StyleRuleFontFace> deserializeAfterDispatch(CSSDeserializeStream*);
 
     ~StyleRuleFontFace();
 
     const StylePropertySet& properties() const { return *m_properties; }
     MutableStylePropertySet& mutableProperties();
 
     PassRefPtrWillBeRawPtr<StyleRuleFontFace> copy() const { return adoptRefWillBeNoop(new StyleRuleFontFace(*this)); }
 
+    void serializeAfterDispatch(CSSSerializeStream*) const;
+
     DECLARE_TRACE_AFTER_DISPATCH();
 
 private:
     StyleRuleFontFace(PassRefPtrWillBeRawPtr<StylePropertySet>);
     StyleRuleFontFace(const StyleRuleFontFace&);
 
     RefPtrWillBeMember<StylePropertySet> m_properties; // Cannot be null.
 };
 
 class StyleRulePage : public StyleRuleBase {
@@ skipping 24 matching lines @@
     CSSSelectorList m_selectorList;
 };
 
 class StyleRuleGroup : public StyleRuleBase {
 public:
     const WillBeHeapVector<RefPtrWillBeMember<StyleRuleBase>>& childRules() const { return m_childRules; }
 
     void wrapperInsertRule(unsigned, PassRefPtrWillBeRawPtr<StyleRuleBase>);
     void wrapperRemoveRule(unsigned);
 
+    void serializeAfterDispatch(CSSSerializeStream*) const;
+    void deserializeAfterDispatch(CSSDeserializeStream*);
+
     DECLARE_TRACE_AFTER_DISPATCH();
 
 protected:
+    StyleRuleGroup(Type type)
+        : StyleRuleBase(type)
+    {
+    }
     StyleRuleGroup(Type, WillBeHeapVector<RefPtrWillBeMember<StyleRuleBase>>& adoptRule);
     StyleRuleGroup(const StyleRuleGroup&);
 
 private:
     WillBeHeapVector<RefPtrWillBeMember<StyleRuleBase>> m_childRules;
 };
 
-class StyleRuleMedia : public StyleRuleGroup {
+class StyleRuleMedia final : public StyleRuleGroup {
 public:
     static PassRefPtrWillBeRawPtr<StyleRuleMedia> create(PassRefPtrWillBeRawPtr<MediaQuerySet> media, WillBeHeapVector<RefPtrWillBeMember<StyleRuleBase>>& adoptRules)
     {
         return adoptRefWillBeNoop(new StyleRuleMedia(media, adoptRules));
     }
+    static PassRefPtrWillBeRawPtr<StyleRuleMedia> deserializeAfterDispatch(CSSDeserializeStream*);
 
     MediaQuerySet* mediaQueries() const { return m_mediaQueries.get(); }
 
     PassRefPtrWillBeRawPtr<StyleRuleMedia> copy() const { return adoptRefWillBeNoop(new StyleRuleMedia(*this)); }
 
+    void serializeAfterDispatch(CSSSerializeStream*) const;
+
     DECLARE_TRACE_AFTER_DISPATCH();
 
 private:
     StyleRuleMedia(PassRefPtrWillBeRawPtr<MediaQuerySet>, WillBeHeapVector<RefPtrWillBeMember<StyleRuleBase>>& adoptRules);
     StyleRuleMedia(const StyleRuleMedia&);
+    StyleRuleMedia()
+        : StyleRuleGroup(Media)
+    {
+    }
 
     RefPtrWillBeMember<MediaQuerySet> m_mediaQueries;
 };
 
 class StyleRuleSupports : public StyleRuleGroup {
 public:
     static PassRefPtrWillBeRawPtr<StyleRuleSupports> create(const String& conditionText, bool conditionIsSupported, WillBeHeapVector<RefPtrWillBeMember<StyleRuleBase>>& adoptRules)
     {
         return adoptRefWillBeNoop(new StyleRuleSupports(conditionText, conditionIsSupported, adoptRules));
     }
@@ skipping 54 matching lines @@
 DEFINE_STYLE_RULE_TYPE_CASTS(FontFace);
 DEFINE_STYLE_RULE_TYPE_CASTS(Page);
 DEFINE_STYLE_RULE_TYPE_CASTS(Media);
 DEFINE_STYLE_RULE_TYPE_CASTS(Supports);
 DEFINE_STYLE_RULE_TYPE_CASTS(Viewport);
 DEFINE_STYLE_RULE_TYPE_CASTS(Charset);
 
 } // namespace blink
 
 #endif // StyleRule_h