LibWeb: Avoid intermediate string allocations in typed om serialization

Author: tcl3

Libraries/LibWeb/CSS/CSSKeywordValue.cpp

@@ -5,6 +5,7 @@
  */
 
 #include "CSSKeywordValue.h"
+#include <AK/StringBuilder.h>
 #include <LibWeb/Bindings/CSSKeywordValuePrototype.h>
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/CSS/Keyword.h>
@@ -59,12 +60,19 @@ WebIDL::ExceptionOr<void> CSSKeywordValue::set_value(FlyString value)
 }
 
 // https://drafts.css-houdini.org/css-typed-om-1/#keywordvalue-serialization
-WebIDL::ExceptionOr<String> CSSKeywordValue::to_string() const
+void CSSKeywordValue::serialize(StringBuilder& builder) const
 {
     // To serialize a CSSKeywordValue this:
     // 1. Return this’s value internal slot.
     // AD-HOC: Serialize it as an identifier. Spec issue: https://github.com/w3c/csswg-drafts/issues/12545
-    return serialize_an_identifier(m_value);
+    serialize_an_identifier(builder, m_value);
+}
+
+WebIDL::ExceptionOr<String> CSSKeywordValue::to_string() const
+{
+    StringBuilder builder;
+    serialize(builder);
+    return builder.to_string_without_validation();
 }
 
 // https://drafts.css-houdini.org/css-typed-om-1/#create-an-internal-representation

Libraries/LibWeb/CSS/CSSKeywordValue.h

@@ -28,6 +28,7 @@ class CSSKeywordValue final : public CSSStyleValue {
     FlyString const& value() const { return m_value; }
     WebIDL::ExceptionOr<void> set_value(FlyString value);
 
+    void serialize(StringBuilder&) const;
     virtual WebIDL::ExceptionOr<String> to_string() const override;
     virtual WebIDL::ExceptionOr<NonnullRefPtr<StyleValue const>> create_an_internal_representation(PropertyNameAndID const&, PerformTypeCheck) const override;
 

Libraries/LibWeb/CSS/CSSMathClamp.cpp

@@ -68,18 +68,16 @@ void CSSMathClamp::visit_edges(Visitor& visitor)
 }
 
 // https://drafts.css-houdini.org/css-typed-om-1/#serialize-a-cssmathvalue
-String CSSMathClamp::serialize_math_value(Nested, Parens) const
+void CSSMathClamp::serialize_math_value(StringBuilder& s, Nested, Parens) const
 {
     // AD-HOC: The spec is missing serialization rules for CSSMathClamp: https://github.com/w3c/css-houdini-drafts/issues/1152
-    StringBuilder s;
     s.append("clamp("sv);
-    s.append(m_lower->to_string({ .nested = true, .parenless = true }));
+    m_lower->serialize(s, { .nested = true, .parenless = true });
     s.append(", "sv);
-    s.append(m_value->to_string({ .nested = true, .parenless = true }));
+    m_value->serialize(s, { .nested = true, .parenless = true });
     s.append(", "sv);
-    s.append(m_upper->to_string({ .nested = true, .parenless = true }));
-    s.append(")"sv);
-    return s.to_string_without_validation();
+    m_upper->serialize(s, { .nested = true, .parenless = true });
+    s.append(')');
 }
 
 // https://drafts.css-houdini.org/css-typed-om-1/#dom-cssmathclamp-lower

Libraries/LibWeb/CSS/CSSMathClamp.h

@@ -28,7 +28,7 @@ class CSSMathClamp final : public CSSMathValue {
     GC::Ref<CSSNumericValue> value() const;
     GC::Ref<CSSNumericValue> upper() const;
 
-    virtual String serialize_math_value(Nested, Parens) const override;
+    virtual void serialize_math_value(StringBuilder&, Nested, Parens) const override;
     virtual bool is_equal_numeric_value(GC::Ref<CSSNumericValue> other) const override;
     virtual Optional<SumValue> create_a_sum_value() const override;
 

Libraries/LibWeb/CSS/CSSMathInvert.cpp

@@ -54,19 +54,18 @@ void CSSMathInvert::visit_edges(Visitor& visitor)
 }
 
 // https://drafts.css-houdini.org/css-typed-om-1/#serialize-a-cssmathvalue
-String CSSMathInvert::serialize_math_value(Nested nested, Parens parens) const
+void CSSMathInvert::serialize_math_value(StringBuilder& s, Nested nested, Parens parens) const
 {
     // NB: Only steps 1 and 6 apply here.
     // 1. Let s initially be the empty string.
-    StringBuilder s;
 
     // 6. Otherwise, if this is a CSSMathInvert:
     {
         // 1. If paren-less is true, continue to the next step; otherwise, if nested is true, append "(" to s;
         //    otherwise, append "calc(" to s.
         if (parens == Parens::With) {
             if (nested == Nested::Yes) {
-                s.append("("sv);
+                s.append('(');
             } else {
                 s.append("calc("sv);
             }
@@ -76,14 +75,13 @@ String CSSMathInvert::serialize_math_value(Nested nested, Parens parens) const
         s.append("1 / "sv);
 
         // 3. Serialize this’s value internal slot with nested set to true, and append the result to s.
-        s.append(m_value->to_string({ .nested = true }));
+        m_value->serialize(s, { .nested = true });
 
         // 4. If paren-less is false, append ")" to s,
         if (parens == Parens::With)
-            s.append(")"sv);
+            s.append(')');
 
         // 5. Return s.
-        return s.to_string_without_validation();
     }
 }
 

Libraries/LibWeb/CSS/CSSMathInvert.h

@@ -26,7 +26,7 @@ class CSSMathInvert final : public CSSMathValue {
 
     GC::Ref<CSSNumericValue> value() const;
 
-    virtual String serialize_math_value(Nested, Parens) const override;
+    virtual void serialize_math_value(StringBuilder&, Nested, Parens) const override;
     virtual bool is_equal_numeric_value(GC::Ref<CSSNumericValue> other) const override;
     virtual Optional<SumValue> create_a_sum_value() const override;
 

Libraries/LibWeb/CSS/CSSMathMax.cpp

@@ -81,11 +81,10 @@ void CSSMathMax::visit_edges(Visitor& visitor)
 }
 
 // https://drafts.css-houdini.org/css-typed-om-1/#serialize-a-cssmathvalue
-String CSSMathMax::serialize_math_value(Nested, Parens) const
+void CSSMathMax::serialize_math_value(StringBuilder& s, Nested, Parens) const
 {
     // NB: Only steps 1 and 2 apply here.
     // 1. Let s initially be the empty string.
-    StringBuilder s;
 
     // 2. If this is a CSSMathMin or CSSMathMax:
     {
@@ -101,12 +100,11 @@ String CSSMathMax::serialize_math_value(Nested, Parens) const
             } else {
                 s.append(", "sv);
             }
-            s.append(arg->to_string({ .nested = true, .parenless = true }));
+            arg->serialize(s, { .nested = true, .parenless = true });
         }
 
         // 3. Append ")" to s and return s.
-        s.append(")"sv);
-        return s.to_string_without_validation();
+        s.append(')');
     }
 }
 

Libraries/LibWeb/CSS/CSSMathMax.h

@@ -26,7 +26,7 @@ class CSSMathMax final : public CSSMathValue {
 
     GC::Ref<CSSNumericArray> values() const;
 
-    virtual String serialize_math_value(Nested, Parens) const override;
+    virtual void serialize_math_value(StringBuilder&, Nested, Parens) const override;
     virtual bool is_equal_numeric_value(GC::Ref<CSSNumericValue> other) const override;
     virtual Optional<SumValue> create_a_sum_value() const override;
 

Libraries/LibWeb/CSS/CSSMathMin.cpp

@@ -82,11 +82,10 @@ void CSSMathMin::visit_edges(Visitor& visitor)
 }
 
 // https://drafts.css-houdini.org/css-typed-om-1/#serialize-a-cssmathvalue
-String CSSMathMin::serialize_math_value(Nested, Parens) const
+void CSSMathMin::serialize_math_value(StringBuilder& s, Nested, Parens) const
 {
     // NB: Only steps 1 and 2 apply here.
     // 1. Let s initially be the empty string.
-    StringBuilder s;
 
     // 2. If this is a CSSMathMin or CSSMathMax:
     {
@@ -102,12 +101,11 @@ String CSSMathMin::serialize_math_value(Nested, Parens) const
             } else {
                 s.append(", "sv);
             }
-            s.append(arg->to_string({ .nested = true, .parenless = true }));
+            arg->serialize(s, { .nested = true, .parenless = true });
         }
 
         // 3. Append ")" to s and return s.
-        s.append(")"sv);
-        return s.to_string_without_validation();
+        s.append(')');
     }
 }
 

Libraries/LibWeb/CSS/CSSMathMin.h

@@ -26,7 +26,7 @@ class CSSMathMin final : public CSSMathValue {
 
     GC::Ref<CSSNumericArray> values() const;
 
-    virtual String serialize_math_value(Nested, Parens) const override;
+    virtual void serialize_math_value(StringBuilder&, Nested, Parens) const override;
     virtual bool is_equal_numeric_value(GC::Ref<CSSNumericValue> other) const override;
     virtual Optional<SumValue> create_a_sum_value() const override;