[Experimental] CSSSerializer Proof-of-concept

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

Index: third_party/WebKit/Source/core/css/CSSGradientValue.cpp
diff --git a/third_party/WebKit/Source/core/css/CSSGradientValue.cpp b/third_party/WebKit/Source/core/css/CSSGradientValue.cpp
index 0a76377836fe4ace2f8c270281870a49f2a9ceda..02bcc5ae2d8b4d552a464a643a1220e265e94824 100644
--- a/third_party/WebKit/Source/core/css/CSSGradientValue.cpp
+++ b/third_party/WebKit/Source/core/css/CSSGradientValue.cpp
@@ -28,8 +28,11 @@
 
 #include "core/CSSValueKeywords.h"
 #include "core/css/CSSCalculationValue.h"
+#include "core/css/CSSColorValue.h"
 #include "core/css/CSSToLengthConversionData.h"
 #include "core/css/CSSValuePair.h"
+#include "core/css/serializer/CSSDeserializeStream.h"
+#include "core/css/serializer/CSSSerializeStream.h"
 #include "core/dom/NodeComputedStyle.h"
 #include "core/dom/TextLinkColors.h"
 #include "core/layout/LayoutObject.h"
@@ -45,6 +48,20 @@
 
 namespace blink {
 
+void CSSGradientColorStop::deserialize(CSSDeserializeStream* stream)
+{
+    m_position = stream->readNullableRef<CSSPrimitiveValue>();
+    m_color = stream->readNullableRef<CSSValue>();
+    m_colorIsDerivedFromElement = stream->readBool();
+}
+
+void CSSGradientColorStop::serialize(CSSSerializeStream* stream) const
+{
+    m_position->serialize(stream);
+    m_color->serialize(stream);
+    stream->writeBool(m_colorIsDerivedFromElement);
+}
+
 DEFINE_TRACE(CSSGradientColorStop)
 {
     visitor->trace(m_position);
@@ -582,6 +599,39 @@ void CSSGradientValue::getStopColors(WillBeHeapVector<Color>& stopColors, const
 
 }
 
+void CSSGradientValue::serializeAfterDispatch(CSSSerializeStream* stream) const
+{
+    m_firstX->serialize(stream);
+    m_firstY->serialize(stream);
+    m_secondX->serialize(stream);
+    m_secondY->serialize(stream);
+
+    stream->writeUnsigned(m_stops.size());
+    for (const CSSGradientColorStop& stop : m_stops) {
+         stop.serialize(stream);
+    }
+
+    stream->writeEnumAsInt<CSSGradientType>(m_gradientType);
+    stream->writeBool(m_repeating);
+}
+
+void CSSGradientValue::deserializeAfterDispatch(CSSDeserializeStream* stream)
+{
+    m_firstX = stream->readNullableRef<CSSValue>();
+    m_firstY = stream->readNullableRef<CSSValue>();
+    m_secondX = stream->readNullableRef<CSSValue>();
+    m_secondY = stream->readNullableRef<CSSValue>();
+
+    unsigned stopsSize = stream->readUnsigned();
+    m_stops.resize(stopsSize);
+    for (unsigned i = 0; i < stopsSize; ++ i) {
+        m_stops[i].deserialize(stream);
+    }
+    
+    m_gradientType = stream->readIntAsEnum<CSSGradientType>();
+    m_repeating = stream->readBool();
+}
+
 DEFINE_TRACE_AFTER_DISPATCH(CSSGradientValue)
 {
 #if ENABLE(OILPAN)
@@ -850,6 +900,22 @@ bool CSSLinearGradientValue::equals(const CSSLinearGradientValue& other) const
     return equalXandY && m_stops == other.m_stops;
 }
 
+void CSSLinearGradientValue::serializeAfterDispatch(CSSSerializeStream* stream) const
+{
+    CSSGradientValue::serializeAfterDispatch(stream);
+    stream->serializeNullable(m_angle);
+}
+
+PassRefPtrWillBeRawPtr<CSSLinearGradientValue> CSSLinearGradientValue::deserializeAfterDispatch(CSSDeserializeStream* stream)
+{
+    RefPtrWillBeRawPtr<CSSLinearGradientValue> value = create(NonRepeating /* dummy */);
+
+    value->CSSGradientValue::deserializeAfterDispatch(stream);
+    value->m_angle = stream->readNullableRef<CSSPrimitiveValue>();
+
+    return value.release();
+}
+
 DEFINE_TRACE_AFTER_DISPATCH(CSSLinearGradientValue)
 {
     visitor->trace(m_angle);
@@ -1213,6 +1279,32 @@ bool CSSRadialGradientValue::equals(const CSSRadialGradientValue& other) const
     return equalShape && equalSizingBehavior && equalHorizontalAndVerticalSize && m_stops == other.m_stops;
 }
 
+void CSSRadialGradientValue::serializeAfterDispatch(CSSSerializeStream* stream) const
+{
+    CSSGradientValue::serializeAfterDispatch(stream);
+    stream->serializeNullable(m_firstRadius);
+    stream->serializeNullable(m_secondRadius);
+    stream->serializeNullable(m_shape);
+    stream->serializeNullable(m_sizingBehavior);
+    stream->serializeNullable(m_endHorizontalSize);
+    stream->serializeNullable(m_endVerticalSize);
+}
+
+PassRefPtrWillBeRawPtr<CSSRadialGradientValue> CSSRadialGradientValue::deserializeAfterDispatch(CSSDeserializeStream* stream)
+{
+    RefPtrWillBeRawPtr<CSSRadialGradientValue> value = create(NonRepeating /* dummy */);
+
+    value->CSSGradientValue::deserializeAfterDispatch(stream);
+    value->m_firstRadius = stream->readNullableRef<CSSPrimitiveValue>();
+    value->m_secondRadius = stream->readNullableRef<CSSPrimitiveValue>();
+    value->m_shape = stream->readNullableRef<CSSPrimitiveValue>();
+    value->m_sizingBehavior = stream->readNullableRef<CSSPrimitiveValue>();
+    value->m_endHorizontalSize = stream->readNullableRef<CSSPrimitiveValue>();
+    value->m_endVerticalSize = stream->readNullableRef<CSSPrimitiveValue>();
+
+    return value.release();
+}
+
 DEFINE_TRACE_AFTER_DISPATCH(CSSRadialGradientValue)
 {
     visitor->trace(m_firstRadius);