[Experimental] CSSSerializer Proof-of-concept

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

 /*
  * Copyright (C) 2008 Apple Inc.  All rights reserved.
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 10 matching lines @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/css/CSSGradientValue.h"
 
 #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"
 #include "platform/geometry/IntSize.h"
 #include "platform/graphics/Gradient.h"
 #include "platform/graphics/GradientGeneratedImage.h"
 #include "platform/graphics/Image.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/WTFString.h"
 #include <algorithm>
 #include <utility>
 
 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);
     visitor->trace(m_color);
 }
 
 PassRefPtr<Image> CSSGradientValue::image(const LayoutObject* layoutObject, const IntSize& size)
 {
     if (size.isEmpty())
         return nullptr;
@@ skipping 517 matching lines @@
 void CSSGradientValue::getStopColors(WillBeHeapVector<Color>& stopColors, const LayoutObject* object) const
 {
     ASSERT(object);
     for (auto& stop : m_stops) {
         if (!stop.isHint())
             stopColors.append(resolveStopColor(*stop.m_color, *object));
     }
 
 }
 
+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)
     visitor->trace(m_firstX);
     visitor->trace(m_firstY);
     visitor->trace(m_secondX);
     visitor->trace(m_secondY);
     visitor->trace(m_stops);
 #endif
     CSSImageGeneratorValue::traceAfterDispatch(visitor);
@@ skipping 248 matching lines @@
     else if (m_firstX)
         equalXandY = compareCSSValuePtr(m_firstX, other.m_firstX) && !other.m_firstY;
     else if (m_firstY)
         equalXandY = compareCSSValuePtr(m_firstY, other.m_firstY) && !other.m_firstX;
     else
         equalXandY = !other.m_firstX && !other.m_firstY;
 
     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);
     CSSGradientValue::traceAfterDispatch(visitor);
 }
 
 inline void CSSGradientValue::appendCSSTextForDeprecatedColorStops(StringBuilder& result) const
 {
     for (unsigned i = 0; i < m_stops.size(); i++) {
         const CSSGradientColorStop& stop = m_stops[i];
@@ skipping 343 matching lines @@
     else if (m_endHorizontalSize && m_endVerticalSize)
         equalHorizontalAndVerticalSize = compareCSSValuePtr(m_endHorizontalSize, other.m_endHorizontalSize) && compareCSSValuePtr(m_endVerticalSize, other.m_endVerticalSize);
     else {
         equalShape = !other.m_shape;
         equalSizingBehavior = !other.m_sizingBehavior;
         equalHorizontalAndVerticalSize = !other.m_endHorizontalSize && !other.m_endVerticalSize;
     }
     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);
     visitor->trace(m_secondRadius);
     visitor->trace(m_shape);
     visitor->trace(m_sizingBehavior);
     visitor->trace(m_endHorizontalSize);
     visitor->trace(m_endVerticalSize);
     CSSGradientValue::traceAfterDispatch(visitor);
 }
 
 } // namespace blink