[RFC] Move StyleTransformData to ComputedStyle top-level

third_party/WebKit/Source/core/style/ComputedStyle.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 163 matching lines @@
   friend class StyleBuilderConverter;
   friend class StyleResolverState;
   friend class StyleResolver;
 
  protected:
   // non-inherited attributes
   DataRef<StyleBoxData> m_box;
   DataRef<StyleVisualData> m_visual;
   DataRef<StyleBackgroundData> m_background;
   DataRef<StyleSurroundData> m_surround;
+  DataRef<StyleTransformData>
+      m_transform;  // Transform properties (rotate, scale, skew, etc.)
   DataRef<StyleRareNonInheritedData> m_rareNonInheritedData;
 
   // inherited attributes
   DataRef<StyleRareInheritedData> m_rareInheritedData;
   DataRef<StyleInheritedData> m_styleInheritedData;
 
   // list of associated pseudo styles
   std::unique_ptr<PseudoStyleCache> m_cachedPseudoStyles;
 
   DataRef<SVGComputedStyle> m_svgStyle;
@@ skipping 125 matching lines @@
     unsigned m_emptyState : 1;
 
     unsigned m_affectedByFocus : 1;
     unsigned m_affectedByHover : 1;
     unsigned m_affectedByActive : 1;
     unsigned m_affectedByDrag : 1;
 
     // 64 bits
 
     unsigned m_isLink : 1;
+    unsigned m_isStackingContext : 1;
 
     mutable unsigned m_hasRemUnits : 1;
 
     // For each independent inherited property, store a 1 if the stored
     // value was inherited from its parent, or 0 if it is explicitly set on
     // this element.
     // Eventually, all properties will have a bit in here to store whether
     // they were inherited from their parent or not.
     // Although two ComputedStyles are equal if their nonInheritedData is
     // equal regardless of the isInherited flags, this struct is stored next
     // to the existing flags to take advantage of packing as much as possible.
     // TODO(sashab): Move these flags closer to inheritedData so that it's
     // clear which inherited properties have a flag stored and which don't.
     // Keep this list of fields in sync with:
     // - setBitDefaults()
     // - The ComputedStyle setter, which must take an extra boolean parameter
     //   and set this - propagateIndependentInheritedProperties() in
     //   ComputedStyle.cpp
     // - The compareEqual() methods in the corresponding class
     // InheritedFlags
     unsigned m_isPointerEventsInherited : 1;
     unsigned m_isVisibilityInherited : 1;
     unsigned m_isWhiteSpaceInherited : 1;
 
     // If you add more style bits here, you will also need to update
-    // ComputedStyle::copyNonInheritedFromCached() 68 bits
+    // ComputedStyle::copyNonInheritedFromCached()
+
+    // 69 bits
   } m_nonInheritedData;
 
   // !END SYNC!
 
   void setBitDefaults() {
     ComputedStyleBase::setBitDefaults();
     m_inheritedData.m_listStyleType =
         static_cast<unsigned>(initialListStyleType());
     m_inheritedData.m_textAlign = static_cast<unsigned>(initialTextAlign());
     m_inheritedData.m_hasSimpleUnderline = false;
@@ skipping 30 matching lines @@
     m_nonInheritedData.m_explicitInheritance = false;
     m_nonInheritedData.m_variableReference = false;
     m_nonInheritedData.m_unique = false;
     m_nonInheritedData.m_emptyState = false;
     m_nonInheritedData.m_hasViewportUnits = false;
     m_nonInheritedData.m_affectedByFocus = false;
     m_nonInheritedData.m_affectedByHover = false;
     m_nonInheritedData.m_affectedByActive = false;
     m_nonInheritedData.m_affectedByDrag = false;
     m_nonInheritedData.m_isLink = false;
+    m_nonInheritedData.m_isStackingContext = false;
     m_nonInheritedData.m_hasRemUnits = false;
 
     // All independently inherited properties default to being inherited.
     m_nonInheritedData.m_isPointerEventsInherited = true;
     m_nonInheritedData.m_isVisibilityInherited = true;
     m_nonInheritedData.m_isWhiteSpaceInherited = true;
   }
 
  private:
   // TODO(sashab): Move these to the bottom of ComputedStyle.
@@ skipping 201 matching lines @@
   }
   void setFilter(const FilterOperations& ops) {
     SET_NESTED_VAR(m_rareNonInheritedData, m_filter, m_operations, ops);
   }
 
   // backface-visibility (aka -webkit-backface-visibility)
   static EBackfaceVisibility initialBackfaceVisibility() {
     return BackfaceVisibilityVisible;
   }
   EBackfaceVisibility backfaceVisibility() const {
-    return static_cast<EBackfaceVisibility>(
-        m_rareNonInheritedData->m_backfaceVisibility);
+    return static_cast<EBackfaceVisibility>(m_transform->m_backfaceVisibility);
   }
   void setBackfaceVisibility(EBackfaceVisibility b) {
-    SET_VAR(m_rareNonInheritedData, m_backfaceVisibility, b);
+    SET_VAR(m_transform, m_backfaceVisibility, b);
   }
 
   // Background properties.
   // background-color
   static Color initialBackgroundColor() { return Color::transparent; }
   void setBackgroundColor(const StyleColor& v) {
     SET_VAR(m_background, m_color, v);
   }
 
   // background-image
@@ skipping 783 matching lines @@
   }
   void setObjectPosition(LengthPoint position) {
     SET_VAR(m_rareNonInheritedData, m_objectPosition, position);
   }
 
   // offset-anchor
   static LengthPoint initialOffsetAnchor() {
     return LengthPoint(Length(50.0, Percent), Length(50.0, Percent));
   }
   const LengthPoint& offsetAnchor() const {
-    return m_rareNonInheritedData->m_transform->m_motion.m_anchor;
+    return m_transform->m_motion.m_anchor;
   }
   void setOffsetAnchor(const LengthPoint& offsetAnchor) {
-    SET_NESTED_VAR(m_rareNonInheritedData, m_transform, m_motion.m_anchor,
-                   offsetAnchor);
+    SET_VAR(m_transform, m_motion.m_anchor, offsetAnchor);
   }
 
   // offset-distance
   static Length initialOffsetDistance() { return Length(0, Fixed); }
   const Length& offsetDistance() const {
-    return m_rareNonInheritedData->m_transform->m_motion.m_distance;
+    return m_transform->m_motion.m_distance;
   }
   void setOffsetDistance(const Length& offsetDistance) {
-    SET_NESTED_VAR(m_rareNonInheritedData, m_transform, m_motion.m_distance,
-                   offsetDistance);
+    SET_VAR(m_transform, m_motion.m_distance, offsetDistance);
   }
 
   // offset-path
   static StylePath* initialOffsetPath() { return nullptr; }
-  StylePath* offsetPath() const {
-    return m_rareNonInheritedData->m_transform->m_motion.m_path.get();
-  }
+  StylePath* offsetPath() const { return m_transform->m_motion.m_path.get(); }
   void setOffsetPath(PassRefPtr<StylePath>);
 
   // offset-position
   static LengthPoint initialOffsetPosition() {
     return LengthPoint(Length(Auto), Length(Auto));
   }
   const LengthPoint& offsetPosition() const {
-    return m_rareNonInheritedData->m_transform->m_motion.m_position;
+    return m_transform->m_motion.m_position;
   }
   void setOffsetPosition(const LengthPoint& offsetPosition) {
-    SET_NESTED_VAR(m_rareNonInheritedData, m_transform, m_motion.m_position,
-                   offsetPosition);
+    SET_VAR(m_transform, m_motion.m_position, offsetPosition);
   }
 
   // offset-rotation
   static StyleOffsetRotation initialOffsetRotation() {
     return StyleOffsetRotation(0, OffsetRotationAuto);
   }
   const StyleOffsetRotation& offsetRotation() const {
-    return m_rareNonInheritedData->m_transform->m_motion.m_rotation;
+    return m_transform->m_motion.m_rotation;
   }
   void setOffsetRotation(const StyleOffsetRotation& offsetRotation) {
-    SET_NESTED_VAR(m_rareNonInheritedData, m_transform, m_motion.m_rotation,
-                   offsetRotation);
+    SET_VAR(m_transform, m_motion.m_rotation, offsetRotation);
   }
 
   // opacity (aka -webkit-opacity)
   static float initialOpacity() { return 1.0f; }
   float opacity() const { return m_rareNonInheritedData->opacity; }
   void setOpacity(float f) {
     float v = clampTo<float>(f, 0, 1);
     SET_VAR(m_rareNonInheritedData, opacity, v);
   }
 
@@ skipping 95 matching lines @@
   void setPaddingRight(const Length& v) {
     SET_VAR(m_surround, padding.m_right, v);
   }
 
   // padding-top
   const Length& paddingTop() const { return m_surround->padding.top(); }
   void setPaddingTop(const Length& v) { SET_VAR(m_surround, padding.m_top, v); }
 
   // perspective (aka -webkit-perspective)
   static float initialPerspective() { return 0; }
-  float perspective() const { return m_rareNonInheritedData->m_perspective; }
-  void setPerspective(float p) {
-    SET_VAR(m_rareNonInheritedData, m_perspective, p);
-  }
+  float perspective() const { return m_transform->m_perspective; }
+  void setPerspective(float p) { SET_VAR(m_transform, m_perspective, p); }
 
   // perspective-origin (aka -webkit-perspective-origin)
   static LengthPoint initialPerspectiveOrigin() {
     return LengthPoint(Length(50.0, Percent), Length(50.0, Percent));
   }
   const LengthPoint& perspectiveOrigin() const {
-    return m_rareNonInheritedData->m_perspectiveOrigin;
+    return m_transform->m_perspectiveOrigin;
   }
   void setPerspectiveOrigin(const LengthPoint& p) {
-    SET_VAR(m_rareNonInheritedData, m_perspectiveOrigin, p);
+    SET_VAR(m_transform, m_perspectiveOrigin, p);
   }
 
   // -webkit-perspective-origin-x
   static Length initialPerspectiveOriginX() { return Length(50.0, Percent); }
   const Length& perspectiveOriginX() const { return perspectiveOrigin().x(); }
   void setPerspectiveOriginX(const Length& v) {
     setPerspectiveOrigin(LengthPoint(v, perspectiveOriginY()));
   }
 
   // -webkit-perspective-origin-y
@@ skipping 16 matching lines @@
     return static_cast<EResize>(m_rareNonInheritedData->m_resize);
   }
   void setResize(EResize r) { SET_VAR(m_rareNonInheritedData, m_resize, r); }
 
   // Transform properties.
   // transform (aka -webkit-transform)
   static EmptyTransformOperations initialTransform() {
     return EmptyTransformOperations();
   }
   const TransformOperations& transform() const {
-    return m_rareNonInheritedData->m_transform->m_operations;
+    return m_transform->m_operations;
   }
   void setTransform(const TransformOperations& ops) {
-    SET_NESTED_VAR(m_rareNonInheritedData, m_transform, m_operations, ops);
+    SET_VAR(m_transform, m_operations, ops);
   }
 
   // transform-origin (aka -webkit-transform-origin)
   static TransformOrigin initialTransformOrigin() {
     return TransformOrigin(Length(50.0, Percent), Length(50.0, Percent), 0);
   }
   const TransformOrigin& transformOrigin() const {
-    return m_rareNonInheritedData->m_transform->m_origin;
+    return m_transform->m_origin;
   }
   void setTransformOrigin(const TransformOrigin& o) {
-    SET_NESTED_VAR(m_rareNonInheritedData, m_transform, m_origin, o);
+    SET_VAR(m_transform, m_origin, o);
   }
 
   // transform-style (aka -webkit-transform-style)
   static ETransformStyle3D initialTransformStyle3D() {
     return TransformStyle3DFlat;
   }
   ETransformStyle3D transformStyle3D() const {
-    return static_cast<ETransformStyle3D>(
-        m_rareNonInheritedData->m_transformStyle3D);
+    return static_cast<ETransformStyle3D>(m_transform->m_transformStyle3D);
   }
   void setTransformStyle3D(ETransformStyle3D b) {
-    SET_VAR(m_rareNonInheritedData, m_transformStyle3D, b);
+    SET_VAR(m_transform, m_transformStyle3D, b);
   }
 
   // -webkit-transform-origin-x
   static Length initialTransformOriginX() { return Length(50.0, Percent); }
   const Length& transformOriginX() const { return transformOrigin().x(); }
   void setTransformOriginX(const Length& v) {
     setTransformOrigin(
         TransformOrigin(v, transformOriginY(), transformOriginZ()));
   }
 
@@ skipping 12 matching lines @@
     setTransformOrigin(
         TransformOrigin(transformOriginX(), transformOriginY(), f));
   }
 
   // Independent transform properties.
   // translate
   static PassRefPtr<TranslateTransformOperation> initialTranslate() {
     return nullptr;
   }
   TranslateTransformOperation* translate() const {
-    return m_rareNonInheritedData->m_transform->m_translate.get();
+    return m_transform->m_translate.get();
   }
   void setTranslate(PassRefPtr<TranslateTransformOperation> v) {
-    m_rareNonInheritedData.access()->m_transform.access()->m_translate = v;
+    m_transform.access()->m_translate = v;
   }
 
   // rotate
   static PassRefPtr<RotateTransformOperation> initialRotate() {
     return nullptr;
   }
   RotateTransformOperation* rotate() const {
-    return m_rareNonInheritedData->m_transform->m_rotate.get();
+    return m_transform->m_rotate.get();
   }
   void setRotate(PassRefPtr<RotateTransformOperation> v) {
-    m_rareNonInheritedData.access()->m_transform.access()->m_rotate = v;
+    m_transform.access()->m_rotate = v;
   }
 
   // scale
   static PassRefPtr<ScaleTransformOperation> initialScale() { return nullptr; }
-  ScaleTransformOperation* scale() const {
-    return m_rareNonInheritedData->m_transform->m_scale.get();
-  }
+  ScaleTransformOperation* scale() const { return m_transform->m_scale.get(); }
   void setScale(PassRefPtr<ScaleTransformOperation> v) {
-    m_rareNonInheritedData.access()->m_transform.access()->m_scale = v;
+    m_transform.access()->m_scale = v;
   }
 
   // Scroll properties.
   // scroll-behavior
   static ScrollBehavior initialScrollBehavior() { return ScrollBehaviorAuto; }
   ScrollBehavior getScrollBehavior() const {
     return static_cast<ScrollBehavior>(
         m_rareNonInheritedData->m_scrollBehavior);
   }
   void setScrollBehavior(ScrollBehavior b) {
@@ skipping 994 matching lines @@
 
   bool affectedByDrag() const { return m_nonInheritedData.m_affectedByDrag; }
   void setAffectedByDrag() { m_nonInheritedData.m_affectedByDrag = true; }
 
   bool emptyState() const { return m_nonInheritedData.m_emptyState; }
   void setEmptyState(bool b) {
     setUnique();
     m_nonInheritedData.m_emptyState = b;
   }
 
-  bool hasInlineTransform() const {
-    return m_rareNonInheritedData->m_hasInlineTransform;
-  }
+  bool hasInlineTransform() const { return m_transform->m_hasInlineTransform; }
   void setHasInlineTransform(bool b) {
-    SET_VAR(m_rareNonInheritedData, m_hasInlineTransform, b);
+    SET_VAR(m_transform, m_hasInlineTransform, b);
   }
 
   bool hasCompositorProxy() const {
     return m_rareNonInheritedData->m_hasCompositorProxy;
   }
   void setHasCompositorProxy(bool b) {
     SET_VAR(m_rareNonInheritedData, m_hasCompositorProxy, b);
   }
 
   bool isLink() const { return m_nonInheritedData.m_isLink; }
@@ skipping 35 matching lines @@
   void setHasAuthorBorder(bool authorBorder) {
     SET_VAR(m_rareNonInheritedData, m_hasAuthorBorder, authorBorder);
   }
 
   // A stacking context is painted atomically and defines a stacking order,
   // whereas a containing stacking context defines in which order the stacking
   // contexts below are painted.
   // See CSS 2.1, Appendix E (https://www.w3.org/TR/CSS21/zindex.html) for more
   // details.
   bool isStackingContext() const {
-    return m_rareNonInheritedData->m_isStackingContext;
+    return m_nonInheritedData.m_isStackingContext;
   }
   void setIsStackingContext(bool b) {
-    SET_VAR(m_rareNonInheritedData, m_isStackingContext, b);
+    m_nonInheritedData.m_isStackingContext = b;
   }
 
   // A unique style is one that has matches something that makes it impossible
   // to share.
   bool unique() const { return m_nonInheritedData.m_unique; }
   void setUnique() { m_nonInheritedData.m_unique = true; }
 
   float textAutosizingMultiplier() const {
     return m_styleInheritedData->textAutosizingMultiplier;
   }
@@ skipping 609 matching lines @@
 
   // Motion utility functions.
   bool hasOffset() const {
     return (offsetPosition().x() != Length(Auto)) || offsetPath();
   }
 
   // Direction utility functions.
   bool isLeftToRightDirection() const { return direction() == LTR; }
 
   // Perspective utility functions.
-  bool hasPerspective() const {
-    return m_rareNonInheritedData->m_perspective > 0;
-  }
+  bool hasPerspective() const { return m_transform->m_perspective > 0; }
 
   // Page size utility functions.
   void resetPageSizeType() {
     SET_VAR(m_rareNonInheritedData, m_pageSizeType, PAGE_SIZE_AUTO);
   }
 
   // Outline utility functions.
   bool hasOutline() const {
     return outlineWidth() > 0 && outlineStyle() > BorderStyleHidden;
   }
@@ skipping 141 matching lines @@
 
   // Opacity utility functions.
   bool hasOpacity() const { return opacity() < 1.0f; }
 
   // Table layout utility functions.
   bool isFixedTableLayout() const {
     return tableLayout() == TableLayoutFixed && !logicalWidth().isAuto();
   }
 
   // Filter/transform utility functions.
-  bool has3DTransform() const {
-    return m_rareNonInheritedData->m_transform->has3DTransform();
-  }
+  bool has3DTransform() const { return m_transform->has3DTransform(); }
   bool hasTransform() const {
     return hasTransformOperations() || hasOffset() ||
            hasCurrentTransformAnimation() || translate() || rotate() || scale();
   }
   bool hasTransformOperations() const {
-    return !m_rareNonInheritedData->m_transform->m_operations.operations()
-                .isEmpty();
+    return !m_transform->m_operations.operations().isEmpty();
   }
   ETransformStyle3D usedTransformStyle3D() const {
     return hasGroupingProperty() ? TransformStyle3DFlat : transformStyle3D();
   }
   bool transformDataEquivalent(const ComputedStyle& otherStyle) const {
-    return m_rareNonInheritedData->m_transform ==
-           otherStyle.m_rareNonInheritedData->m_transform;
+    return m_transform.get() == otherStyle.m_transform.get() ||
+           m_transform->transformDataEquivalent(*otherStyle.m_transform);
   }
   bool preserves3D() const {
     return usedTransformStyle3D() != TransformStyle3DFlat;
   }
   enum ApplyTransformOrigin { IncludeTransformOrigin, ExcludeTransformOrigin };
   enum ApplyMotionPath { IncludeMotionPath, ExcludeMotionPath };
   enum ApplyIndependentTransformProperties {
     IncludeIndependentTransformProperties,
     ExcludeIndependentTransformProperties
   };
@@ skipping 475 matching lines @@
   m_nonInheritedData.m_pseudoBits |= 1 << (pseudo - 1);
 }
 
 inline bool ComputedStyle::hasPseudoElementStyle() const {
   return m_nonInheritedData.m_pseudoBits & ElementPseudoIdMask;
 }
 
 }  // namespace blink
 
 #endif  // ComputedStyle_h