LibWeb: Make storage of CSS::StyleValues const-correct

Now we consistently use `RefPtr<StyleValue const>` for all StyleValues.
This commit is contained in:
Andrew Kaster 2025-04-15 15:18:27 -06:00 committed by Andrew Kaster
commit 6d11414957
Notes: github-actions[bot] 2025-04-16 16:44:32 +00:00
113 changed files with 628 additions and 629 deletions

View file

@ -165,7 +165,7 @@ struct ColorStopListElement {
Optional<ColorHint> transition_hint;
struct ColorStop {
RefPtr<CSSStyleValue> color;
RefPtr<CSSStyleValue const> color;
Optional<TPosition> position;
Optional<TPosition> second_position = {};
inline bool operator==(ColorStop const&) const = default;

View file

@ -16,7 +16,7 @@ namespace Web::CSS {
class AngleStyleValue : public CSSUnitValue {
public:
static ValueComparingNonnullRefPtr<AngleStyleValue> create(Angle angle)
static ValueComparingNonnullRefPtr<AngleStyleValue const> create(Angle angle)
{
return adopt_ref(*new (nothrow) AngleStyleValue(move(angle)));
}

View file

@ -16,7 +16,7 @@ namespace Web::CSS {
class BackgroundRepeatStyleValue final : public StyleValueWithDefaultOperators<BackgroundRepeatStyleValue> {
public:
static ValueComparingNonnullRefPtr<BackgroundRepeatStyleValue> create(Repeat repeat_x, Repeat repeat_y)
static ValueComparingNonnullRefPtr<BackgroundRepeatStyleValue const> create(Repeat repeat_x, Repeat repeat_y)
{
return adopt_ref(*new (nothrow) BackgroundRepeatStyleValue(repeat_x, repeat_y));
}

View file

@ -18,7 +18,7 @@ namespace Web::CSS {
// NOTE: This is not used for identifier sizes, like `cover` and `contain`.
class BackgroundSizeStyleValue final : public StyleValueWithDefaultOperators<BackgroundSizeStyleValue> {
public:
static ValueComparingNonnullRefPtr<BackgroundSizeStyleValue> create(LengthPercentage size_x, LengthPercentage size_y)
static ValueComparingNonnullRefPtr<BackgroundSizeStyleValue const> create(LengthPercentage size_x, LengthPercentage size_y)
{
return adopt_ref(*new (nothrow) BackgroundSizeStyleValue(size_x, size_y));
}

View file

@ -59,7 +59,7 @@ struct Circle {
bool operator==(Circle const&) const = default;
ShapeRadius radius;
ValueComparingNonnullRefPtr<PositionStyleValue> position;
ValueComparingNonnullRefPtr<PositionStyleValue const> position;
};
struct Ellipse {
@ -70,7 +70,7 @@ struct Ellipse {
ShapeRadius radius_x;
ShapeRadius radius_y;
ValueComparingNonnullRefPtr<PositionStyleValue> position;
ValueComparingNonnullRefPtr<PositionStyleValue const> position;
};
struct Polygon {
@ -94,7 +94,7 @@ using BasicShape = Variant<Inset, Xywh, Rect, Circle, Ellipse, Polygon>;
class BasicShapeStyleValue : public StyleValueWithDefaultOperators<BasicShapeStyleValue> {
public:
static ValueComparingNonnullRefPtr<BasicShapeStyleValue> create(BasicShape basic_shape)
static ValueComparingNonnullRefPtr<BasicShapeStyleValue const> create(BasicShape basic_shape)
{
return adopt_ref(*new (nothrow) BasicShapeStyleValue(move(basic_shape)));
}

View file

@ -17,7 +17,7 @@ namespace Web::CSS {
class BorderRadiusStyleValue final : public StyleValueWithDefaultOperators<BorderRadiusStyleValue> {
public:
static ValueComparingNonnullRefPtr<BorderRadiusStyleValue> create(LengthPercentage const& horizontal_radius, LengthPercentage const& vertical_radius)
static ValueComparingNonnullRefPtr<BorderRadiusStyleValue const> create(LengthPercentage const& horizontal_radius, LengthPercentage const& vertical_radius)
{
return adopt_ref(*new (nothrow) BorderRadiusStyleValue(horizontal_radius, vertical_radius));
}

View file

@ -18,7 +18,7 @@
namespace Web::CSS {
ValueComparingNonnullRefPtr<CSSColorValue> CSSColorValue::create_from_color(Color color, ColorSyntax color_syntax, Optional<FlyString> name)
ValueComparingNonnullRefPtr<CSSColorValue const> CSSColorValue::create_from_color(Color color, ColorSyntax color_syntax, Optional<FlyString> name)
{
return CSSRGB::create(
NumberStyleValue::create(color.red()),

View file

@ -23,7 +23,7 @@ enum class ColorSyntax : u8 {
// https://drafts.css-houdini.org/css-typed-om-1/#csscolorvalue
class CSSColorValue : public CSSStyleValue {
public:
static ValueComparingNonnullRefPtr<CSSColorValue> create_from_color(Color color, ColorSyntax color_syntax, Optional<FlyString> name = {});
static ValueComparingNonnullRefPtr<CSSColorValue const> create_from_color(Color color, ColorSyntax color_syntax, Optional<FlyString> name = {});
virtual ~CSSColorValue() override = default;
virtual bool has_color() const override { return true; }

View file

@ -14,7 +14,7 @@ namespace Web::CSS {
// https://drafts.css-houdini.org/css-typed-om-1/#csshsl
class CSSHSL final : public CSSColorValue {
public:
static ValueComparingNonnullRefPtr<CSSHSL> create(ValueComparingNonnullRefPtr<CSSStyleValue> h, ValueComparingNonnullRefPtr<CSSStyleValue> s, ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingRefPtr<CSSStyleValue> alpha, ColorSyntax color_syntax)
static ValueComparingNonnullRefPtr<CSSHSL const> create(ValueComparingNonnullRefPtr<CSSStyleValue const> h, ValueComparingNonnullRefPtr<CSSStyleValue const> s, ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingRefPtr<CSSStyleValue const> alpha, ColorSyntax color_syntax)
{
// alpha defaults to 1
if (!alpha)
@ -36,17 +36,17 @@ public:
virtual bool equals(CSSStyleValue const& other) const override;
private:
CSSHSL(ValueComparingNonnullRefPtr<CSSStyleValue> h, ValueComparingNonnullRefPtr<CSSStyleValue> s, ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> alpha, ColorSyntax color_syntax)
CSSHSL(ValueComparingNonnullRefPtr<CSSStyleValue const> h, ValueComparingNonnullRefPtr<CSSStyleValue const> s, ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha, ColorSyntax color_syntax)
: CSSColorValue(ColorType::HSL, color_syntax)
, m_properties { .h = move(h), .s = move(s), .l = move(l), .alpha = move(alpha) }
{
}
struct Properties {
ValueComparingNonnullRefPtr<CSSStyleValue> h;
ValueComparingNonnullRefPtr<CSSStyleValue> s;
ValueComparingNonnullRefPtr<CSSStyleValue> l;
ValueComparingNonnullRefPtr<CSSStyleValue> alpha;
ValueComparingNonnullRefPtr<CSSStyleValue const> h;
ValueComparingNonnullRefPtr<CSSStyleValue const> s;
ValueComparingNonnullRefPtr<CSSStyleValue const> l;
ValueComparingNonnullRefPtr<CSSStyleValue const> alpha;
bool operator==(Properties const&) const = default;
} m_properties;
};

View file

@ -14,7 +14,7 @@ namespace Web::CSS {
// https://drafts.css-houdini.org/css-typed-om-1/#csshwb
class CSSHWB final : public CSSColorValue {
public:
static ValueComparingNonnullRefPtr<CSSHWB> create(ValueComparingNonnullRefPtr<CSSStyleValue> h, ValueComparingNonnullRefPtr<CSSStyleValue> w, ValueComparingNonnullRefPtr<CSSStyleValue> b, ValueComparingRefPtr<CSSStyleValue> alpha = {})
static ValueComparingNonnullRefPtr<CSSHWB const> create(ValueComparingNonnullRefPtr<CSSStyleValue const> h, ValueComparingNonnullRefPtr<CSSStyleValue const> w, ValueComparingNonnullRefPtr<CSSStyleValue const> b, ValueComparingRefPtr<CSSStyleValue const> alpha = {})
{
// alpha defaults to 1
if (!alpha)
@ -36,17 +36,17 @@ public:
virtual bool equals(CSSStyleValue const& other) const override;
private:
CSSHWB(ValueComparingNonnullRefPtr<CSSStyleValue> h, ValueComparingNonnullRefPtr<CSSStyleValue> w, ValueComparingNonnullRefPtr<CSSStyleValue> b, ValueComparingNonnullRefPtr<CSSStyleValue> alpha)
CSSHWB(ValueComparingNonnullRefPtr<CSSStyleValue const> h, ValueComparingNonnullRefPtr<CSSStyleValue const> w, ValueComparingNonnullRefPtr<CSSStyleValue const> b, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha)
: CSSColorValue(ColorType::HWB, ColorSyntax::Modern)
, m_properties { .h = move(h), .w = move(w), .b = move(b), .alpha = move(alpha) }
{
}
struct Properties {
ValueComparingNonnullRefPtr<CSSStyleValue> h;
ValueComparingNonnullRefPtr<CSSStyleValue> w;
ValueComparingNonnullRefPtr<CSSStyleValue> b;
ValueComparingNonnullRefPtr<CSSStyleValue> alpha;
ValueComparingNonnullRefPtr<CSSStyleValue const> h;
ValueComparingNonnullRefPtr<CSSStyleValue const> w;
ValueComparingNonnullRefPtr<CSSStyleValue const> b;
ValueComparingNonnullRefPtr<CSSStyleValue const> alpha;
bool operator==(Properties const&) const = default;
} m_properties;
};

View file

@ -17,28 +17,28 @@ namespace Web::CSS {
// https://drafts.css-houdini.org/css-typed-om-1/#csskeywordvalue
class CSSKeywordValue : public StyleValueWithDefaultOperators<CSSKeywordValue> {
public:
static ValueComparingNonnullRefPtr<CSSKeywordValue> create(Keyword keyword)
static ValueComparingNonnullRefPtr<CSSKeywordValue const> create(Keyword keyword)
{
// NOTE: We'll have to be much more careful with caching once we expose CSSKeywordValue to JS, as it's mutable.
switch (keyword) {
case Keyword::Inherit: {
static ValueComparingNonnullRefPtr<CSSKeywordValue> const inherit_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::Inherit));
static ValueComparingNonnullRefPtr<CSSKeywordValue const> const inherit_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::Inherit));
return inherit_instance;
}
case Keyword::Initial: {
static ValueComparingNonnullRefPtr<CSSKeywordValue> const initial_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::Initial));
static ValueComparingNonnullRefPtr<CSSKeywordValue const> const initial_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::Initial));
return initial_instance;
}
case Keyword::Revert: {
static ValueComparingNonnullRefPtr<CSSKeywordValue> const revert_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::Revert));
static ValueComparingNonnullRefPtr<CSSKeywordValue const> const revert_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::Revert));
return revert_instance;
}
case Keyword::RevertLayer: {
static ValueComparingNonnullRefPtr<CSSKeywordValue> const revert_layer_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::RevertLayer));
static ValueComparingNonnullRefPtr<CSSKeywordValue const> const revert_layer_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::RevertLayer));
return revert_layer_instance;
}
case Keyword::Unset: {
static ValueComparingNonnullRefPtr<CSSKeywordValue> const unset_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::Unset));
static ValueComparingNonnullRefPtr<CSSKeywordValue const> const unset_instance = adopt_ref(*new (nothrow) CSSKeywordValue(Keyword::Unset));
return unset_instance;
}
default:

View file

@ -14,7 +14,7 @@ namespace Web::CSS {
class CSSLCHLike : public CSSColorValue {
public:
template<DerivedFrom<CSSLCHLike> T>
static ValueComparingNonnullRefPtr<T> create(ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> c, ValueComparingNonnullRefPtr<CSSStyleValue> h, ValueComparingRefPtr<CSSStyleValue> alpha = {})
static ValueComparingNonnullRefPtr<T const> create(ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> c, ValueComparingNonnullRefPtr<CSSStyleValue const> h, ValueComparingRefPtr<CSSStyleValue const> alpha = {})
{
// alpha defaults to 1
if (!alpha)
@ -32,17 +32,17 @@ public:
virtual bool equals(CSSStyleValue const& other) const override;
protected:
CSSLCHLike(ColorType color_type, ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> c, ValueComparingNonnullRefPtr<CSSStyleValue> h, ValueComparingNonnullRefPtr<CSSStyleValue> alpha)
CSSLCHLike(ColorType color_type, ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> c, ValueComparingNonnullRefPtr<CSSStyleValue const> h, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha)
: CSSColorValue(color_type, ColorSyntax::Modern)
, m_properties { .l = move(l), .c = move(c), .h = move(h), .alpha = move(alpha) }
{
}
struct Properties {
ValueComparingNonnullRefPtr<CSSStyleValue> l;
ValueComparingNonnullRefPtr<CSSStyleValue> c;
ValueComparingNonnullRefPtr<CSSStyleValue> h;
ValueComparingNonnullRefPtr<CSSStyleValue> alpha;
ValueComparingNonnullRefPtr<CSSStyleValue const> l;
ValueComparingNonnullRefPtr<CSSStyleValue const> c;
ValueComparingNonnullRefPtr<CSSStyleValue const> h;
ValueComparingNonnullRefPtr<CSSStyleValue const> alpha;
bool operator==(Properties const&) const = default;
} m_properties;
};
@ -50,7 +50,7 @@ protected:
// https://drafts.css-houdini.org/css-typed-om-1/#csslch
class CSSLCH final : public CSSLCHLike {
public:
CSSLCH(Badge<CSSLCHLike>, ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> c, ValueComparingNonnullRefPtr<CSSStyleValue> h, ValueComparingNonnullRefPtr<CSSStyleValue> alpha)
CSSLCH(Badge<CSSLCHLike>, ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> c, ValueComparingNonnullRefPtr<CSSStyleValue const> h, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha)
: CSSLCHLike(ColorType::LCH, move(l), move(c), move(h), move(alpha))
{
}
@ -64,7 +64,7 @@ public:
// https://drafts.css-houdini.org/css-typed-om-1/#cssoklch
class CSSOKLCH final : public CSSLCHLike {
public:
CSSOKLCH(Badge<CSSLCHLike>, ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> c, ValueComparingNonnullRefPtr<CSSStyleValue> h, ValueComparingNonnullRefPtr<CSSStyleValue> alpha)
CSSOKLCH(Badge<CSSLCHLike>, ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> c, ValueComparingNonnullRefPtr<CSSStyleValue const> h, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha)
: CSSLCHLike(ColorType::OKLCH, move(l), move(c), move(h), move(alpha))
{
}

View file

@ -14,7 +14,7 @@ namespace Web::CSS {
class CSSLabLike : public CSSColorValue {
public:
template<typename T>
static ValueComparingNonnullRefPtr<T> create(ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> a, ValueComparingNonnullRefPtr<CSSStyleValue> b, ValueComparingRefPtr<CSSStyleValue> alpha = {})
static ValueComparingNonnullRefPtr<T const> create(ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> a, ValueComparingNonnullRefPtr<CSSStyleValue const> b, ValueComparingRefPtr<CSSStyleValue const> alpha = {})
{
// alpha defaults to 1
if (!alpha)
@ -33,17 +33,17 @@ public:
virtual bool equals(CSSStyleValue const& other) const override;
protected:
CSSLabLike(ColorType color_type, ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> a, ValueComparingNonnullRefPtr<CSSStyleValue> b, ValueComparingNonnullRefPtr<CSSStyleValue> alpha)
CSSLabLike(ColorType color_type, ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> a, ValueComparingNonnullRefPtr<CSSStyleValue const> b, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha)
: CSSColorValue(color_type, ColorSyntax::Modern)
, m_properties { .l = move(l), .a = move(a), .b = move(b), .alpha = move(alpha) }
{
}
struct Properties {
ValueComparingNonnullRefPtr<CSSStyleValue> l;
ValueComparingNonnullRefPtr<CSSStyleValue> a;
ValueComparingNonnullRefPtr<CSSStyleValue> b;
ValueComparingNonnullRefPtr<CSSStyleValue> alpha;
ValueComparingNonnullRefPtr<CSSStyleValue const> l;
ValueComparingNonnullRefPtr<CSSStyleValue const> a;
ValueComparingNonnullRefPtr<CSSStyleValue const> b;
ValueComparingNonnullRefPtr<CSSStyleValue const> alpha;
bool operator==(Properties const&) const = default;
} m_properties;
};
@ -54,7 +54,7 @@ public:
virtual Color to_color(Optional<Layout::NodeWithStyle const&>) const override;
virtual String to_string(SerializationMode) const override;
CSSOKLab(Badge<CSSLabLike>, ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> a, ValueComparingNonnullRefPtr<CSSStyleValue> b, ValueComparingNonnullRefPtr<CSSStyleValue> alpha)
CSSOKLab(Badge<CSSLabLike>, ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> a, ValueComparingNonnullRefPtr<CSSStyleValue const> b, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha)
: CSSLabLike(ColorType::OKLab, move(l), move(a), move(b), move(alpha))
{
}
@ -66,7 +66,7 @@ public:
virtual Color to_color(Optional<Layout::NodeWithStyle const&>) const override;
virtual String to_string(SerializationMode) const override;
CSSLab(Badge<CSSLabLike>, ValueComparingNonnullRefPtr<CSSStyleValue> l, ValueComparingNonnullRefPtr<CSSStyleValue> a, ValueComparingNonnullRefPtr<CSSStyleValue> b, ValueComparingNonnullRefPtr<CSSStyleValue> alpha)
CSSLab(Badge<CSSLabLike>, ValueComparingNonnullRefPtr<CSSStyleValue const> l, ValueComparingNonnullRefPtr<CSSStyleValue const> a, ValueComparingNonnullRefPtr<CSSStyleValue const> b, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha)
: CSSLabLike(ColorType::Lab, move(l), move(a), move(b), move(alpha))
{
}

View file

@ -15,7 +15,7 @@ class CSSLightDark final : public CSSColorValue {
public:
virtual ~CSSLightDark() override = default;
static ValueComparingNonnullRefPtr<CSSLightDark> create(ValueComparingNonnullRefPtr<CSSStyleValue> light, ValueComparingNonnullRefPtr<CSSStyleValue> dark)
static ValueComparingNonnullRefPtr<CSSLightDark const> create(ValueComparingNonnullRefPtr<CSSStyleValue const> light, ValueComparingNonnullRefPtr<CSSStyleValue const> dark)
{
return AK::adopt_ref(*new (nothrow) CSSLightDark(move(light), move(dark)));
}
@ -25,15 +25,15 @@ public:
virtual String to_string(SerializationMode) const override;
private:
CSSLightDark(ValueComparingNonnullRefPtr<CSSStyleValue> light, ValueComparingNonnullRefPtr<CSSStyleValue> dark)
CSSLightDark(ValueComparingNonnullRefPtr<CSSStyleValue const> light, ValueComparingNonnullRefPtr<CSSStyleValue const> dark)
: CSSColorValue(CSSColorValue::ColorType::LightDark, ColorSyntax::Modern)
, m_properties { .light = move(light), .dark = move(dark) }
{
}
struct Properties {
ValueComparingNonnullRefPtr<CSSStyleValue> light;
ValueComparingNonnullRefPtr<CSSStyleValue> dark;
ValueComparingNonnullRefPtr<CSSStyleValue const> light;
ValueComparingNonnullRefPtr<CSSStyleValue const> dark;
bool operator==(Properties const&) const = default;
};

View file

@ -14,7 +14,7 @@ namespace Web::CSS {
// https://drafts.css-houdini.org/css-typed-om-1/#cssrgb
class CSSRGB final : public CSSColorValue {
public:
static ValueComparingNonnullRefPtr<CSSRGB> create(ValueComparingNonnullRefPtr<CSSStyleValue> r, ValueComparingNonnullRefPtr<CSSStyleValue> g, ValueComparingNonnullRefPtr<CSSStyleValue> b, ValueComparingRefPtr<CSSStyleValue> alpha, ColorSyntax color_syntax, Optional<FlyString> name = {})
static ValueComparingNonnullRefPtr<CSSRGB const> create(ValueComparingNonnullRefPtr<CSSStyleValue const> r, ValueComparingNonnullRefPtr<CSSStyleValue const> g, ValueComparingNonnullRefPtr<CSSStyleValue const> b, ValueComparingRefPtr<CSSStyleValue const> alpha, ColorSyntax color_syntax, Optional<FlyString> name = {})
{
// alpha defaults to 1
if (!alpha)
@ -36,17 +36,17 @@ public:
virtual bool equals(CSSStyleValue const& other) const override;
private:
CSSRGB(ValueComparingNonnullRefPtr<CSSStyleValue> r, ValueComparingNonnullRefPtr<CSSStyleValue> g, ValueComparingNonnullRefPtr<CSSStyleValue> b, ValueComparingNonnullRefPtr<CSSStyleValue> alpha, ColorSyntax color_syntax, Optional<FlyString> name = {})
CSSRGB(ValueComparingNonnullRefPtr<CSSStyleValue const> r, ValueComparingNonnullRefPtr<CSSStyleValue const> g, ValueComparingNonnullRefPtr<CSSStyleValue const> b, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha, ColorSyntax color_syntax, Optional<FlyString> name = {})
: CSSColorValue(ColorType::RGB, color_syntax)
, m_properties { .r = move(r), .g = move(g), .b = move(b), .alpha = move(alpha), .name = name }
{
}
struct Properties {
ValueComparingNonnullRefPtr<CSSStyleValue> r;
ValueComparingNonnullRefPtr<CSSStyleValue> g;
ValueComparingNonnullRefPtr<CSSStyleValue> b;
ValueComparingNonnullRefPtr<CSSStyleValue> alpha;
ValueComparingNonnullRefPtr<CSSStyleValue const> r;
ValueComparingNonnullRefPtr<CSSStyleValue const> g;
ValueComparingNonnullRefPtr<CSSStyleValue const> b;
ValueComparingNonnullRefPtr<CSSStyleValue const> alpha;
Optional<FlyString> name;
bool operator==(Properties const&) const = default;
} m_properties;

View file

@ -664,11 +664,11 @@ CalculatedStyleValue::CalculationResult NumericCalculationNode::resolve(Calculat
return CalculatedStyleValue::CalculationResult::from_value(m_value, context, numeric_type());
}
RefPtr<CSSStyleValue> NumericCalculationNode::to_style_value(CalculationContext const& context) const
RefPtr<CSSStyleValue const> NumericCalculationNode::to_style_value(CalculationContext const& context) const
{
// TODO: Clamp values to the range allowed by the context.
return m_value.visit(
[&](Number const& number) -> RefPtr<CSSStyleValue> {
[&](Number const& number) -> RefPtr<CSSStyleValue const> {
// FIXME: Returning infinity or NaN as a NumberStyleValue isn't valid.
// This is a temporary fix until value-clamping is implemented here.
// In future, we can remove these two lines and return NonnullRefPtr again.
@ -679,13 +679,13 @@ RefPtr<CSSStyleValue> NumericCalculationNode::to_style_value(CalculationContext
return IntegerStyleValue::create(llround(number.value()));
return NumberStyleValue::create(number.value());
},
[](Angle const& angle) -> RefPtr<CSSStyleValue> { return AngleStyleValue::create(angle); },
[](Flex const& flex) -> RefPtr<CSSStyleValue> { return FlexStyleValue::create(flex); },
[](Frequency const& frequency) -> RefPtr<CSSStyleValue> { return FrequencyStyleValue::create(frequency); },
[](Length const& length) -> RefPtr<CSSStyleValue> { return LengthStyleValue::create(length); },
[](Percentage const& percentage) -> RefPtr<CSSStyleValue> { return PercentageStyleValue::create(percentage); },
[](Resolution const& resolution) -> RefPtr<CSSStyleValue> { return ResolutionStyleValue::create(resolution); },
[](Time const& time) -> RefPtr<CSSStyleValue> { return TimeStyleValue::create(time); });
[](Angle const& angle) -> RefPtr<CSSStyleValue const> { return AngleStyleValue::create(angle); },
[](Flex const& flex) -> RefPtr<CSSStyleValue const> { return FlexStyleValue::create(flex); },
[](Frequency const& frequency) -> RefPtr<CSSStyleValue const> { return FrequencyStyleValue::create(frequency); },
[](Length const& length) -> RefPtr<CSSStyleValue const> { return LengthStyleValue::create(length); },
[](Percentage const& percentage) -> RefPtr<CSSStyleValue const> { return PercentageStyleValue::create(percentage); },
[](Resolution const& resolution) -> RefPtr<CSSStyleValue const> { return ResolutionStyleValue::create(resolution); },
[](Time const& time) -> RefPtr<CSSStyleValue const> { return TimeStyleValue::create(time); });
}
Optional<NonFiniteValue> NumericCalculationNode::infinite_or_nan_value() const

View file

@ -67,7 +67,7 @@ public:
Optional<CSSNumericType> m_type;
};
static ValueComparingNonnullRefPtr<CalculatedStyleValue> create(NonnullRefPtr<CalculationNode> calculation, CSSNumericType resolved_type, CalculationContext context)
static ValueComparingNonnullRefPtr<CalculatedStyleValue const> create(NonnullRefPtr<CalculationNode> calculation, CSSNumericType resolved_type, CalculationContext context)
{
return adopt_ref(*new (nothrow) CalculatedStyleValue(move(calculation), move(resolved_type), move(context)));
}
@ -262,7 +262,7 @@ public:
virtual CalculatedStyleValue::CalculationResult resolve(CalculationResolutionContext const&) const override;
virtual NonnullRefPtr<CalculationNode> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override { return *this; }
RefPtr<CSSStyleValue> to_style_value(CalculationContext const&) const;
RefPtr<CSSStyleValue const> to_style_value(CalculationContext const&) const;
virtual Vector<NonnullRefPtr<CalculationNode>> children() const override { return {}; }
NumericValue const& value() const { return m_value; }

View file

@ -58,7 +58,7 @@ StringView string_view_from_color_type(CSSColorValue::ColorType color_type)
}
ValueComparingNonnullRefPtr<ColorFunctionStyleValue> ColorFunctionStyleValue::create(StringView color_space, ValueComparingNonnullRefPtr<CSSStyleValue> c1, ValueComparingNonnullRefPtr<CSSStyleValue> c2, ValueComparingNonnullRefPtr<CSSStyleValue> c3, ValueComparingRefPtr<CSSStyleValue> alpha)
ValueComparingNonnullRefPtr<ColorFunctionStyleValue const> ColorFunctionStyleValue::create(StringView color_space, ValueComparingNonnullRefPtr<CSSStyleValue const> c1, ValueComparingNonnullRefPtr<CSSStyleValue const> c2, ValueComparingNonnullRefPtr<CSSStyleValue const> c3, ValueComparingRefPtr<CSSStyleValue const> alpha)
{
VERIFY(any_of(s_supported_color_space, [=](auto supported) { return color_space == supported; }));
@ -93,7 +93,7 @@ ColorFunctionStyleValue::Resolved ColorFunctionStyleValue::resolve_properties()
// https://www.w3.org/TR/css-color-4/#serializing-color-function-values
String ColorFunctionStyleValue::to_string(SerializationMode mode) const
{
auto convert_percentage = [](ValueComparingNonnullRefPtr<CSSStyleValue> const& value) -> RemoveReference<decltype(value)> {
auto convert_percentage = [](ValueComparingNonnullRefPtr<CSSStyleValue const> const& value) -> RemoveReference<decltype(value)> {
if (value->is_percentage())
return NumberStyleValue::create(value->as_percentage().value() / 100);
return value;

View file

@ -15,7 +15,7 @@ class ColorFunctionStyleValue final : public CSSColorValue {
public:
virtual ~ColorFunctionStyleValue() override = default;
static ValueComparingNonnullRefPtr<ColorFunctionStyleValue> create(StringView color_space, ValueComparingNonnullRefPtr<CSSStyleValue> c1, ValueComparingNonnullRefPtr<CSSStyleValue> c2, ValueComparingNonnullRefPtr<CSSStyleValue> c3, ValueComparingRefPtr<CSSStyleValue> alpha = {});
static ValueComparingNonnullRefPtr<ColorFunctionStyleValue const> create(StringView color_space, ValueComparingNonnullRefPtr<CSSStyleValue const> c1, ValueComparingNonnullRefPtr<CSSStyleValue const> c2, ValueComparingNonnullRefPtr<CSSStyleValue const> c3, ValueComparingRefPtr<CSSStyleValue const> alpha = {});
virtual bool equals(CSSStyleValue const&) const override;
virtual Color to_color(Optional<Layout::NodeWithStyle const&>) const override;
@ -26,15 +26,15 @@ public:
static constexpr Array s_supported_color_space = { "a98-rgb"sv, "display-p3"sv, "srgb"sv, "srgb-linear"sv, "prophoto-rgb"sv, "rec2020"sv, "xyz"sv, "xyz-d50"sv, "xyz-d65"sv };
private:
ColorFunctionStyleValue(ColorType color_type, ValueComparingNonnullRefPtr<CSSStyleValue> c1, ValueComparingNonnullRefPtr<CSSStyleValue> c2, ValueComparingNonnullRefPtr<CSSStyleValue> c3, ValueComparingNonnullRefPtr<CSSStyleValue> alpha)
ColorFunctionStyleValue(ColorType color_type, ValueComparingNonnullRefPtr<CSSStyleValue const> c1, ValueComparingNonnullRefPtr<CSSStyleValue const> c2, ValueComparingNonnullRefPtr<CSSStyleValue const> c3, ValueComparingNonnullRefPtr<CSSStyleValue const> alpha)
: CSSColorValue(color_type, ColorSyntax::Modern)
, m_properties { .channels = { move(c1), move(c2), move(c3) }, .alpha = move(alpha) }
{
}
struct Properties {
Array<ValueComparingNonnullRefPtr<CSSStyleValue>, 3> channels;
ValueComparingNonnullRefPtr<CSSStyleValue> alpha;
Array<ValueComparingNonnullRefPtr<CSSStyleValue const>, 3> channels;
ValueComparingNonnullRefPtr<CSSStyleValue const> alpha;
bool operator==(Properties const&) const = default;
};

View file

@ -12,11 +12,11 @@ namespace Web::CSS {
class ColorSchemeStyleValue final : public StyleValueWithDefaultOperators<ColorSchemeStyleValue> {
public:
static ValueComparingNonnullRefPtr<ColorSchemeStyleValue> create(Vector<String> schemes, bool only)
static ValueComparingNonnullRefPtr<ColorSchemeStyleValue const> create(Vector<String> schemes, bool only)
{
return adopt_ref(*new (nothrow) ColorSchemeStyleValue(move(schemes), only));
}
static ValueComparingNonnullRefPtr<ColorSchemeStyleValue> normal()
static ValueComparingNonnullRefPtr<ColorSchemeStyleValue const> normal()
{
return adopt_ref(*new (nothrow) ColorSchemeStyleValue({}, false));
}

View file

@ -17,7 +17,7 @@ namespace Web::CSS {
class ConicGradientStyleValue final : public AbstractImageStyleValue {
public:
static ValueComparingNonnullRefPtr<ConicGradientStyleValue> create(Angle from_angle, ValueComparingNonnullRefPtr<PositionStyleValue> position, Vector<AngularColorStopListElement> color_stop_list, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method)
static ValueComparingNonnullRefPtr<ConicGradientStyleValue const> create(Angle from_angle, ValueComparingNonnullRefPtr<PositionStyleValue const> position, Vector<AngularColorStopListElement> color_stop_list, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method)
{
VERIFY(!color_stop_list.is_empty());
bool any_non_legacy = color_stop_list.find_first_index_if([](auto const& stop) { return !stop.color_stop.color->is_keyword() && stop.color_stop.color->as_color().color_syntax() == ColorSyntax::Modern; }).has_value();
@ -54,7 +54,7 @@ public:
bool is_repeating() const { return m_properties.repeating == GradientRepeating::Yes; }
private:
ConicGradientStyleValue(Angle from_angle, ValueComparingNonnullRefPtr<PositionStyleValue> position, Vector<AngularColorStopListElement> color_stop_list, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method, ColorSyntax color_syntax)
ConicGradientStyleValue(Angle from_angle, ValueComparingNonnullRefPtr<PositionStyleValue const> position, Vector<AngularColorStopListElement> color_stop_list, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method, ColorSyntax color_syntax)
: AbstractImageStyleValue(Type::ConicGradient)
, m_properties { .from_angle = from_angle, .position = move(position), .color_stop_list = move(color_stop_list), .repeating = repeating, .interpolation_method = interpolation_method, .color_syntax = color_syntax }
{
@ -62,7 +62,7 @@ private:
struct Properties {
Angle from_angle;
ValueComparingNonnullRefPtr<PositionStyleValue> position;
ValueComparingNonnullRefPtr<PositionStyleValue const> position;
Vector<AngularColorStopListElement> color_stop_list;
GradientRepeating repeating;
Optional<InterpolationMethod> interpolation_method;

View file

@ -15,7 +15,7 @@ namespace Web::CSS {
class ContentStyleValue final : public StyleValueWithDefaultOperators<ContentStyleValue> {
public:
static ValueComparingNonnullRefPtr<ContentStyleValue> create(ValueComparingNonnullRefPtr<StyleValueList> content, ValueComparingRefPtr<StyleValueList> alt_text)
static ValueComparingNonnullRefPtr<ContentStyleValue const> create(ValueComparingNonnullRefPtr<StyleValueList const> content, ValueComparingRefPtr<StyleValueList const> alt_text)
{
return adopt_ref(*new (nothrow) ContentStyleValue(move(content), move(alt_text)));
}
@ -30,15 +30,15 @@ public:
bool properties_equal(ContentStyleValue const& other) const { return m_properties == other.m_properties; }
private:
ContentStyleValue(ValueComparingNonnullRefPtr<StyleValueList> content, ValueComparingRefPtr<StyleValueList> alt_text)
ContentStyleValue(ValueComparingNonnullRefPtr<StyleValueList const> content, ValueComparingRefPtr<StyleValueList const> alt_text)
: StyleValueWithDefaultOperators(Type::Content)
, m_properties { .content = move(content), .alt_text = move(alt_text) }
{
}
struct Properties {
ValueComparingNonnullRefPtr<StyleValueList> content;
ValueComparingRefPtr<StyleValueList> alt_text;
ValueComparingNonnullRefPtr<StyleValueList const> content;
ValueComparingRefPtr<StyleValueList const> alt_text;
bool operator==(Properties const&) const = default;
} m_properties;
};

View file

@ -23,7 +23,7 @@ struct CounterDefinition {
*/
class CounterDefinitionsStyleValue : public StyleValueWithDefaultOperators<CounterDefinitionsStyleValue> {
public:
static ValueComparingNonnullRefPtr<CounterDefinitionsStyleValue> create(Vector<CounterDefinition> counter_definitions)
static ValueComparingNonnullRefPtr<CounterDefinitionsStyleValue const> create(Vector<CounterDefinition> counter_definitions)
{
return adopt_ref(*new (nothrow) CounterDefinitionsStyleValue(move(counter_definitions)));
}

View file

@ -19,11 +19,11 @@ public:
Counters,
};
static ValueComparingNonnullRefPtr<CounterStyleValue> create_counter(FlyString counter_name, ValueComparingNonnullRefPtr<CSSStyleValue const> counter_style)
static ValueComparingNonnullRefPtr<CounterStyleValue const> create_counter(FlyString counter_name, ValueComparingNonnullRefPtr<CSSStyleValue const> counter_style)
{
return adopt_ref(*new (nothrow) CounterStyleValue(CounterFunction::Counter, move(counter_name), move(counter_style), {}));
}
static ValueComparingNonnullRefPtr<CounterStyleValue> create_counters(FlyString counter_name, FlyString join_string, ValueComparingNonnullRefPtr<CSSStyleValue const> counter_style)
static ValueComparingNonnullRefPtr<CounterStyleValue const> create_counters(FlyString counter_name, FlyString join_string, ValueComparingNonnullRefPtr<CSSStyleValue const> counter_style)
{
return adopt_ref(*new (nothrow) CounterStyleValue(CounterFunction::Counters, move(counter_name), move(counter_style), move(join_string)));
}

View file

@ -18,14 +18,14 @@ namespace Web::CSS {
class CursorStyleValue final : public StyleValueWithDefaultOperators<CursorStyleValue> {
public:
static ValueComparingNonnullRefPtr<CursorStyleValue> create(ValueComparingNonnullRefPtr<AbstractImageStyleValue> image, Optional<NumberOrCalculated> x, Optional<NumberOrCalculated> y)
static ValueComparingNonnullRefPtr<CursorStyleValue const> create(ValueComparingNonnullRefPtr<AbstractImageStyleValue const> image, Optional<NumberOrCalculated> x, Optional<NumberOrCalculated> y)
{
VERIFY(x.has_value() == y.has_value());
return adopt_ref(*new (nothrow) CursorStyleValue(move(image), move(x), move(y)));
}
virtual ~CursorStyleValue() override = default;
ValueComparingNonnullRefPtr<AbstractImageStyleValue> image() const { return m_properties.image; }
ValueComparingNonnullRefPtr<AbstractImageStyleValue const> image() const { return m_properties.image; }
Optional<NumberOrCalculated> const& x() const { return m_properties.x; }
Optional<NumberOrCalculated> const& y() const { return m_properties.y; }
@ -36,7 +36,7 @@ public:
bool properties_equal(CursorStyleValue const& other) const { return m_properties == other.m_properties; }
private:
CursorStyleValue(ValueComparingNonnullRefPtr<AbstractImageStyleValue> image,
CursorStyleValue(ValueComparingNonnullRefPtr<AbstractImageStyleValue const> image,
Optional<NumberOrCalculated> x,
Optional<NumberOrCalculated> y)
: StyleValueWithDefaultOperators(Type::Cursor)
@ -45,7 +45,7 @@ private:
}
struct Properties {
ValueComparingNonnullRefPtr<AbstractImageStyleValue> image;
ValueComparingNonnullRefPtr<AbstractImageStyleValue const> image;
Optional<NumberOrCalculated> x;
Optional<NumberOrCalculated> y;
bool operator==(Properties const&) const = default;

View file

@ -14,7 +14,7 @@ namespace Web::CSS {
// https://www.w3.org/TR/css-values-4/#custom-idents
class CustomIdentStyleValue final : public StyleValueWithDefaultOperators<CustomIdentStyleValue> {
public:
static ValueComparingNonnullRefPtr<CustomIdentStyleValue> create(FlyString custom_ident)
static ValueComparingNonnullRefPtr<CustomIdentStyleValue const> create(FlyString custom_ident)
{
return adopt_ref(*new (nothrow) CustomIdentStyleValue(move(custom_ident)));
}

View file

@ -8,7 +8,7 @@
namespace Web::CSS {
ValueComparingNonnullRefPtr<DisplayStyleValue> DisplayStyleValue::create(Display const& display)
ValueComparingNonnullRefPtr<DisplayStyleValue const> DisplayStyleValue::create(Display const& display)
{
return adopt_ref(*new (nothrow) DisplayStyleValue(display));
}

View file

@ -13,7 +13,7 @@ namespace Web::CSS {
class DisplayStyleValue : public StyleValueWithDefaultOperators<DisplayStyleValue> {
public:
static ValueComparingNonnullRefPtr<DisplayStyleValue> create(Display const&);
static ValueComparingNonnullRefPtr<DisplayStyleValue const> create(Display const&);
virtual ~DisplayStyleValue() override = default;
virtual String to_string(SerializationMode) const override { return m_display.to_string(); }

View file

@ -94,7 +94,7 @@ public:
String to_string() const;
};
static ValueComparingNonnullRefPtr<EasingStyleValue> create(Function const& function)
static ValueComparingNonnullRefPtr<EasingStyleValue const> create(Function const& function)
{
return adopt_ref(*new (nothrow) EasingStyleValue(function));
}

View file

@ -14,7 +14,7 @@ namespace Web::CSS {
class EdgeStyleValue final : public StyleValueWithDefaultOperators<EdgeStyleValue> {
public:
static ValueComparingNonnullRefPtr<EdgeStyleValue> create(Optional<PositionEdge> edge, Optional<LengthPercentage> const& offset)
static ValueComparingNonnullRefPtr<EdgeStyleValue const> create(Optional<PositionEdge> edge, Optional<LengthPercentage> const& offset)
{
return adopt_ref(*new (nothrow) EdgeStyleValue(edge, offset));
}

View file

@ -57,7 +57,7 @@ using FilterFunction = Variant<FilterOperation::Blur, FilterOperation::DropShado
class FilterValueListStyleValue final : public StyleValueWithDefaultOperators<FilterValueListStyleValue> {
public:
static ValueComparingNonnullRefPtr<FilterValueListStyleValue> create(
static ValueComparingNonnullRefPtr<FilterValueListStyleValue const> create(
Vector<FilterFunction> filter_value_list)
{
VERIFY(filter_value_list.size() >= 1);

View file

@ -13,11 +13,11 @@ namespace Web::CSS {
class FitContentStyleValue final : public CSSStyleValue {
public:
static ValueComparingNonnullRefPtr<FitContentStyleValue> create()
static ValueComparingNonnullRefPtr<FitContentStyleValue const> create()
{
return adopt_ref(*new (nothrow) FitContentStyleValue(LengthPercentage { Length::make_auto() }));
}
static ValueComparingNonnullRefPtr<FitContentStyleValue> create(LengthPercentage length_percentage)
static ValueComparingNonnullRefPtr<FitContentStyleValue const> create(LengthPercentage length_percentage)
{
return adopt_ref(*new (nothrow) FitContentStyleValue(move(length_percentage)));
}

View file

@ -13,7 +13,7 @@ namespace Web::CSS {
class FlexStyleValue final : public CSSUnitValue {
public:
static ValueComparingNonnullRefPtr<FlexStyleValue> create(Flex flex)
static ValueComparingNonnullRefPtr<FlexStyleValue const> create(Flex flex)
{
return adopt_ref(*new (nothrow) FlexStyleValue(move(flex)));
}

View file

@ -14,11 +14,11 @@ namespace Web::CSS {
class FontSourceStyleValue final : public StyleValueWithDefaultOperators<FontSourceStyleValue> {
public:
struct Local {
NonnullRefPtr<CSSStyleValue> name;
NonnullRefPtr<CSSStyleValue const> name;
};
using Source = Variant<Local, ::URL::URL>;
static ValueComparingNonnullRefPtr<FontSourceStyleValue> create(Source source, Optional<FlyString> format)
static ValueComparingNonnullRefPtr<FontSourceStyleValue const> create(Source source, Optional<FlyString> format)
{
return adopt_ref(*new (nothrow) FontSourceStyleValue(move(source), move(format)));
}

View file

@ -16,7 +16,7 @@ namespace Web::CSS {
class FrequencyStyleValue final : public CSSUnitValue {
public:
static ValueComparingNonnullRefPtr<FrequencyStyleValue> create(Frequency frequency)
static ValueComparingNonnullRefPtr<FrequencyStyleValue const> create(Frequency frequency)
{
return adopt_ref(*new (nothrow) FrequencyStyleValue(move(frequency)));
}

View file

@ -8,7 +8,7 @@
namespace Web::CSS {
ValueComparingNonnullRefPtr<GridAutoFlowStyleValue> GridAutoFlowStyleValue::create(Axis axis, Dense dense)
ValueComparingNonnullRefPtr<GridAutoFlowStyleValue const> GridAutoFlowStyleValue::create(Axis axis, Dense dense)
{
return adopt_ref(*new GridAutoFlowStyleValue(axis, dense));
}

View file

@ -20,7 +20,7 @@ public:
No,
Yes,
};
static ValueComparingNonnullRefPtr<GridAutoFlowStyleValue> create(Axis, Dense);
static ValueComparingNonnullRefPtr<GridAutoFlowStyleValue const> create(Axis, Dense);
virtual ~GridAutoFlowStyleValue() override = default;
[[nodiscard]] bool is_row() const { return m_row; }

View file

@ -12,7 +12,7 @@
namespace Web::CSS {
ValueComparingNonnullRefPtr<GridTemplateAreaStyleValue> GridTemplateAreaStyleValue::create(Vector<Vector<String>> grid_template_area)
ValueComparingNonnullRefPtr<GridTemplateAreaStyleValue const> GridTemplateAreaStyleValue::create(Vector<Vector<String>> grid_template_area)
{
return adopt_ref(*new (nothrow) GridTemplateAreaStyleValue(grid_template_area));
}

View file

@ -15,7 +15,7 @@ namespace Web::CSS {
class GridTemplateAreaStyleValue final : public StyleValueWithDefaultOperators<GridTemplateAreaStyleValue> {
public:
static ValueComparingNonnullRefPtr<GridTemplateAreaStyleValue> create(Vector<Vector<String>> grid_template_area);
static ValueComparingNonnullRefPtr<GridTemplateAreaStyleValue const> create(Vector<Vector<String>> grid_template_area);
virtual ~GridTemplateAreaStyleValue() override = default;
Vector<Vector<String>> const& grid_template_area() const { return m_grid_template_area; }

View file

@ -11,7 +11,7 @@
namespace Web::CSS {
ValueComparingNonnullRefPtr<GridTrackPlacementStyleValue> GridTrackPlacementStyleValue::create(CSS::GridTrackPlacement grid_track_placement)
ValueComparingNonnullRefPtr<GridTrackPlacementStyleValue const> GridTrackPlacementStyleValue::create(CSS::GridTrackPlacement grid_track_placement)
{
return adopt_ref(*new (nothrow) GridTrackPlacementStyleValue(grid_track_placement));
}

View file

@ -16,7 +16,7 @@ namespace Web::CSS {
class GridTrackPlacementStyleValue final : public StyleValueWithDefaultOperators<GridTrackPlacementStyleValue> {
public:
static ValueComparingNonnullRefPtr<GridTrackPlacementStyleValue> create(GridTrackPlacement grid_track_placement);
static ValueComparingNonnullRefPtr<GridTrackPlacementStyleValue const> create(GridTrackPlacement grid_track_placement);
virtual ~GridTrackPlacementStyleValue() override = default;
GridTrackPlacement const& grid_track_placement() const { return m_grid_track_placement; }

View file

@ -16,17 +16,17 @@ String GridTrackSizeListStyleValue::to_string(SerializationMode) const
return m_grid_track_size_list.to_string();
}
ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue> GridTrackSizeListStyleValue::create(CSS::GridTrackSizeList grid_track_size_list)
ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue const> GridTrackSizeListStyleValue::create(CSS::GridTrackSizeList grid_track_size_list)
{
return adopt_ref(*new (nothrow) GridTrackSizeListStyleValue(grid_track_size_list));
}
ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue> GridTrackSizeListStyleValue::make_auto()
ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue const> GridTrackSizeListStyleValue::make_auto()
{
return adopt_ref(*new (nothrow) GridTrackSizeListStyleValue(CSS::GridTrackSizeList()));
}
ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue> GridTrackSizeListStyleValue::make_none()
ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue const> GridTrackSizeListStyleValue::make_none()
{
return adopt_ref(*new (nothrow) GridTrackSizeListStyleValue(CSS::GridTrackSizeList()));
}

View file

@ -16,11 +16,11 @@ namespace Web::CSS {
class GridTrackSizeListStyleValue final : public StyleValueWithDefaultOperators<GridTrackSizeListStyleValue> {
public:
static ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue> create(CSS::GridTrackSizeList grid_track_size_list);
static ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue const> create(CSS::GridTrackSizeList grid_track_size_list);
virtual ~GridTrackSizeListStyleValue() override = default;
static ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue> make_auto();
static ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue> make_none();
static ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue const> make_auto();
static ValueComparingNonnullRefPtr<GridTrackSizeListStyleValue const> make_none();
CSS::GridTrackSizeList grid_track_size_list() const { return m_grid_track_size_list; }

View file

@ -20,12 +20,12 @@
namespace Web::CSS {
ValueComparingNonnullRefPtr<ImageStyleValue> ImageStyleValue::create(URL const& url)
ValueComparingNonnullRefPtr<ImageStyleValue const> ImageStyleValue::create(URL const& url)
{
return adopt_ref(*new (nothrow) ImageStyleValue(url));
}
ValueComparingNonnullRefPtr<ImageStyleValue> ImageStyleValue::create(::URL::URL const& url)
ValueComparingNonnullRefPtr<ImageStyleValue const> ImageStyleValue::create(::URL::URL const& url)
{
return adopt_ref(*new (nothrow) ImageStyleValue(URL { url.to_string() }));
}

View file

@ -24,9 +24,8 @@ class ImageStyleValue final
using Base = AbstractImageStyleValue;
public:
static ValueComparingNonnullRefPtr<ImageStyleValue> create(URL const&);
static ValueComparingNonnullRefPtr<ImageStyleValue> create(::URL::URL const&);
static ValueComparingNonnullRefPtr<ImageStyleValue const> create(URL const&);
static ValueComparingNonnullRefPtr<ImageStyleValue const> create(::URL::URL const&);
virtual ~ImageStyleValue() override;
virtual void visit_edges(JS::Cell::Visitor& visitor) const override;
@ -46,7 +45,7 @@ public:
virtual Optional<Gfx::Color> color_if_single_pixel_bitmap() const override;
Gfx::ImmutableBitmap const* current_frame_bitmap(DevicePixelRect const& dest_rect) const;
Function<void()> on_animate;
mutable Function<void()> on_animate;
GC::Ptr<HTML::DecodedImageData> image_data() const;

View file

@ -12,7 +12,7 @@ namespace Web::CSS {
class IntegerStyleValue final : public CSSUnitValue {
public:
static ValueComparingNonnullRefPtr<IntegerStyleValue> create(i64 value)
static ValueComparingNonnullRefPtr<IntegerStyleValue const> create(i64 value)
{
return adopt_ref(*new (nothrow) IntegerStyleValue(value));
}

View file

@ -11,7 +11,7 @@
namespace Web::CSS {
ValueComparingNonnullRefPtr<LengthStyleValue> LengthStyleValue::create(Length const& length)
ValueComparingNonnullRefPtr<LengthStyleValue const> LengthStyleValue::create(Length const& length)
{
VERIFY(!length.is_auto());
if (length.is_px()) {

View file

@ -16,7 +16,7 @@ namespace Web::CSS {
class LengthStyleValue final : public CSSUnitValue {
public:
static ValueComparingNonnullRefPtr<LengthStyleValue> create(Length const&);
static ValueComparingNonnullRefPtr<LengthStyleValue const> create(Length const&);
virtual ~LengthStyleValue() override = default;
Length const& length() const { return m_length; }

View file

@ -39,7 +39,7 @@ public:
WebKit
};
static ValueComparingNonnullRefPtr<LinearGradientStyleValue> create(GradientDirection direction, Vector<LinearColorStopListElement> color_stop_list, GradientType type, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method)
static ValueComparingNonnullRefPtr<LinearGradientStyleValue const> create(GradientDirection direction, Vector<LinearColorStopListElement> color_stop_list, GradientType type, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method)
{
VERIFY(!color_stop_list.is_empty());
bool any_non_legacy = color_stop_list.find_first_index_if([](auto const& stop) { return !stop.color_stop.color->is_keyword() && stop.color_stop.color->as_color().color_syntax() == ColorSyntax::Modern; }).has_value();

View file

@ -8,17 +8,17 @@
namespace Web::CSS {
ValueComparingNonnullRefPtr<MathDepthStyleValue> MathDepthStyleValue::create_auto_add()
ValueComparingNonnullRefPtr<MathDepthStyleValue const> MathDepthStyleValue::create_auto_add()
{
return adopt_ref(*new (nothrow) MathDepthStyleValue(MathDepthType::AutoAdd));
}
ValueComparingNonnullRefPtr<MathDepthStyleValue> MathDepthStyleValue::create_add(ValueComparingNonnullRefPtr<CSSStyleValue const> integer_value)
ValueComparingNonnullRefPtr<MathDepthStyleValue const> MathDepthStyleValue::create_add(ValueComparingNonnullRefPtr<CSSStyleValue const> integer_value)
{
return adopt_ref(*new (nothrow) MathDepthStyleValue(MathDepthType::Add, move(integer_value)));
}
ValueComparingNonnullRefPtr<MathDepthStyleValue> MathDepthStyleValue::create_integer(ValueComparingNonnullRefPtr<CSSStyleValue const> integer_value)
ValueComparingNonnullRefPtr<MathDepthStyleValue const> MathDepthStyleValue::create_integer(ValueComparingNonnullRefPtr<CSSStyleValue const> integer_value)
{
return adopt_ref(*new (nothrow) MathDepthStyleValue(MathDepthType::Integer, move(integer_value)));
}

View file

@ -12,9 +12,9 @@ namespace Web::CSS {
class MathDepthStyleValue : public StyleValueWithDefaultOperators<MathDepthStyleValue> {
public:
static ValueComparingNonnullRefPtr<MathDepthStyleValue> create_auto_add();
static ValueComparingNonnullRefPtr<MathDepthStyleValue> create_add(ValueComparingNonnullRefPtr<CSSStyleValue const> integer_value);
static ValueComparingNonnullRefPtr<MathDepthStyleValue> create_integer(ValueComparingNonnullRefPtr<CSSStyleValue const> integer_value);
static ValueComparingNonnullRefPtr<MathDepthStyleValue const> create_auto_add();
static ValueComparingNonnullRefPtr<MathDepthStyleValue const> create_add(ValueComparingNonnullRefPtr<CSSStyleValue const> integer_value);
static ValueComparingNonnullRefPtr<MathDepthStyleValue const> create_integer(ValueComparingNonnullRefPtr<CSSStyleValue const> integer_value);
virtual ~MathDepthStyleValue() override = default;
bool is_auto_add() const { return m_type == MathDepthType::AutoAdd; }

View file

@ -15,7 +15,7 @@ namespace Web::CSS {
class NumberStyleValue final : public CSSUnitValue {
public:
static ValueComparingNonnullRefPtr<NumberStyleValue> create(double value)
static ValueComparingNonnullRefPtr<NumberStyleValue const> create(double value)
{
return adopt_ref(*new (nothrow) NumberStyleValue(value));
}

View file

@ -20,21 +20,21 @@ public:
FontFeatureSettings,
FontVariationSettings,
};
static ValueComparingNonnullRefPtr<OpenTypeTaggedStyleValue> create(Mode mode, FlyString tag, ValueComparingNonnullRefPtr<CSSStyleValue> value)
static ValueComparingNonnullRefPtr<OpenTypeTaggedStyleValue const> create(Mode mode, FlyString tag, ValueComparingNonnullRefPtr<CSSStyleValue const> value)
{
return adopt_ref(*new (nothrow) OpenTypeTaggedStyleValue(mode, move(tag), move(value)));
}
virtual ~OpenTypeTaggedStyleValue() override = default;
FlyString const& tag() const { return m_tag; }
ValueComparingNonnullRefPtr<CSSStyleValue> const& value() const { return m_value; }
ValueComparingNonnullRefPtr<CSSStyleValue const> const& value() const { return m_value; }
virtual String to_string(SerializationMode) const override;
bool properties_equal(OpenTypeTaggedStyleValue const&) const;
private:
explicit OpenTypeTaggedStyleValue(Mode mode, FlyString tag, ValueComparingNonnullRefPtr<CSSStyleValue> value)
explicit OpenTypeTaggedStyleValue(Mode mode, FlyString tag, ValueComparingNonnullRefPtr<CSSStyleValue const> value)
: StyleValueWithDefaultOperators(Type::OpenTypeTagged)
, m_mode(mode)
, m_tag(move(tag))
@ -44,7 +44,7 @@ private:
Mode m_mode;
FlyString m_tag;
ValueComparingNonnullRefPtr<CSSStyleValue> m_value;
ValueComparingNonnullRefPtr<CSSStyleValue const> m_value;
};
}

View file

@ -16,7 +16,7 @@ namespace Web::CSS {
class PercentageStyleValue final : public CSSUnitValue {
public:
static ValueComparingNonnullRefPtr<PercentageStyleValue> create(Percentage percentage)
static ValueComparingNonnullRefPtr<PercentageStyleValue const> create(Percentage percentage)
{
return adopt_ref(*new (nothrow) PercentageStyleValue(move(percentage)));
}

View file

@ -18,11 +18,11 @@ namespace Web::CSS {
class PositionStyleValue final : public StyleValueWithDefaultOperators<PositionStyleValue> {
public:
static ValueComparingNonnullRefPtr<PositionStyleValue> create(ValueComparingNonnullRefPtr<EdgeStyleValue> edge_x, ValueComparingNonnullRefPtr<EdgeStyleValue> edge_y)
static ValueComparingNonnullRefPtr<PositionStyleValue const> create(ValueComparingNonnullRefPtr<EdgeStyleValue const> edge_x, ValueComparingNonnullRefPtr<EdgeStyleValue const> edge_y)
{
return adopt_ref(*new (nothrow) PositionStyleValue(move(edge_x), move(edge_y)));
}
static ValueComparingNonnullRefPtr<PositionStyleValue> create_center()
static ValueComparingNonnullRefPtr<PositionStyleValue const> create_center()
{
return adopt_ref(*new (nothrow) PositionStyleValue(
EdgeStyleValue::create(PositionEdge::Center, {}),
@ -30,8 +30,8 @@ public:
}
virtual ~PositionStyleValue() override = default;
ValueComparingNonnullRefPtr<EdgeStyleValue> edge_x() const { return m_properties.edge_x; }
ValueComparingNonnullRefPtr<EdgeStyleValue> edge_y() const { return m_properties.edge_y; }
ValueComparingNonnullRefPtr<EdgeStyleValue const> edge_x() const { return m_properties.edge_x; }
ValueComparingNonnullRefPtr<EdgeStyleValue const> edge_y() const { return m_properties.edge_y; }
bool is_center() const;
CSSPixelPoint resolved(Layout::Node const&, CSSPixelRect const&) const;
@ -40,15 +40,15 @@ public:
bool properties_equal(PositionStyleValue const& other) const { return m_properties == other.m_properties; }
private:
PositionStyleValue(ValueComparingNonnullRefPtr<EdgeStyleValue> edge_x, ValueComparingNonnullRefPtr<EdgeStyleValue> edge_y)
PositionStyleValue(ValueComparingNonnullRefPtr<EdgeStyleValue const> edge_x, ValueComparingNonnullRefPtr<EdgeStyleValue const> edge_y)
: StyleValueWithDefaultOperators(Type::Position)
, m_properties { .edge_x = edge_x, .edge_y = edge_y }
, m_properties { .edge_x = move(edge_x), .edge_y = move(edge_y) }
{
}
struct Properties {
ValueComparingNonnullRefPtr<EdgeStyleValue> edge_x;
ValueComparingNonnullRefPtr<EdgeStyleValue> edge_y;
ValueComparingNonnullRefPtr<EdgeStyleValue const> edge_x;
ValueComparingNonnullRefPtr<EdgeStyleValue const> edge_y;
bool operator==(Properties const&) const = default;
} m_properties;
};

View file

@ -43,7 +43,7 @@ public:
using Size = Variant<Extent, CircleSize, EllipseSize>;
static ValueComparingNonnullRefPtr<RadialGradientStyleValue> create(EndingShape ending_shape, Size size, ValueComparingNonnullRefPtr<PositionStyleValue> position, Vector<LinearColorStopListElement> color_stop_list, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method)
static ValueComparingNonnullRefPtr<RadialGradientStyleValue const> create(EndingShape ending_shape, Size size, ValueComparingNonnullRefPtr<PositionStyleValue const> position, Vector<LinearColorStopListElement> color_stop_list, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method)
{
VERIFY(!color_stop_list.is_empty());
bool any_non_legacy = color_stop_list.find_first_index_if([](auto const& stop) { return !stop.color_stop.color->is_keyword() && stop.color_stop.color->as_color().color_syntax() == ColorSyntax::Modern; }).has_value();
@ -80,7 +80,7 @@ public:
virtual ~RadialGradientStyleValue() override = default;
private:
RadialGradientStyleValue(EndingShape ending_shape, Size size, ValueComparingNonnullRefPtr<PositionStyleValue> position, Vector<LinearColorStopListElement> color_stop_list, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method, ColorSyntax color_syntax)
RadialGradientStyleValue(EndingShape ending_shape, Size size, ValueComparingNonnullRefPtr<PositionStyleValue const> position, Vector<LinearColorStopListElement> color_stop_list, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method, ColorSyntax color_syntax)
: AbstractImageStyleValue(Type::RadialGradient)
, m_properties { .ending_shape = ending_shape, .size = size, .position = move(position), .color_stop_list = move(color_stop_list), .repeating = repeating, .interpolation_method = interpolation_method, .color_syntax = color_syntax }
{
@ -89,7 +89,7 @@ private:
struct Properties {
EndingShape ending_shape;
Size size;
ValueComparingNonnullRefPtr<PositionStyleValue> position;
ValueComparingNonnullRefPtr<PositionStyleValue const> position;
Vector<LinearColorStopListElement> color_stop_list;
GradientRepeating repeating;
Optional<InterpolationMethod> interpolation_method;

View file

@ -13,7 +13,7 @@ namespace Web::CSS {
class RatioStyleValue final : public StyleValueWithDefaultOperators<RatioStyleValue> {
public:
static ValueComparingNonnullRefPtr<RatioStyleValue> create(Ratio ratio)
static ValueComparingNonnullRefPtr<RatioStyleValue const> create(Ratio ratio)
{
return adopt_ref(*new (nothrow) RatioStyleValue(move(ratio)));
}

View file

@ -11,7 +11,7 @@
namespace Web::CSS {
ValueComparingNonnullRefPtr<RectStyleValue> RectStyleValue::create(EdgeRect rect)
ValueComparingNonnullRefPtr<RectStyleValue const> RectStyleValue::create(EdgeRect rect)
{
return adopt_ref(*new (nothrow) RectStyleValue(move(rect)));
}

View file

@ -16,7 +16,7 @@ namespace Web::CSS {
class RectStyleValue : public StyleValueWithDefaultOperators<RectStyleValue> {
public:
static ValueComparingNonnullRefPtr<RectStyleValue> create(EdgeRect rect);
static ValueComparingNonnullRefPtr<RectStyleValue const> create(EdgeRect rect);
virtual ~RectStyleValue() override = default;
EdgeRect rect() const { return m_rect; }

View file

@ -13,7 +13,7 @@ namespace Web::CSS {
class ResolutionStyleValue : public CSSUnitValue {
public:
static ValueComparingNonnullRefPtr<ResolutionStyleValue> create(Resolution resolution)
static ValueComparingNonnullRefPtr<ResolutionStyleValue const> create(Resolution resolution)
{
return adopt_ref(*new (nothrow) ResolutionStyleValue(move(resolution)));
}

View file

@ -12,7 +12,7 @@ namespace Web::CSS {
class ScrollbarGutterStyleValue final : public StyleValueWithDefaultOperators<ScrollbarGutterStyleValue> {
public:
static ValueComparingNonnullRefPtr<ScrollbarGutterStyleValue> create(ScrollbarGutter value)
static ValueComparingNonnullRefPtr<ScrollbarGutterStyleValue const> create(ScrollbarGutter value)
{
return adopt_ref(*new (nothrow) ScrollbarGutterStyleValue(value));
}

View file

@ -22,7 +22,7 @@ enum class ShadowPlacement {
class ShadowStyleValue final : public StyleValueWithDefaultOperators<ShadowStyleValue> {
public:
static ValueComparingNonnullRefPtr<ShadowStyleValue> create(
static ValueComparingNonnullRefPtr<ShadowStyleValue const> create(
ValueComparingNonnullRefPtr<CSSStyleValue const> color,
ValueComparingNonnullRefPtr<CSSStyleValue const> offset_x,
ValueComparingNonnullRefPtr<CSSStyleValue const> offset_y,

View file

@ -12,7 +12,7 @@ namespace Web::CSS {
class ShorthandStyleValue final : public StyleValueWithDefaultOperators<ShorthandStyleValue> {
public:
static ValueComparingNonnullRefPtr<ShorthandStyleValue> create(PropertyID shorthand, Vector<PropertyID> sub_properties, Vector<ValueComparingNonnullRefPtr<CSSStyleValue const>> values)
static ValueComparingNonnullRefPtr<ShorthandStyleValue const> create(PropertyID shorthand, Vector<PropertyID> sub_properties, Vector<ValueComparingNonnullRefPtr<CSSStyleValue const>> values)
{
return adopt_ref(*new ShorthandStyleValue(shorthand, move(sub_properties), move(values)));
}

View file

@ -14,7 +14,7 @@ namespace Web::CSS {
class StringStyleValue : public StyleValueWithDefaultOperators<StringStyleValue> {
public:
static ValueComparingNonnullRefPtr<StringStyleValue> create(FlyString const& string)
static ValueComparingNonnullRefPtr<StringStyleValue const> create(FlyString const& string)
{
return adopt_ref(*new (nothrow) StringStyleValue(string));
}

View file

@ -16,7 +16,7 @@ namespace Web::CSS {
class TimeStyleValue : public CSSUnitValue {
public:
static ValueComparingNonnullRefPtr<TimeStyleValue> create(Time time)
static ValueComparingNonnullRefPtr<TimeStyleValue const> create(Time time)
{
return adopt_ref(*new (nothrow) TimeStyleValue(move(time)));
}

View file

@ -16,7 +16,7 @@ namespace Web::CSS {
class TransformationStyleValue final : public StyleValueWithDefaultOperators<TransformationStyleValue> {
public:
static ValueComparingNonnullRefPtr<TransformationStyleValue> create(PropertyID property, TransformFunction transform_function, StyleValueVector&& values)
static ValueComparingNonnullRefPtr<TransformationStyleValue const> create(PropertyID property, TransformFunction transform_function, StyleValueVector&& values)
{
return adopt_ref(*new (nothrow) TransformationStyleValue(property, transform_function, move(values)));
}

View file

@ -17,15 +17,15 @@ namespace Web::CSS {
class TransitionStyleValue final : public StyleValueWithDefaultOperators<TransitionStyleValue> {
public:
struct Transition {
ValueComparingRefPtr<CustomIdentStyleValue> property_name;
ValueComparingRefPtr<CustomIdentStyleValue const> property_name;
TimeOrCalculated duration { CSS::Time::make_seconds(0.0) };
TimeOrCalculated delay { CSS::Time::make_seconds(0.0) };
ValueComparingRefPtr<EasingStyleValue> easing;
ValueComparingRefPtr<EasingStyleValue const> easing;
bool operator==(Transition const&) const = default;
};
static ValueComparingNonnullRefPtr<TransitionStyleValue> create(Vector<Transition> transitions)
static ValueComparingNonnullRefPtr<TransitionStyleValue const> create(Vector<Transition> transitions)
{
return adopt_ref(*new (nothrow) TransitionStyleValue(move(transitions)));
}

View file

@ -14,7 +14,7 @@ namespace Web::CSS {
class URLStyleValue final : public StyleValueWithDefaultOperators<URLStyleValue> {
public:
static ValueComparingNonnullRefPtr<URLStyleValue> create(::URL::URL const& url)
static ValueComparingNonnullRefPtr<URLStyleValue const> create(::URL::URL const& url)
{
return adopt_ref(*new (nothrow) URLStyleValue(url));
}

View file

@ -13,7 +13,7 @@ namespace Web::CSS {
class UnicodeRangeStyleValue final : public StyleValueWithDefaultOperators<UnicodeRangeStyleValue> {
public:
static ValueComparingNonnullRefPtr<UnicodeRangeStyleValue> create(Gfx::UnicodeRange unicode_range)
static ValueComparingNonnullRefPtr<UnicodeRangeStyleValue const> create(Gfx::UnicodeRange unicode_range)
{
return adopt_ref(*new (nothrow) UnicodeRangeStyleValue(unicode_range));
}

View file

@ -17,7 +17,7 @@ namespace Web::CSS {
class UnresolvedStyleValue final : public CSSStyleValue {
public:
static ValueComparingNonnullRefPtr<UnresolvedStyleValue> create(Vector<Parser::ComponentValue>&& values, bool contains_var_or_attr, Optional<String> original_source_text)
static ValueComparingNonnullRefPtr<UnresolvedStyleValue const> create(Vector<Parser::ComponentValue>&& values, bool contains_var_or_attr, Optional<String> original_source_text)
{
return adopt_ref(*new (nothrow) UnresolvedStyleValue(move(values), contains_var_or_attr, move(original_source_text)));
}