[Experimental] CSSSerializer Proof-of-concept

third_party/WebKit/Source/core/css/CSSCalculationValue.cpp

Index: third_party/WebKit/Source/core/css/CSSCalculationValue.cpp
diff --git a/third_party/WebKit/Source/core/css/CSSCalculationValue.cpp b/third_party/WebKit/Source/core/css/CSSCalculationValue.cpp
index dfe32bce2c636a25c0342ae3b9ee004cfb6b12a9..ab9cb99d8e93e508a69bb7775f7c27f48426f36a 100644
--- a/third_party/WebKit/Source/core/css/CSSCalculationValue.cpp
+++ b/third_party/WebKit/Source/core/css/CSSCalculationValue.cpp
@@ -32,6 +32,8 @@
 
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/resolver/StyleResolver.h"
+#include "core/css/serializer/CSSDeserializeStream.h"
+#include "core/css/serializer/CSSSerializeStream.h"
 #include "wtf/MathExtras.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/text/StringBuilder.h"
@@ -262,6 +264,17 @@ public:
         return m_value->typeWithCalcResolved();
     }
 
+    void serialize(CSSSerializeStream* stream) const override
+    {
+        CSSCalcExpressionNode::serialize(stream);
+        m_value->serialize(stream);
+    }
+    
+    static PassRefPtrWillBeRawPtr<CSSCalcPrimitiveValue> deserializeAfterDispatch(CalculationCategory category, bool isInteger, CSSDeserializeStream* stream)
+    {
+        RefPtrWillBeRawPtr<CSSPrimitiveValue> value = stream->readNullableRef<CSSPrimitiveValue>();
+        return create(value.release(), isInteger);
+    }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
@@ -529,6 +542,22 @@ public:
         return CSSPrimitiveValue::UnitType::Unknown;
     }
 
+    void serialize(CSSSerializeStream* stream) const override
+    {
+        CSSCalcExpressionNode::serialize(stream);
+        m_leftSide->serialize(stream);
+        m_rightSide->serialize(stream);
+        stream->writeEnumAsInt<CalcOperator>(m_operator);
+    }
+
+    static PassRefPtrWillBeRawPtr<CSSCalcBinaryOperation> deserializeAfterDispatch(CalculationCategory category, bool isInteger, CSSDeserializeStream* stream)
+    {
+        RefPtrWillBeRawPtr<CSSCalcExpressionNode> leftSide = CSSCalcExpressionNode::deserialize(stream);
+        RefPtrWillBeRawPtr<CSSCalcExpressionNode> rightSide = CSSCalcExpressionNode::deserialize(stream);
+        CalcOperator calcOperator = stream->readIntAsEnum<CalcOperator>();
+        return adoptRefWillBeNoop(new CSSCalcBinaryOperation(leftSide.release(), rightSide.release(), calcOperator, category));
+    }
+
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_leftSide);
@@ -730,6 +759,29 @@ PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> CSSCalcValue::createExpressionNode
         CalcAdd);
 }
 
+void CSSCalcExpressionNode::serialize(CSSSerializeStream* stream) const
+{
+    stream->writeEnumAsInt<Type>(type());
+    stream->writeEnumAsInt<CalculationCategory>(m_category);
+    stream->writeBool(m_isInteger);
+}
+
+PassRefPtrWillBeRawPtr<CSSCalcExpressionNode> CSSCalcExpressionNode::deserialize(CSSDeserializeStream* stream)
+{
+    Type type = stream->readIntAsEnum<Type>();
+    CalculationCategory category = stream->readIntAsEnum<CalculationCategory>();    
+    bool isInteger = stream->readBool();
+    
+    switch (type) {
+    case CssCalcPrimitiveValue:
+        return CSSCalcPrimitiveValue::deserializeAfterDispatch(category, isInteger, stream);
+    case CssCalcBinaryOperation:
+        return CSSCalcBinaryOperation::deserializeAfterDispatch(category, isInteger, stream);
+    default:
+        ASSERT_NOT_REACHED();
+    }
+}
+
 PassRefPtrWillBeRawPtr<CSSCalcValue> CSSCalcValue::create(const CSSParserTokenRange& tokens, ValueRange range)
 {
     CSSCalcExpressionNodeParser parser;
@@ -743,4 +795,17 @@ PassRefPtrWillBeRawPtr<CSSCalcValue> CSSCalcValue::create(PassRefPtrWillBeRawPtr
     return adoptRefWillBeNoop(new CSSCalcValue(expression, range));
 }
 
+void CSSCalcValue::serialize(CSSSerializeStream* stream) const
+{
+    m_expression->serialize(stream);
+    stream->writeBool(m_nonNegative);
+}
+
+PassRefPtrWillBeRawPtr<CSSCalcValue> CSSCalcValue::deserialize(CSSDeserializeStream* stream)
+{
+    RefPtrWillBeRawPtr<CSSCalcExpressionNode> expression = CSSCalcExpressionNode::deserialize(stream);
+    bool nonNegative = stream->readBool();
+    return create(expression.release(), nonNegative ? ValueRangeNonNegative : ValueRangeAll);
+}
+
 } // namespace blink