CSSProperty: Use member variables to store static characteristics

instead of costly virtual functions.

This saves on code size, data size, number of dynamic relocations, and makes
accessing these properties faster.

Bug: none
Change-Id: I1750f8d8e03c1ff4925a86778c6f65ae7125a566
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1538527
Commit-Queue: Hans Wennborg <hans@chromium.org>
Reviewed-by: Anders Hartvoll Ruud <andruud@chromium.org>
Cr-Commit-Position: refs/heads/master@{#645292}

third_party/blink/renderer/build/scripts/core/css/properties/templates/css_property_subclass.h.tmpl

@@ -29,8 +29,35 @@ class {{property_classname}} final : public CSSUnresolvedProperty {
   {% else %}
 class {{property_classname}} final : public {{property.namespace_group}} {
  public:
-  constexpr {{property_classname}}() : {{property.namespace_group}}() {}
+  constexpr {{property_classname}}() : {{property.namespace_group}}(CSSPropertyID::{{property.enum_key}},
+    0
+  {% if property.interpolable %}
+    | kInterpolable
+  {% endif %}
+  {% if property.compositable %}
+    | kCompositableProperty
+  {% endif %}
+  {% if property.is_descriptor %}
+    | kDescriptor
+  {% endif %}
+  {% if 'Percent' in property.typedom_types %}
+    | kSupportsPercentage
+  {% endif %}
+  {% if property.is_property %}
+    | kProperty
+  {% endif %}
+  {% if property.valid_for_visited_link %}
+    | kValidForVisitedLink
+  {% endif %}
+    ,
+  {% if property.separator != None %}
+    '{{property.separator}}'
+  {% else %}
+    '\0'
   {% endif %}
+    ) {}
+  {% endif %}
+
   {% if property.is_internal %}
   bool IsEnabled() const override { return false; }
   {% elif property.runtime_flag %}
@@ -47,7 +74,6 @@ class {{property_classname}} final : public {{property.namespace_group}} {
     return "{{property_classname[0].lower() + property_classname[1:]}}";
   }
   {% if property.alias_for == None %}
-  CSSPropertyID PropertyID() const override { return CSSPropertyID::{{property.enum_key}}; }
   {%if property.layout_dependent %}
   bool IsLayoutDependentProperty() const override { return true; }
   bool IsLayoutDependent(const ComputedStyle*, LayoutObject*) const override;
@@ -55,34 +81,14 @@ class {{property_classname}} final : public {{property.namespace_group}} {
   {% for property_method in property.property_methods %}
   {{property_method.return_type}} {{property_method.name}}{{property_method.parameters}} const override;
   {% endfor %}
-  {% if property.interpolable %}
-  bool IsInterpolable() const override { return true; }
-  {% endif %}
   {% if property.inherited %}
   bool IsInherited() const override { return true; }
   {% endif %}
-  {% if property.compositable %}
-  bool IsCompositableProperty() const override { return true; }
-  {% endif %}
   {% if property.separator != None %}
-  bool IsRepeated() const override { return true; }
-  char RepetitionSeparator() const override { return '{{property.separator}}'; }
-  {% endif %}
-  {% if property.is_descriptor %}
-  bool IsDescriptor() const override { return true; }
-  {% endif %}
-  {% if 'Percent' in property.typedom_types %}
-  bool SupportsPercentage() const override { return true; }
-  {% endif %}
-  {% if not property.is_property %}
-  bool IsProperty() const override { return false; }
   {% endif %}
   {% if not property.affected_by_all %}
   bool IsAffectedByAll() const override { return false; }
   {% endif %}
-  {% if property.valid_for_visited_link %}
-  bool IsValidForVisitedLink() const override { return true; }
-  {% endif %}
   {% if property.direction_aware_options %}
   const CSSValue* CSSValueFromComputedStyleInternal(
       const ComputedStyle& ,

third_party/blink/renderer/core/css/properties/css_property.h

@@ -32,33 +32,34 @@ class CORE_EXPORT CSSProperty : public CSSUnresolvedProperty {
   // For backwards compatibility when passing around CSSUnresolvedProperty
   // references. In case we need to call a function that hasn't been converted
   // to using property classes yet.
-  virtual CSSPropertyID PropertyID() const {
-    NOTREACHED();
-    return CSSPropertyID::kInvalid;
-  }
+  CSSPropertyID PropertyID() const { return property_id_; }
   virtual CSSPropertyName GetCSSPropertyName() const {
     return CSSPropertyName(PropertyID());
   }
+
   bool IDEquals(CSSPropertyID id) const { return PropertyID() == id; }
   bool IsResolvedProperty() const override { return true; }
-  virtual bool IsInterpolable() const { return false; }
+
+  bool IsInterpolable() const { return flags_ & kInterpolable; }
+  bool IsCompositableProperty() const { return flags_ & kCompositableProperty; }
+  bool IsDescriptor() const { return flags_ & kDescriptor; }
+  bool SupportsPercentage() const { return flags_ & kSupportsPercentage; }
+  bool IsProperty() const { return flags_ & kProperty; }
+  bool IsValidForVisitedLink() const { return flags_ & kValidForVisitedLink; }
+  bool IsShorthand() const { return flags_ & kShorthand; }
+  bool IsLonghand() const { return flags_ & kLonghand; }
+
+  bool IsRepeated() const { return repetition_separator_ != '\0'; }
+  char RepetitionSeparator() const { return repetition_separator_; }
+
   virtual bool IsInherited() const { return false; }
-  virtual bool IsCompositableProperty() const { return false; }
-  virtual bool IsRepeated() const { return false; }
-  virtual char RepetitionSeparator() const {
-    NOTREACHED();
-    return 0;
-  }
-  virtual bool IsDescriptor() const { return false; }
-  virtual bool SupportsPercentage() const { return false; }
-  virtual bool IsProperty() const { return true; }
+
   virtual bool IsAffectedByAll() const { return IsEnabled() && IsProperty(); }
   virtual bool IsLayoutDependentProperty() const { return false; }
   virtual bool IsLayoutDependent(const ComputedStyle* style,
                                  LayoutObject* layout_object) const {
     return false;
   }
-  virtual bool IsValidForVisitedLink() const { return false; }
 
   virtual const CSSValue* CSSValueFromComputedStyleInternal(
       const ComputedStyle&,
@@ -83,14 +84,29 @@ class CORE_EXPORT CSSProperty : public CSSUnresolvedProperty {
                                                            WritingMode) const {
     return *this;
   }
-  virtual bool IsShorthand() const { return false; }
-  virtual bool IsLonghand() const { return false; }
   static void FilterEnabledCSSPropertiesIntoVector(const CSSPropertyID*,
                                                    size_t length,
                                                    Vector<const CSSProperty*>&);
 
  protected:
-  constexpr CSSProperty() : CSSUnresolvedProperty() {}
+  enum Flag : uint8_t {
+    kInterpolable = 1 << 0,
+    kCompositableProperty = 1 << 1,
+    kDescriptor = 1 << 2,
+    kSupportsPercentage = 1 << 3,
+    kProperty = 1 << 4,
+    kValidForVisitedLink = 1 << 5,
+    kShorthand = 1 << 6,
+    kLonghand = 1 << 7
+  };
+
+  constexpr CSSProperty(CSSPropertyID property_id,
+                        uint8_t flags,
+                        char repetition_separator)
+      : CSSUnresolvedProperty(),
+        property_id_(property_id),
+        flags_(flags),
+        repetition_separator_(repetition_separator) {}
 
   static const StylePropertyShorthand& BorderDirections();
   static const CSSProperty& ResolveAfterToPhysicalProperty(
@@ -109,6 +125,11 @@ class CORE_EXPORT CSSProperty : public CSSUnresolvedProperty {
       TextDirection,
       WritingMode,
       const StylePropertyShorthand&);
+
+ private:
+  CSSPropertyID property_id_;
+  uint8_t flags_;
+  char repetition_separator_;
 };
 
 template <>

third_party/blink/renderer/core/css/properties/longhand.h

@@ -38,13 +38,13 @@ class Longhand : public CSSProperty {
     NOTREACHED();
     return Color();
   }
-  bool IsLonghand() const override { return true; }
   virtual const CSSValue* InitialValue() const {
     return CSSInitialValue::Create();
   }
 
  protected:
-  constexpr Longhand() : CSSProperty() {}
+  constexpr Longhand(CSSPropertyID id, uint8_t flags, char repetition_separator)
+      : CSSProperty(id, flags | kLonghand, repetition_separator) {}
 };
 
 template <>

third_party/blink/renderer/core/css/properties/longhands/variable.h

@@ -17,11 +17,10 @@ namespace blink {
 // (as returned by GetCSSPropertyVariable()) has been removed.
 class CORE_EXPORT Variable : public Longhand {
  public:
-  constexpr Variable() : Longhand() {}
+  constexpr Variable() : Longhand(CSSPropertyID::kVariable, kProperty, '\0') {}
 
   bool IsInherited() const override { return true; }
   bool IsAffectedByAll() const override { return false; }
-  CSSPropertyID PropertyID() const override { return CSSPropertyID::kVariable; }
   CSSPropertyName GetCSSPropertyName() const override {
     NOTREACHED();
     return CSSPropertyName("");

third_party/blink/renderer/core/css/properties/shorthand.h

@@ -29,10 +29,12 @@ class Shorthand : public CSSProperty {
     NOTREACHED();
     return false;
   }
-  bool IsShorthand() const override { return true; }
 
  protected:
-  constexpr Shorthand() : CSSProperty() {}
+  constexpr Shorthand(CSSPropertyID id,
+                      uint8_t flags,
+                      char repetition_separator)
+      : CSSProperty(id, flags | kShorthand, repetition_separator) {}
 };
 
 template <>