[Experimental] CSSSerializer Proof-of-concept

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

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 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.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 13 matching lines @@
 #include "core/CoreExport.h"
 #include "platform/heap/Handle.h"
 #include "platform/weborigin/KURL.h"
 #include "wtf/HashMap.h"
 #include "wtf/ListHashSet.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
+class CSSDeserializeStream;
+class CSSSerializeStream;
+
 class CORE_EXPORT CSSValue : public RefCountedWillBeGarbageCollectedFinalized<CSSValue> {
 #if ENABLE(OILPAN)
 public:
     // Override operator new to allocate CSSValue subtype objects onto
     // a dedicated heap.
     GC_PLUGIN_IGNORE("crbug.com/443854")
     void* operator new(size_t size)
     {
         return allocateObject(size, false);
     }
@@ skipping 61 matching lines @@
     bool isContentDistributionValue() const { return m_classType == CSSContentDistributionClass; }
     bool isUnicodeRangeValue() const { return m_classType == UnicodeRangeClass; }
     bool isGridLineNamesValue() const { return m_classType == GridLineNamesClass; }
     bool isCustomPropertyDeclaration() const { return m_classType == CustomPropertyDeclarationClass; }
     bool isVariableReferenceValue() const { return m_classType == VariableReferenceClass; }
 
     bool hasFailedOrCanceledSubresources() const;
 
     bool equals(const CSSValue&) const;
 
+    static PassRefPtrWillBeRawPtr<CSSValue> deserialize(CSSDeserializeStream*);
+    void serialize(CSSSerializeStream*) const;
+
     void finalizeGarbageCollectedObject();
     DEFINE_INLINE_TRACE_AFTER_DISPATCH() { }
     DECLARE_TRACE();
 
     // ~CSSValue should be public, because non-public ~CSSValue causes C2248
     // error: 'blink::CSSValue::~CSSValue' : cannot access protected member
     // declared in class 'blink::CSSValue' when compiling
     // 'source\wtf\refcounted.h' by using msvc.
     ~CSSValue() { }
 
-protected:
+    //  protected:
+public:
     static const size_t ClassTypeBits = 6;
     enum ClassType {
         PrimitiveClass,
         ColorClass,
         CounterClass,
         QuadClass,
         CustomIdentClass,
         StringClass,
         URIClass,
         ValuePairClass,
@@ skipping 69 matching lines @@
     // Don't go making it virtual again unless you know exactly what you're doing!
 
 private:
     void destroy();
 
 protected:
     // The bits in this section are only used by specific subclasses but kept here
     // to maximize struct packing.
 
     // CSSPrimitiveValue bits:
-    unsigned m_primitiveUnitType : 7; // CSSPrimitiveValue::UnitType
-    mutable unsigned m_hasCachedCSSText : 1;
+    union {
+        struct {
+            unsigned m_primitiveUnitType : 7; // CSSPrimitiveValue::UnitType
+            mutable unsigned m_hasCachedCSSText : 1;
 
-    unsigned m_valueListSeparator : ValueListSeparatorBits;
+            unsigned m_valueListSeparator : ValueListSeparatorBits;
 
-private:
-    unsigned m_classType : ClassTypeBits; // ClassType
+            // private:
+            unsigned m_classType : ClassTypeBits; // ClassType
+        };
+        unsigned m_bitfields;
+    };
+
+    union aaaa {
+        struct {
+            unsigned m_primitiveUnitType : 7; // CSSPrimitiveValue::UnitType
+            mutable unsigned m_hasCachedCSSText : 1;
+
+            unsigned m_valueListSeparator : ValueListSeparatorBits;
+
+            // private:
+            unsigned m_classType : ClassTypeBits; // ClassType
+        };
+        unsigned m_bitfields;
+    };
 };
 
 template<typename CSSValueType, size_t inlineCapacity>
 inline bool compareCSSValueVector(const WillBeHeapVector<RefPtrWillBeMember<CSSValueType>, inlineCapacity>& firstVector, const WillBeHeapVector<RefPtrWillBeMember<CSSValueType>, inlineCapacity>& secondVector)
 {
     size_t size = firstVector.size();
     if (size != secondVector.size())
         return false;
 
     for (size_t i = 0; i < size; i++) {
@@ skipping 29 matching lines @@
 template<typename CSSValueType>
 inline bool compareCSSValuePtr(const Member<CSSValueType>& first, const Member<CSSValueType>& second)
 {
     if (first == second)
         return true;
     if (!first || !second)
         return false;
     return first->equals(*second);
 }
 
+template<typename T> class CSSSerializeTrait;
+template<> class CSSSerializeTrait<CSSValue> {
+public:
+    static void serializeNull(CSSSerializeStream*);
+    static void serializeNonNullHeader(CSSSerializeStream*) { }
+};
+
+template<typename T> class CSSDeserializeTrait;
+template<> class CSSDeserializeTrait<CSSValue> {
+public:
+    static bool deserializeNonNullHeader(CSSDeserializeStream*)
+    { 
+        // CSSValue::deserialize will return nullptr if needed.
+        return true;
+    }
+};
+
 #define DEFINE_CSS_VALUE_TYPE_CASTS(thisType, predicate) \
     DEFINE_TYPE_CASTS(thisType, CSSValue, value, value->predicate, value.predicate)
 
 } // namespace blink
 
 #endif // CSSValue_h