Store CSSPropertyID in SVGAnimatedPropertyBase

third_party/WebKit/Source/core/svg/properties/SVGAnimatedProperty.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
 G*     * Redistributions in binary form must reproduce the above
@@ skipping 44 matching lines @@
   virtual bool isAnimating() const = 0;
 
   virtual SVGPropertyBase* createAnimatedValue() = 0;
   virtual void setAnimatedValue(SVGPropertyBase*) = 0;
   virtual void animationEnded();
 
   virtual SVGParsingError setBaseValueAsString(const String&) = 0;
   virtual bool needsSynchronizeAttribute() = 0;
   virtual void synchronizeAttribute();
 
-  AnimatedPropertyType type() const { return m_type; }
+  AnimatedPropertyType type() const {
+    return static_cast<AnimatedPropertyType>(m_type);
+  }
 
   SVGElement* contextElement() const { return m_contextElement; }
 
   const QualifiedName& attributeName() const { return m_attributeName; }
 
+  CSSPropertyID cssPropertyId() const {
+    return static_cast<CSSPropertyID>(m_cssPropertyId);
+  }
+
+  bool hasPresentationAttributeMapping() const {
+    return cssPropertyId() != CSSPropertyInvalid;
+  }
+
   bool isReadOnly() const { return m_isReadOnly; }
 
   void setReadOnly() { m_isReadOnly = true; }
 
   bool isSpecified() const;
 
   DEFINE_INLINE_VIRTUAL_TRACE() {}
 
  protected:
   SVGAnimatedPropertyBase(AnimatedPropertyType,
                           SVGElement*,
-                          const QualifiedName& attributeName);
+                          const QualifiedName& attributeName,
+                          CSSPropertyID = CSSPropertyInvalid);
 
  private:
-  const AnimatedPropertyType m_type;
-  bool m_isReadOnly;
+  static_assert(NumberOfAnimatedPropertyTypes <= (1u << 5),
+                "enough bits for AnimatedPropertyType (m_type)");
+  static constexpr int kCssPropertyBits = 9;
+  static_assert((1u << kCssPropertyBits) - 1 >= lastCSSProperty,
+                "enough bits for CSS property ids");
+
+  const unsigned m_type : 5;
+  const unsigned m_cssPropertyId : kCssPropertyBits;
+  unsigned m_isReadOnly : 1;
 
   // This raw pointer is safe since the SVG element is guaranteed to be kept
   // alive by a V8 wrapper.
   // See http://crbug.com/528275 for the detail.
   UntracedMember<SVGElement> m_contextElement;
 
   const QualifiedName& m_attributeName;
 };
 
 template <typename Property>
@@ skipping 36 matching lines @@
 
   DEFINE_INLINE_VIRTUAL_TRACE() {
     visitor->trace(m_baseValue);
     visitor->trace(m_currentValue);
     SVGAnimatedPropertyBase::trace(visitor);
   }
 
  protected:
   SVGAnimatedPropertyCommon(SVGElement* contextElement,
                             const QualifiedName& attributeName,
-                            Property* initialValue)
+                            Property* initialValue,
+                            CSSPropertyID cssPropertyId = CSSPropertyInvalid)
       : SVGAnimatedPropertyBase(Property::classType(),
                                 contextElement,
-                                attributeName),
+                                attributeName,
+                                cssPropertyId),
         m_baseValue(initialValue) {}
 
  private:
   Member<Property> m_baseValue;
   Member<Property> m_currentValue;
 };
 
 // Implementation of SVGAnimatedProperty which uses primitive types.
 // This is for classes which return primitive type for its "animVal".
 // Examples are SVGAnimatedBoolean, SVGAnimatedNumber, etc.
@@ skipping 36 matching lines @@
   }
 
   PrimitiveType animVal() {
     this->contextElement()->ensureAttributeAnimValUpdated();
     return this->currentValue()->value();
   }
 
  protected:
   SVGAnimatedProperty(SVGElement* contextElement,
                       const QualifiedName& attributeName,
-                      Property* initialValue)
+                      Property* initialValue,
+                      CSSPropertyID cssPropertyId = CSSPropertyInvalid)
       : SVGAnimatedPropertyCommon<Property>(contextElement,
                                             attributeName,
-                                            initialValue),
+                                            initialValue,
+                                            cssPropertyId),
         m_baseValueUpdated(false) {}
 
   bool m_baseValueUpdated;
 };
 
 // Implementation of SVGAnimatedProperty which uses tear-off value types.
 // These classes has "void" for its PrimitiveType.
 // This is for classes which return special type for its "animVal".
 // Examples are SVGAnimatedLength, SVGAnimatedRect, SVGAnimated*List, etc.
 template <typename Property, typename TearOffType>
 class SVGAnimatedProperty<Property, TearOffType, void>
     : public SVGAnimatedPropertyCommon<Property> {
  public:
   static SVGAnimatedProperty<Property>* create(
       SVGElement* contextElement,
       const QualifiedName& attributeName,
-      Property* initialValue) {
+      Property* initialValue,
+      CSSPropertyID cssPropertyId = CSSPropertyInvalid) {
     return new SVGAnimatedProperty<Property>(contextElement, attributeName,
-                                             initialValue);
+                                             initialValue, cssPropertyId);
   }
 
   void setAnimatedValue(SVGPropertyBase* value) override {
     SVGAnimatedPropertyCommon<Property>::setAnimatedValue(value);
     updateAnimValTearOffIfNeeded();
   }
 
   void animationEnded() override {
     SVGAnimatedPropertyCommon<Property>::animationEnded();
     updateAnimValTearOffIfNeeded();
@@ skipping 33 matching lines @@
 
   DEFINE_INLINE_VIRTUAL_TRACE() {
     visitor->trace(m_baseValTearOff);
     visitor->trace(m_animValTearOff);
     SVGAnimatedPropertyCommon<Property>::trace(visitor);
   }
 
  protected:
   SVGAnimatedProperty(SVGElement* contextElement,
                       const QualifiedName& attributeName,
-                      Property* initialValue)
+                      Property* initialValue,
+                      CSSPropertyID cssPropertyId = CSSPropertyInvalid)
       : SVGAnimatedPropertyCommon<Property>(contextElement,
                                             attributeName,
-                                            initialValue) {}
+                                            initialValue,
+                                            cssPropertyId) {}
 
  private:
   void updateAnimValTearOffIfNeeded() {
     if (m_animValTearOff)
       m_animValTearOff->setTarget(this->currentValue());
   }
 
   // When still (not animated):
   //     Both m_animValTearOff and m_baseValTearOff target m_baseValue.
   // When animated:
   //     m_animValTearOff targets m_currentValue.
   //     m_baseValTearOff targets m_baseValue.
   Member<TearOffType> m_baseValTearOff;
   Member<TearOffType> m_animValTearOff;
 };
 
 // Implementation of SVGAnimatedProperty which doesn't use tear-off value types.
 // This class has "void" for its TearOffType.
 // Currently only used for SVGAnimatedPath.
 template <typename Property>
 class SVGAnimatedProperty<Property, void, void>
     : public SVGAnimatedPropertyCommon<Property> {
  public:
   static SVGAnimatedProperty<Property>* create(
       SVGElement* contextElement,
       const QualifiedName& attributeName,
-      Property* initialValue) {
+      Property* initialValue,
+      CSSPropertyID cssPropertyId = CSSPropertyInvalid) {
     return new SVGAnimatedProperty<Property>(contextElement, attributeName,
-                                             initialValue);
+                                             initialValue, cssPropertyId);
   }
 
   bool needsSynchronizeAttribute() override {
     // DOM attribute synchronization is only needed if the property is being
     // animated.
     return this->isAnimating();
   }
 
  protected:
   SVGAnimatedProperty(SVGElement* contextElement,
                       const QualifiedName& attributeName,
-                      Property* initialValue)
+                      Property* initialValue,
+                      CSSPropertyID cssPropertyId = CSSPropertyInvalid)
       : SVGAnimatedPropertyCommon<Property>(contextElement,
                                             attributeName,
-                                            initialValue) {}
+                                            initialValue,
+                                            cssPropertyId) {}
 };
 
 }  // namespace blink
 
 #endif  // SVGAnimatedProperty_h