LibWeb: Move and rename CSSStyleValue to StyleValues/StyleValue.{h,cpp}

This reverts 0e3487b.

Back when I made that change, I thought we could make our StyleValue
classes match the typed-om definitions directly. However, they have
different requirements. Typed-om types need to be mutable and GCed,
whereas StyleValues are immutable and ideally wouldn't require a JS VM.

While I was already making such a cataclysmic change, I've moved it into
the StyleValues directory, because it *not* being there has bothered me
for a long time. 😅

Author: AtkinsSJ

Documentation/CSSGeneratedFiles.md

@@ -25,7 +25,7 @@ Each property will have some set of these fields on it:
 | `affects-stacking-context`        | No       | `false` | Boolean. Whether this property can cause a new stacking context for the element.                            | `bool property_affects_stacking_context(PropertyID)`                                                                                                                                        |
 | `animation-type`                  | Yes      |         | String. How the property should be animated. Defined by the spec. See below.                                | `AnimationType animation_type_from_longhand_property(PropertyID)`                                                                                                                           |
 | `inherited`                       | Yes      |         | Boolean. Whether the property is inherited by its child elements.                                           | `bool is_inherited_property(PropertyID)`                                                                                                                                                    |
-| `initial`                         | Yes      |         | String. The property's initial value if it is not specified.                                                | `NonnullRefPtr<CSSStyleValue const> property_initial_value(PropertyID)`                                                                                                                     |
+| `initial`                         | Yes      |         | String. The property's initial value if it is not specified.                                                | `NonnullRefPtr<StyleValue const> property_initial_value(PropertyID)`                                                                                                                     |
 | `legacy-alias-for`                | No       | Nothing | String. The name of a property this is an alias for. See below.                                             |                                                                                                                                                                                             |
 | `logical-alias-for`               | No       | Nothing | An object. See below.                                                                                       | `bool property_is_logical_alias(PropertyID);`<br/>`PropertyID map_logical_alias_to_physical_property(PropertyID, LogicalAliasMappingContext const&)`                                        |
 | `longhands`                       | No       | `[]`    | Array of strings. If this is a shorthand, these are the property names that it expands out into.            | `Vector<PropertyID> longhands_for_shorthand(PropertyID)`<br/>`Vector<PropertyID> expanded_longhands_for_shorthand(PropertyID)`<br/>`Vector<PropertyID> shorthands_for_longhand(PropertyID)` |
@@ -129,7 +129,7 @@ The generated code provides:
   it exists in that at-rule.
 - `FlyString to_string(DescriptorID)` for serializing descriptor names.
 - `bool at_rule_supports_descriptor(AtRuleID, DescriptorID)` to query if the given at-rule allows the descriptor.
-- `RefPtr<CSSStyleValue const> descriptor_initial_value(AtRuleID, DescriptorID)` for getting a descriptor's initial value.
+- `RefPtr<StyleValue const> descriptor_initial_value(AtRuleID, DescriptorID)` for getting a descriptor's initial value.
 - `DescriptorMetadata get_descriptor_metadata(AtRuleID, DescriptorID)` returns data used for parsing the descriptor.
 
 ### At-rule fields

Documentation/CSSProperties.md

@@ -18,7 +18,7 @@ However, there are many CSS properties with more complicated grammar and so they
 
 Property-parsing code goes in `CSS/Parser/PropertyParsing.cpp`, and `CSS/Parser/Parser.h`. First,
 `Parser::parse_css_value()` is called, which has a switch for specific properties. Call your method from there. It
-should return a `RefPtr` to a `CSSStyleValue` or one of its subclasses.
+should return a `RefPtr` to a `StyleValue` or one of its subclasses.
 
 For shorthands, you should normally use `ShorthandStyleValue`, which automatically expands its longhand values. You
 might need to modify `ShorthandStyleValue::to_string` if your shorthand has special serialization rules. For example,
@@ -29,7 +29,7 @@ If you need to do this, pester @AtkinsSJ until he gets around to documenting it.
 
 ## Computed style
 
-After parsing and style computation, longhand properties are stored as `CSSStyleValue` pointers in
+After parsing and style computation, longhand properties are stored as `StyleValue` pointers in
 `ComputedProperties`. Any shorthands have been expanded out, and so we do not need to store them directly.
 
 These longhands then need to be converted to a more usable form. To do this, add a getter to `ComputedProperties` with

Documentation/LibWebFromLoadingToPainting.md

@@ -80,7 +80,7 @@ The cascade origin determines the processing order for rules. The "user-agent" s
 
 Note: the user-agent style is a built-in CSS style sheet that lives in the LibWeb source code [here](https://github.com/LadybirdBrowser/ladybird/blob/master/Libraries/LibWeb/CSS/Default.css).
 
-The end product of style computation is a fully populated StyleProperties object. It has a CSSStyleValue for each CSS::PropertyID. In spec parlance, these are the *computed* values. (Note that these are not the same as you get from `getComputedStyle()`, that API returns the *resolved* values.)
+The end product of style computation is a fully populated StyleProperties object. It has a StyleValue for each CSS::PropertyID. In spec parlance, these are the *computed* values. (Note that these are not the same as you get from `getComputedStyle()`, that API returns the *resolved* values.)
 
 #### Resolving CSS custom properties ("variables")
 

Libraries/LibWeb/Animations/AnimationEffect.cpp

@@ -158,7 +158,7 @@ WebIDL::ExceptionOr<void> AnimationEffect::update_timing(OptionalEffectTiming ti
 
     // 4. If the easing member of input exists but cannot be parsed using the <easing-function> production
     //    [CSS-EASING-1], throw a TypeError and abort this procedure.
-    RefPtr<CSS::CSSStyleValue const> easing_value;
+    RefPtr<CSS::StyleValue const> easing_value;
     if (timing.easing.has_value()) {
         easing_value = parse_easing_string(timing.easing.value());
         if (!easing_value)
@@ -604,7 +604,7 @@ Optional<double> AnimationEffect::transformed_progress() const
     return m_timing_function.evaluate_at(directed_progress.value(), before_flag);
 }
 
-RefPtr<CSS::CSSStyleValue const> AnimationEffect::parse_easing_string(StringView value)
+RefPtr<CSS::StyleValue const> AnimationEffect::parse_easing_string(StringView value)
 {
     if (auto style_value = parse_css_value(CSS::Parser::ParsingParams(), value, CSS::PropertyID::AnimationTimingFunction)) {
         if (style_value->is_easing())
@@ -631,7 +631,7 @@ void AnimationEffect::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(m_associated_animation);
 }
 
-static CSS::RequiredInvalidationAfterStyleChange compute_required_invalidation_for_animated_properties(HashMap<CSS::PropertyID, NonnullRefPtr<CSS::CSSStyleValue const>> const& old_properties, HashMap<CSS::PropertyID, NonnullRefPtr<CSS::CSSStyleValue const>> const& new_properties)
+static CSS::RequiredInvalidationAfterStyleChange compute_required_invalidation_for_animated_properties(HashMap<CSS::PropertyID, NonnullRefPtr<CSS::StyleValue const>> const& old_properties, HashMap<CSS::PropertyID, NonnullRefPtr<CSS::StyleValue const>> const& new_properties)
 {
     CSS::RequiredInvalidationAfterStyleChange invalidation;
     auto old_and_new_properties = MUST(Bitmap::create(to_underlying(CSS::last_property_id) + 1, 0));

Libraries/LibWeb/Animations/AnimationEffect.h

@@ -62,7 +62,7 @@ Bindings::PlaybackDirection css_animation_direction_to_bindings_playback_directi
 // This object lives for the duration of an animation update, and is used to store per-element data about animated CSS properties.
 struct AnimationUpdateContext {
     struct ElementData {
-        using PropertyMap = HashMap<CSS::PropertyID, NonnullRefPtr<CSS::CSSStyleValue const>>;
+        using PropertyMap = HashMap<CSS::PropertyID, NonnullRefPtr<CSS::StyleValue const>>;
         PropertyMap animated_properties_before_update;
         GC::Ptr<CSS::ComputedProperties> target_style;
     };
@@ -79,7 +79,7 @@ class AnimationEffect : public Bindings::PlatformObject {
     GC_DECLARE_ALLOCATOR(AnimationEffect);
 
 public:
-    static RefPtr<CSS::CSSStyleValue const> parse_easing_string(StringView value);
+    static RefPtr<CSS::StyleValue const> parse_easing_string(StringView value);
 
     EffectTiming get_timing() const;
     ComputedEffectTiming get_computed_timing() const;

Libraries/LibWeb/Animations/KeyframeEffect.cpp

@@ -563,7 +563,7 @@ static WebIDL::ExceptionOr<Vector<BaseKeyframe>> process_a_keyframes_argument(JS
         if (!easing_value)
             return WebIDL::SimpleException { WebIDL::SimpleExceptionType::TypeError, MUST(String::formatted("Invalid animation easing value: \"{}\"", easing_string)) };
 
-        keyframe.easing.set(NonnullRefPtr<CSS::CSSStyleValue const> { *easing_value });
+        keyframe.easing.set(NonnullRefPtr<CSS::StyleValue const> { *easing_value });
     }
 
     // 9. Parse each of the values in unused easings using the CSS syntax defined for easing member of the EffectTiming
@@ -591,7 +591,7 @@ void KeyframeEffect::generate_initial_and_final_frames(RefPtr<KeyFrameSet> keyfr
         initial_keyframe = keyframe_set->keyframes_by_key.find(0);
     }
 
-    auto expanded_properties = [&](HashMap<CSS::PropertyID, Variant<KeyFrameSet::UseInitial, NonnullRefPtr<CSS::CSSStyleValue const>>>& properties) {
+    auto expanded_properties = [&](HashMap<CSS::PropertyID, Variant<KeyFrameSet::UseInitial, NonnullRefPtr<CSS::StyleValue const>>>& properties) {
         HashTable<CSS::PropertyID> result;
 
         for (auto property : properties) {
@@ -827,7 +827,7 @@ WebIDL::ExceptionOr<GC::RootVector<JS::Object*>> KeyframeEffect::get_keyframes()
             auto object = JS::Object::create(realm, realm.intrinsics().object_prototype());
             TRY(object->set(vm.names.offset, keyframe.offset.has_value() ? JS::Value(keyframe.offset.value()) : JS::js_null(), ShouldThrowExceptions::Yes));
             TRY(object->set(vm.names.computedOffset, JS::Value(keyframe.computed_offset.value()), ShouldThrowExceptions::Yes));
-            auto easing_value = keyframe.easing.get<NonnullRefPtr<CSS::CSSStyleValue const>>();
+            auto easing_value = keyframe.easing.get<NonnullRefPtr<CSS::StyleValue const>>();
             TRY(object->set(vm.names.easing, JS::PrimitiveString::create(vm, easing_value->to_string(CSS::SerializationMode::Normal)), ShouldThrowExceptions::Yes));
 
             if (keyframe.composite == Bindings::CompositeOperationOrAuto::Replace) {
@@ -881,7 +881,7 @@ WebIDL::ExceptionOr<void> KeyframeEffect::set_keyframes(Optional<GC::Root<JS::Ob
                 property_value = CSS::Parser::Parser::resolve_unresolved_style_value(CSS::Parser::ParsingParams { target->document() }, *target, pseudo_element_type(), property_id, property_value->as_unresolved());
 
             resolved_keyframe.properties.set(property_id, property_value);
-            CSS::StyleComputer::for_each_property_expanding_shorthands(property_id, property_value, [&](CSS::PropertyID longhand_id, CSS::CSSStyleValue const&) {
+            CSS::StyleComputer::for_each_property_expanding_shorthands(property_id, property_value, [&](CSS::PropertyID longhand_id, CSS::StyleValue const&) {
                 m_target_properties.set(longhand_id);
             });
         }

Libraries/LibWeb/Animations/KeyframeEffect.h

@@ -11,13 +11,13 @@
 #include <LibWeb/Animations/AnimationEffect.h>
 #include <LibWeb/Bindings/KeyframeEffectPrototype.h>
 #include <LibWeb/Bindings/PlatformObject.h>
-#include <LibWeb/CSS/CSSStyleValue.h>
 #include <LibWeb/CSS/PropertyID.h>
 #include <LibWeb/CSS/Selector.h>
+#include <LibWeb/CSS/StyleValues/StyleValue.h>
 
 namespace Web::Animations {
 
-using EasingValue = Variant<String, NonnullRefPtr<CSS::CSSStyleValue const>>;
+using EasingValue = Variant<String, NonnullRefPtr<CSS::StyleValue const>>;
 
 // https://www.w3.org/TR/web-animations-1/#the-keyframeeffectoptions-dictionary
 struct KeyframeEffectOptions : public EffectTiming {
@@ -39,7 +39,7 @@ struct BasePropertyIndexedKeyframe {
 // https://www.w3.org/TR/web-animations-1/#dictdef-basekeyframe
 struct BaseKeyframe {
     using UnparsedProperties = HashMap<String, String>;
-    using ParsedProperties = HashMap<CSS::PropertyID, NonnullRefPtr<CSS::CSSStyleValue const>>;
+    using ParsedProperties = HashMap<CSS::PropertyID, NonnullRefPtr<CSS::StyleValue const>>;
 
     Optional<double> offset {};
     EasingValue easing { "linear"_string };
@@ -64,9 +64,9 @@ class KeyframeEffect : public AnimationEffect {
     struct KeyFrameSet : public RefCounted<KeyFrameSet> {
         struct UseInitial { };
         struct ResolvedKeyFrame {
-            // These CSSStyleValue properties can be unresolved, as they may be generated from a @keyframes rule, well
+            // These StyleValue properties can be unresolved, as they may be generated from a @keyframes rule, well
             // before they are applied to an element
-            HashMap<CSS::PropertyID, Variant<UseInitial, NonnullRefPtr<CSS::CSSStyleValue const>>> properties {};
+            HashMap<CSS::PropertyID, Variant<UseInitial, NonnullRefPtr<CSS::StyleValue const>>> properties {};
         };
         RedBlackTree<u64, ResolvedKeyFrame> keyframes_by_key;
     };

Libraries/LibWeb/CMakeLists.txt

@@ -125,7 +125,6 @@ set(SOURCES
     CSS/CSSStyleProperties.cpp
     CSS/CSSStyleRule.cpp
     CSS/CSSStyleSheet.cpp
-    CSS/CSSStyleValue.cpp
     CSS/CSSSupportsRule.cpp
     CSS/CSSTransition.cpp
     CSS/Descriptor.cpp
@@ -234,6 +233,7 @@ set(SOURCES
     CSS/StyleValues/ScrollbarColorStyleValue.cpp
     CSS/StyleValues/ShadowStyleValue.cpp
     CSS/StyleValues/ShorthandStyleValue.cpp
+    CSS/StyleValues/StyleValue.cpp
     CSS/StyleValues/StyleValueList.cpp
     CSS/StyleValues/TransformationStyleValue.cpp
     CSS/StyleValues/TransitionStyleValue.cpp

Libraries/LibWeb/CSS/CSS.cpp

@@ -89,7 +89,7 @@ WebIDL::ExceptionOr<void> register_property(JS::VM& vm, PropertyDefinition defin
         return WebIDL::SyntaxError::create(realm, "Invalid syntax definition"_string);
     }
 
-    RefPtr<CSSStyleValue const> initial_value_maybe;
+    RefPtr<StyleValue const> initial_value_maybe;
 
     // 4. If syntax definition is the universal syntax definition, and initialValue is not present,
     if (maybe_syntax->type() == Parser::SyntaxNode::NodeType::Universal) {

Libraries/LibWeb/CSS/CSSAnimation.h

@@ -7,8 +7,8 @@
 #pragma once
 
 #include <LibWeb/Animations/Animation.h>
-#include <LibWeb/CSS/CSSStyleValue.h>
 #include <LibWeb/CSS/PropertyID.h>
+#include <LibWeb/CSS/StyleValues/StyleValue.h>
 
 namespace Web::CSS {