Clean up naming in ComputedStyle

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
  * License as published by the Free Software Foundation; either
@@ skipping 142 matching lines @@
     DataRef<StyleInheritedData> inherited;
 
     // list of associated pseudo styles
     std::unique_ptr<PseudoStyleCache> m_cachedPseudoStyles;
 
     DataRef<SVGComputedStyle> m_svgStyle;
 
 // !START SYNC!: Keep this in sync with the copy constructor in ComputedStyle.cpp and implicitlyInherited() in StyleResolver.cpp
 
     // inherit
-    struct InheritedFlags {
-        bool operator==(const InheritedFlags& other) const
+    struct InheritedData {
+        bool operator==(const InheritedData& other) const
         {
-            return (_empty_cells == other._empty_cells)
-                && (_caption_side == other._caption_side)
-                && (_list_style_type == other._list_style_type)
-                && (_list_style_position == other._list_style_position)
-                && (_visibility == other._visibility)
-                && (_text_align == other._text_align)
-                && (_text_transform == other._text_transform)
+            return (m_emptyCells == other.m_emptyCells)
+                && (m_captionSide == other.m_captionSide)
+                && (m_listStyleType == other.m_listStyleType)
+                && (m_listStylePosition == other.m_listStylePosition)
+                && (m_visibility == other.m_visibility)
+                && (m_textAlign == other.m_textAlign)
+                && (m_textTransform == other.m_textTransform)
                 && (m_textUnderline == other.m_textUnderline)
-                && (_cursor_style == other._cursor_style)
-                && (_direction == other._direction)
-                && (_white_space == other._white_space)
-                && (_border_collapse == other._border_collapse)
-                && (_box_direction == other._box_direction)
+                && (m_cursorStyle == other.m_cursorStyle)
+                && (m_direction == other.m_direction)
+                && (m_whiteSpace == other.m_whiteSpace)
+                && (m_borderCollapse == other.m_borderCollapse)
+                && (m_boxDirection == other.m_boxDirection)
                 && (m_rtlOrdering == other.m_rtlOrdering)
                 && (m_printColorAdjust == other.m_printColorAdjust)
-                && (_pointerEvents == other._pointerEvents)
-                && (_insideLink == other._insideLink)
+                && (m_pointerEvents == other.m_pointerEvents)
+                && (m_insideLink == other.m_insideLink)
                 && (m_writingMode == other.m_writingMode);
         }
 
-        bool operator!=(const InheritedFlags& other) const { return !(*this == other); }
+        bool operator!=(const InheritedData& other) const { return !(*this == other); }
 
-        unsigned _empty_cells : 1; // EEmptyCells
-        unsigned _caption_side : 2; // ECaptionSide
-        unsigned _list_style_type : 7; // EListStyleType
-        unsigned _list_style_position : 1; // EListStylePosition
-        unsigned _visibility : 2; // EVisibility
-        unsigned _text_align : 4; // ETextAlign
-        unsigned _text_transform : 2; // ETextTransform
+        unsigned m_emptyCells : 1; // EEmptyCells
+        unsigned m_captionSide : 2; // ECaptionSide
+        unsigned m_listStyleType : 7; // EListStyleType
+        unsigned m_listStylePosition : 1; // EListStylePosition
+        unsigned m_visibility : 2; // EVisibility
+        unsigned m_textAlign : 4; // ETextAlign
+        unsigned m_textTransform : 2; // ETextTransform
         unsigned m_textUnderline : 1;
-        unsigned _cursor_style : 6; // ECursor
-        unsigned _direction : 1; // TextDirection
-        unsigned _white_space : 3; // EWhiteSpace
-        unsigned _border_collapse : 1; // EBorderCollapse
-        unsigned _box_direction : 1; // EBoxDirection (CSS3 box_direction property, flexible box layout module)
+        unsigned m_cursorStyle : 6; // ECursor
+        unsigned m_direction : 1; // TextDirection
+        unsigned m_whiteSpace : 3; // EWhiteSpace
+        unsigned m_borderCollapse : 1; // EBorderCollapse
+        unsigned m_boxDirection : 1; // EBoxDirection (CSS3 box_direction property, flexible box layout module)
         // 32 bits
 
         // non CSS2 inherited
         unsigned m_rtlOrdering : 1; // Order
         unsigned m_printColorAdjust : PrintColorAdjustBits;
-        unsigned _pointerEvents : 4; // EPointerEvents
-        unsigned _insideLink : 2; // EInsideLink
+        unsigned m_pointerEvents : 4; // EPointerEvents
+        unsigned m_insideLink : 2; // EInsideLink
 
         // CSS Text Layout Module Level 3: Vertical writing support
         unsigned m_writingMode : 2; // WritingMode
         // 42 bits
-    } inherited_flags;
+    } inherited_data;
 
 // don't inherit
-    struct NonInheritedFlags {
+    struct NonInheritedData {
         // Compare computed styles, differences in other flags should not cause an inequality.
-        bool operator==(const NonInheritedFlags& other) const
+        bool operator==(const NonInheritedData& other) const
         {
-            return effectiveDisplay == other.effectiveDisplay
-                && originalDisplay == other.originalDisplay
-                && overflowX == other.overflowX
-                && overflowY == other.overflowY
-                && verticalAlign == other.verticalAlign
-                && clear == other.clear
-                && position == other.position
-                && floating == other.floating
-                && tableLayout == other.tableLayout
-                && unicodeBidi == other.unicodeBidi
+            return m_effectiveDisplay == other.m_effectiveDisplay
+                && m_originalDisplay == other.m_originalDisplay
+                && m_overflowX == other.m_overflowX
+                && m_overflowY == other.m_overflowY
+                && m_verticalAlign == other.m_verticalAlign
+                && m_clear == other.m_clear
+                && m_position == other.m_position
+                && m_floating == other.m_floating
+                && m_tableLayout == other.m_tableLayout
+                && m_unicodeBidi == other.m_unicodeBidi
                 // hasViewportUnits
-                && breakBefore == other.breakBefore
-                && breakAfter == other.breakAfter
-                && breakInside == other.breakInside;
+                && m_breakBefore == other.m_breakBefore
+                && m_breakAfter == other.m_breakAfter
+                && m_breakInside == other.m_breakInside;
                 // styleType
                 // pseudoBits
                 // explicitInheritance
                 // unique
                 // emptyState
                 // affectedByFocus
                 // affectedByHover
                 // affectedByActive
                 // affectedByDrag
                 // isLink
         }
 
-        bool operator!=(const NonInheritedFlags& other) const { return !(*this == other); }
+        bool operator!=(const NonInheritedData& other) const { return !(*this == other); }
 
-        unsigned effectiveDisplay : 5; // EDisplay
-        unsigned originalDisplay : 5; // EDisplay
-        unsigned overflowX : 3; // EOverflow
-        unsigned overflowY : 3; // EOverflow
-        unsigned verticalAlign : 4; // EVerticalAlign
-        unsigned clear : 2; // EClear
-        unsigned position : 3; // EPosition
-        unsigned floating : 2; // EFloat
-        unsigned tableLayout : 1; // ETableLayout
-        unsigned unicodeBidi : 3; // EUnicodeBidi
+        unsigned m_effectiveDisplay : 5; // EDisplay
+        unsigned m_originalDisplay : 5; // EDisplay
+        unsigned m_overflowX : 3; // EOverflow
+        unsigned m_overflowY : 3; // EOverflow
+        unsigned m_verticalAlign : 4; // EVerticalAlign
+        unsigned m_clear : 2; // EClear
+        unsigned m_position : 3; // EPosition
+        unsigned m_floating : 2; // EFloat
+        unsigned m_tableLayout : 1; // ETableLayout
+        unsigned m_unicodeBidi : 3; // EUnicodeBidi
 
         // This is set if we used viewport units when resolving a length.
         // It is mutable so we can pass around const ComputedStyles to resolve lengths.
-        mutable unsigned hasViewportUnits : 1;
+        mutable unsigned m_hasViewportUnits : 1;
 
         // 32 bits
 
-        unsigned breakBefore : 4; // EBreak
-        unsigned breakAfter : 4; // EBreak
-        unsigned breakInside : 2; // EBreak
+        unsigned m_breakBefore : 4; // EBreak
+        unsigned m_breakAfter : 4; // EBreak
+        unsigned m_breakInside : 2; // EBreak
 
-        unsigned styleType : 6; // PseudoId
-        unsigned pseudoBits : 8;
-        unsigned explicitInheritance : 1; // Explicitly inherits a non-inherited property
-        unsigned variableReference : 1; // A non-inherited property references a variable.
-        unsigned unique : 1; // Style can not be shared.
+        unsigned m_styleType : 6; // PseudoId
+        unsigned m_pseudoBits : 8;
+        unsigned m_explicitInheritance : 1; // Explicitly inherits a non-inherited property
+        unsigned m_variableReference : 1; // A non-inherited property references a variable.
+        unsigned m_unique : 1; // Style can not be shared.
 
-        unsigned emptyState : 1;
+        unsigned m_emptyState : 1;
 
-        unsigned affectedByFocus : 1;
-        unsigned affectedByHover : 1;
-        unsigned affectedByActive : 1;
-        unsigned affectedByDrag : 1;
+        unsigned m_affectedByFocus : 1;
+        unsigned m_affectedByHover : 1;
+        unsigned m_affectedByActive : 1;
+        unsigned m_affectedByDrag : 1;
 
         // 64 bits
 
-        unsigned isLink : 1;
+        unsigned m_isLink : 1;
 
-        mutable unsigned hasRemUnits : 1;
+        mutable unsigned m_hasRemUnits : 1;
         // If you add more style bits here, you will also need to update ComputedStyle::copyNonInheritedFromCached()
         // 66 bits
-    } noninherited_flags;
+    } noninherited_data;
 
 // !END SYNC!
 
 protected:
     void setBitDefaults()
     {
-        inherited_flags._empty_cells = initialEmptyCells();
-        inherited_flags._caption_side = initialCaptionSide();
-        inherited_flags._list_style_type = initialListStyleType();
-        inherited_flags._list_style_position = initialListStylePosition();
-        inherited_flags._visibility = initialVisibility();
-        inherited_flags._text_align = initialTextAlign();
-        inherited_flags._text_transform = initialTextTransform();
-        inherited_flags.m_textUnderline = false;
-        inherited_flags._cursor_style = initialCursor();
-        inherited_flags._direction = initialDirection();
-        inherited_flags._white_space = initialWhiteSpace();
-        inherited_flags._border_collapse = initialBorderCollapse();
-        inherited_flags.m_rtlOrdering = initialRTLOrdering();
-        inherited_flags._box_direction = initialBoxDirection();
-        inherited_flags.m_printColorAdjust = initialPrintColorAdjust();
-        inherited_flags._pointerEvents = initialPointerEvents();
-        inherited_flags._insideLink = NotInsideLink;
-        inherited_flags.m_writingMode = initialWritingMode();
+        inherited_data.m_emptyCells = initialEmptyCells();
+        inherited_data.m_captionSide = initialCaptionSide();
+        inherited_data.m_listStyleType = initialListStyleType();
+        inherited_data.m_listStylePosition = initialListStylePosition();
+        inherited_data.m_visibility = initialVisibility();
+        inherited_data.m_textAlign = initialTextAlign();
+        inherited_data.m_textTransform = initialTextTransform();
+        inherited_data.m_textUnderline = false;
+        inherited_data.m_cursorStyle = initialCursor();
+        inherited_data.m_direction = initialDirection();
+        inherited_data.m_whiteSpace = initialWhiteSpace();
+        inherited_data.m_borderCollapse = initialBorderCollapse();
+        inherited_data.m_rtlOrdering = initialRTLOrdering();
+        inherited_data.m_boxDirection = initialBoxDirection();
+        inherited_data.m_printColorAdjust = initialPrintColorAdjust();
+        inherited_data.m_pointerEvents = initialPointerEvents();
+        inherited_data.m_insideLink = NotInsideLink;
+        inherited_data.m_writingMode = initialWritingMode();
 
-        noninherited_flags.effectiveDisplay = noninherited_flags.originalDisplay = initialDisplay();
-        noninherited_flags.overflowX = initialOverflowX();
-        noninherited_flags.overflowY = initialOverflowY();
-        noninherited_flags.verticalAlign = initialVerticalAlign();
-        noninherited_flags.clear = initialClear();
-        noninherited_flags.position = initialPosition();
-        noninherited_flags.floating = initialFloating();
-        noninherited_flags.tableLayout = initialTableLayout();
-        noninherited_flags.unicodeBidi = initialUnicodeBidi();
-        noninherited_flags.breakBefore = initialBreakBefore();
-        noninherited_flags.breakAfter = initialBreakAfter();
-        noninherited_flags.breakInside = initialBreakInside();
-        noninherited_flags.styleType = PseudoIdNone;
-        noninherited_flags.pseudoBits = 0;
-        noninherited_flags.explicitInheritance = false;
-        noninherited_flags.variableReference = false;
-        noninherited_flags.unique = false;
-        noninherited_flags.emptyState = false;
-        noninherited_flags.hasViewportUnits = false;
-        noninherited_flags.affectedByFocus = false;
-        noninherited_flags.affectedByHover = false;
-        noninherited_flags.affectedByActive = false;
-        noninherited_flags.affectedByDrag = false;
-        noninherited_flags.isLink = false;
-        noninherited_flags.hasRemUnits = false;
+        noninherited_data.m_effectiveDisplay = noninherited_data.m_originalDisplay = initialDisplay();
+        noninherited_data.m_overflowX = initialOverflowX();
+        noninherited_data.m_overflowY = initialOverflowY();
+        noninherited_data.m_verticalAlign = initialVerticalAlign();
+        noninherited_data.m_clear = initialClear();
+        noninherited_data.m_position = initialPosition();
+        noninherited_data.m_floating = initialFloating();
+        noninherited_data.m_tableLayout = initialTableLayout();
+        noninherited_data.m_unicodeBidi = initialUnicodeBidi();
+        noninherited_data.m_breakBefore = initialBreakBefore();
+        noninherited_data.m_breakAfter = initialBreakAfter();
+        noninherited_data.m_breakInside = initialBreakInside();
+        noninherited_data.m_styleType = PseudoIdNone;
+        noninherited_data.m_pseudoBits = 0;
+        noninherited_data.m_explicitInheritance = false;
+        noninherited_data.m_variableReference = false;
+        noninherited_data.m_unique = false;
+        noninherited_data.m_emptyState = false;
+        noninherited_data.m_hasViewportUnits = false;
+        noninherited_data.m_affectedByFocus = false;
+        noninherited_data.m_affectedByHover = false;
+        noninherited_data.m_affectedByActive = false;
+        noninherited_data.m_affectedByDrag = false;
+        noninherited_data.m_isLink = false;
+        noninherited_data.m_hasRemUnits = false;
     }
 
 private:
     ALWAYS_INLINE ComputedStyle();
 
     enum InitialStyleTag {
         InitialStyle
     };
     ALWAYS_INLINE explicit ComputedStyle(InitialStyleTag);
     ALWAYS_INLINE ComputedStyle(const ComputedStyle&);
@@ skipping 27 matching lines @@
     StyleDifference visualInvalidationDiff(const ComputedStyle&) const;
 
     enum IsAtShadowBoundary {
         AtShadowBoundary,
         NotAtShadowBoundary,
     };
 
     void inheritFrom(const ComputedStyle& inheritParent, IsAtShadowBoundary = NotAtShadowBoundary);
     void copyNonInheritedFromCached(const ComputedStyle&);
 
-    PseudoId styleType() const { return static_cast<PseudoId>(noninherited_flags.styleType); }
-    void setStyleType(PseudoId styleType) { noninherited_flags.styleType = styleType; }
+    PseudoId styleType() const { return static_cast<PseudoId>(noninherited_data.m_styleType); }
+    void setStyleType(PseudoId styleType) { noninherited_data.m_styleType = styleType; }
 
     ComputedStyle* getCachedPseudoStyle(PseudoId) const;
     ComputedStyle* addCachedPseudoStyle(PassRefPtr<ComputedStyle>);
     void removeCachedPseudoStyle(PseudoId);
 
     const PseudoStyleCache* cachedPseudoStyles() const { return m_cachedPseudoStyles.get(); }
 
-    void setHasViewportUnits(bool hasViewportUnits = true) const { noninherited_flags.hasViewportUnits = hasViewportUnits; }
-    bool hasViewportUnits() const { return noninherited_flags.hasViewportUnits; }
+    void setHasViewportUnits(bool hasViewportUnits = true) const { noninherited_data.m_hasViewportUnits = hasViewportUnits; }
+    bool hasViewportUnits() const { return noninherited_data.m_hasViewportUnits; }
 
-    void setHasRemUnits() const { noninherited_flags.hasRemUnits = true; }
-    bool hasRemUnits() const { return noninherited_flags.hasRemUnits; }
+    void setHasRemUnits() const { noninherited_data.m_hasRemUnits = true; }
+    bool hasRemUnits() const { return noninherited_data.m_hasRemUnits; }
 
-    bool affectedByFocus() const { return noninherited_flags.affectedByFocus; }
-    bool affectedByHover() const { return noninherited_flags.affectedByHover; }
-    bool affectedByActive() const { return noninherited_flags.affectedByActive; }
-    bool affectedByDrag() const { return noninherited_flags.affectedByDrag; }
+    bool affectedByFocus() const { return noninherited_data.m_affectedByFocus; }
+    bool affectedByHover() const { return noninherited_data.m_affectedByHover; }
+    bool affectedByActive() const { return noninherited_data.m_affectedByActive; }
+    bool affectedByDrag() const { return noninherited_data.m_affectedByDrag; }
 
-    void setAffectedByFocus() { noninherited_flags.affectedByFocus = true; }
-    void setAffectedByHover() { noninherited_flags.affectedByHover = true; }
-    void setAffectedByActive() { noninherited_flags.affectedByActive = true; }
-    void setAffectedByDrag() { noninherited_flags.affectedByDrag = true; }
+    void setAffectedByFocus() { noninherited_data.m_affectedByFocus = true; }
+    void setAffectedByHover() { noninherited_data.m_affectedByHover = true; }
+    void setAffectedByActive() { noninherited_data.m_affectedByActive = true; }
+    void setAffectedByDrag() { noninherited_data.m_affectedByDrag = true; }
 
     bool operator==(const ComputedStyle& other) const;
     bool operator!=(const ComputedStyle& other) const { return !(*this == other); }
-    bool isFloating() const { return noninherited_flags.floating != NoFloat; }
+    bool isFloating() const { return noninherited_data.m_floating != NoFloat; }
     bool hasMargin() const { return surround->margin.nonZero(); }
     bool hasBorderFill() const { return surround->border.hasBorderFill(); }
     bool hasBorder() const { return surround->border.hasBorder(); }
     bool hasBorderDecoration() const { return hasBorder() || hasBorderFill(); }
     bool hasPadding() const { return surround->padding.nonZero(); }
     bool hasMarginBeforeQuirk() const { return marginBefore().quirk(); }
     bool hasMarginAfterQuirk() const { return marginAfter().quirk(); }
 
     bool hasBackgroundImage() const { return m_background->background().hasImage(); }
     bool hasFixedBackgroundImage() const { return m_background->background().hasFixedImage(); }
@@ skipping 37 matching lines @@
     // of creating stacking contexts.
     bool hasNonInitialOpacity() const { return hasOpacity() || hasWillChangeOpacityHint() || hasCurrentOpacityAnimation(); }
 
     // Returns whether this style contains any grouping property as defined by [css-transforms].
     // The main purpose of this is to adjust the used value of transform-style property.
     // Note: We currently don't include every grouping property on the spec to maintain
     //       backward compatibility.
     // [css-transforms] https://drafts.csswg.org/css-transforms/#grouping-property-values
     bool hasGroupingProperty() const { return !isOverflowVisible() || hasFilterInducingProperty() || hasNonInitialOpacity(); }
 
-    Order rtlOrdering() const { return static_cast<Order>(inherited_flags.m_rtlOrdering); }
-    void setRTLOrdering(Order o) { inherited_flags.m_rtlOrdering = o; }
+    Order rtlOrdering() const { return static_cast<Order>(inherited_data.m_rtlOrdering); }
+    void setRTLOrdering(Order o) { inherited_data.m_rtlOrdering = o; }
 
     bool isStyleAvailable() const;
 
     bool hasAnyPublicPseudoStyles() const;
     bool hasPseudoStyle(PseudoId) const;
     void setHasPseudoStyle(PseudoId);
     bool hasUniquePseudoStyle() const;
     bool hasPseudoElementStyle() const;
 
     bool canContainAbsolutePositionObjects() const { return position() != StaticPosition; }
     bool canContainFixedPositionObjects() const { return hasTransformRelatedProperty() || containsPaint();}
 
     // attribute getter methods
 
-    EDisplay display() const { return static_cast<EDisplay>(noninherited_flags.effectiveDisplay); }
-    EDisplay originalDisplay() const { return static_cast<EDisplay>(noninherited_flags.originalDisplay); }
+    EDisplay display() const { return static_cast<EDisplay>(noninherited_data.m_effectiveDisplay); }
+    EDisplay originalDisplay() const { return static_cast<EDisplay>(noninherited_data.m_originalDisplay); }
 
     const Length& left() const { return surround->offset.left(); }
     const Length& right() const { return surround->offset.right(); }
     const Length& top() const { return surround->offset.top(); }
     const Length& bottom() const { return surround->offset.bottom(); }
 
     // Accessors for positioned object edges that take into account writing mode.
     const Length& logicalLeft() const { return surround->offset.logicalLeft(getWritingMode()); }
     const Length& logicalRight() const { return surround->offset.logicalRight(getWritingMode()); }
     const Length& logicalTop() const { return surround->offset.before(getWritingMode()); }
     const Length& logicalBottom() const { return surround->offset.after(getWritingMode()); }
 
     // Whether or not a positioned element requires normal flow x/y to be computed
     // to determine its position.
     bool hasAutoLeftAndRight() const { return left().isAuto() && right().isAuto(); }
     bool hasAutoTopAndBottom() const { return top().isAuto() && bottom().isAuto(); }
     bool hasStaticInlinePosition(bool horizontal) const { return horizontal ? hasAutoLeftAndRight() : hasAutoTopAndBottom(); }
     bool hasStaticBlockPosition(bool horizontal) const { return horizontal ? hasAutoTopAndBottom() : hasAutoLeftAndRight(); }
 
-    EPosition position() const { return static_cast<EPosition>(noninherited_flags.position); }
+    EPosition position() const { return static_cast<EPosition>(noninherited_data.m_position); }
     bool hasOutOfFlowPosition() const { return position() == AbsolutePosition || position() == FixedPosition; }
     bool hasInFlowPosition() const { return position() == RelativePosition || position() == StickyPosition; }
     bool hasViewportConstrainedPosition() const { return position() == FixedPosition || position() == StickyPosition; }
-    EFloat floating() const { return static_cast<EFloat>(noninherited_flags.floating); }
+    EFloat floating() const { return static_cast<EFloat>(noninherited_data.m_floating); }
 
     const Length& width() const { return m_box->width(); }
     const Length& height() const { return m_box->height(); }
     const Length& minWidth() const { return m_box->minWidth(); }
     const Length& maxWidth() const { return m_box->maxWidth(); }
     const Length& minHeight() const { return m_box->minHeight(); }
     const Length& maxHeight() const { return m_box->maxHeight(); }
 
     const Length& logicalWidth() const { return isHorizontalWritingMode() ? width() : height(); }
     const Length& logicalHeight() const { return isHorizontalWritingMode() ? height() : width(); }
@@ skipping 46 matching lines @@
     {
         if (m_background->outline().style() == BorderStyleNone)
             return 0;
         return m_background->outline().width();
     }
     bool hasOutline() const { return outlineWidth() > 0 && outlineStyle() > BorderStyleHidden; }
     EBorderStyle outlineStyle() const { return m_background->outline().style(); }
     OutlineIsAuto outlineStyleIsAuto() const { return static_cast<OutlineIsAuto>(m_background->outline().isAuto()); }
     int outlineOutsetExtent() const;
 
-    EOverflow overflowX() const { return static_cast<EOverflow>(noninherited_flags.overflowX); }
-    EOverflow overflowY() const { return static_cast<EOverflow>(noninherited_flags.overflowY); }
+    EOverflow overflowX() const { return static_cast<EOverflow>(noninherited_data.m_overflowX); }
+    EOverflow overflowY() const { return static_cast<EOverflow>(noninherited_data.m_overflowY); }
     // It's sufficient to just check one direction, since it's illegal to have visible on only one overflow value.
     bool isOverflowVisible() const { ASSERT(overflowX() != OverflowVisible || overflowX() == overflowY()); return overflowX() == OverflowVisible; }
     bool isOverflowPaged() const { return overflowY() == OverflowPagedX || overflowY() == OverflowPagedY; }
 
-    EVisibility visibility() const { return static_cast<EVisibility>(inherited_flags._visibility); }
-    EVerticalAlign verticalAlign() const { return static_cast<EVerticalAlign>(noninherited_flags.verticalAlign); }
+    EVisibility visibility() const { return static_cast<EVisibility>(inherited_data.m_visibility); }
+    EVerticalAlign verticalAlign() const { return static_cast<EVerticalAlign>(noninherited_data.m_verticalAlign); }
     const Length& getVerticalAlignLength() const { return m_box->verticalAlign(); }
 
     const Length& clipLeft() const { return visual->clip.left(); }
     const Length& clipRight() const { return visual->clip.right(); }
     const Length& clipTop() const { return visual->clip.top(); }
     const Length& clipBottom() const { return visual->clip.bottom(); }
     const LengthBox& clip() const { return visual->clip; }
     bool hasAutoClip() const { return visual->hasAutoClip; }
 
-    EUnicodeBidi unicodeBidi() const { return static_cast<EUnicodeBidi>(noninherited_flags.unicodeBidi); }
+    EUnicodeBidi unicodeBidi() const { return static_cast<EUnicodeBidi>(noninherited_data.m_unicodeBidi); }
 
-    EClear clear() const { return static_cast<EClear>(noninherited_flags.clear); }
-    ETableLayout tableLayout() const { return static_cast<ETableLayout>(noninherited_flags.tableLayout); }
+    EClear clear() const { return static_cast<EClear>(noninherited_data.m_clear); }
+    ETableLayout tableLayout() const { return static_cast<ETableLayout>(noninherited_data.m_tableLayout); }
     bool isFixedTableLayout() const { return tableLayout() == TableLayoutFixed && !logicalWidth().isAuto(); }
 
     const Font& font() const;
     const FontMetrics& getFontMetrics() const;
     const FontDescription& getFontDescription() const;
     float specifiedFontSize() const;
     float computedFontSize() const;
     int fontSize() const;
     float fontSizeAdjust() const;
     bool hasFontSizeAdjust() const;
     FontWeight fontWeight() const;
     FontStretch fontStretch() const;
 
     float textAutosizingMultiplier() const { return inherited->textAutosizingMultiplier; }
 
     const Length& textIndent() const { return rareInheritedData->indent; }
     TextIndentLine getTextIndentLine() const { return static_cast<TextIndentLine>(rareInheritedData->m_textIndentLine); }
     TextIndentType getTextIndentType() const { return static_cast<TextIndentType>(rareInheritedData->m_textIndentType); }
-    ETextAlign textAlign() const { return static_cast<ETextAlign>(inherited_flags._text_align); }
+    ETextAlign textAlign() const { return static_cast<ETextAlign>(inherited_data.m_textAlign); }
     TextAlignLast getTextAlignLast() const { return static_cast<TextAlignLast>(rareInheritedData->m_textAlignLast); }
     TextJustify getTextJustify() const { return static_cast<TextJustify>(rareInheritedData->m_textJustify); }
-    ETextTransform textTransform() const { return static_cast<ETextTransform>(inherited_flags._text_transform); }
+    ETextTransform textTransform() const { return static_cast<ETextTransform>(inherited_data.m_textTransform); }
     TextDecoration textDecorationsInEffect() const;
     const Vector<AppliedTextDecoration>& appliedTextDecorations() const;
     TextDecoration getTextDecoration() const { return static_cast<TextDecoration>(visual->textDecoration); }
     TextUnderlinePosition getTextUnderlinePosition() const { return static_cast<TextUnderlinePosition>(rareInheritedData->m_textUnderlinePosition); }
     TextDecorationStyle getTextDecorationStyle() const { return static_cast<TextDecorationStyle>(rareNonInheritedData->m_textDecorationStyle); }
     float wordSpacing() const;
     float letterSpacing() const;
     StyleVariableData* variables() const;
 
     void setVariable(const AtomicString&, PassRefPtr<CSSVariableData>);
     void removeVariable(const AtomicString&);
 
     float zoom() const { return visual->m_zoom; }
     float effectiveZoom() const { return rareInheritedData->m_effectiveZoom; }
 
-    TextDirection direction() const { return static_cast<TextDirection>(inherited_flags._direction); }
+    TextDirection direction() const { return static_cast<TextDirection>(inherited_data.m_direction); }
     bool isLeftToRightDirection() const { return direction() == LTR; }
     bool selfOrAncestorHasDirAutoAttribute() const { return rareInheritedData->m_selfOrAncestorHasDirAutoAttribute; }
 
     const Length& specifiedLineHeight() const;
     Length lineHeight() const;
     int computedLineHeight() const;
 
-    EWhiteSpace whiteSpace() const { return static_cast<EWhiteSpace>(inherited_flags._white_space); }
+    EWhiteSpace whiteSpace() const { return static_cast<EWhiteSpace>(inherited_data.m_whiteSpace); }
     static bool autoWrap(EWhiteSpace ws)
     {
         // Nowrap and pre don't automatically wrap.
         return ws != NOWRAP && ws != PRE;
     }
 
     bool autoWrap() const
     {
         return autoWrap(whiteSpace());
     }
@@ skipping 51 matching lines @@
     FillLayer& accessMaskLayers() { return rareNonInheritedData.access()->m_mask; }
     const FillLayer& maskLayers() const { return rareNonInheritedData->m_mask; }
 
     const NinePieceImage& maskBoxImage() const { return rareNonInheritedData->m_maskBoxImage; }
     StyleImage* maskBoxImageSource() const { return rareNonInheritedData->m_maskBoxImage.image(); }
     const LengthBox& maskBoxImageSlices() const { return rareNonInheritedData->m_maskBoxImage.imageSlices(); }
     bool maskBoxImageSlicesFill() const { return rareNonInheritedData->m_maskBoxImage.fill(); }
     const BorderImageLengthBox& maskBoxImageWidth() const { return rareNonInheritedData->m_maskBoxImage.borderSlices(); }
     const BorderImageLengthBox& maskBoxImageOutset() const { return rareNonInheritedData->m_maskBoxImage.outset(); }
 
-    EBorderCollapse borderCollapse() const { return static_cast<EBorderCollapse>(inherited_flags._border_collapse); }
+    EBorderCollapse borderCollapse() const { return static_cast<EBorderCollapse>(inherited_data.m_borderCollapse); }
     short horizontalBorderSpacing() const;
     short verticalBorderSpacing() const;
-    EEmptyCells emptyCells() const { return static_cast<EEmptyCells>(inherited_flags._empty_cells); }
-    ECaptionSide captionSide() const { return static_cast<ECaptionSide>(inherited_flags._caption_side); }
+    EEmptyCells emptyCells() const { return static_cast<EEmptyCells>(inherited_data.m_emptyCells); }
+    ECaptionSide captionSide() const { return static_cast<ECaptionSide>(inherited_data.m_captionSide); }
 
-    EListStyleType listStyleType() const { return static_cast<EListStyleType>(inherited_flags._list_style_type); }
+    EListStyleType listStyleType() const { return static_cast<EListStyleType>(inherited_data.m_listStyleType); }
     StyleImage* listStyleImage() const;
-    EListStylePosition listStylePosition() const { return static_cast<EListStylePosition>(inherited_flags._list_style_position); }
+    EListStylePosition listStylePosition() const { return static_cast<EListStylePosition>(inherited_data.m_listStylePosition); }
 
     const Length& marginTop() const { return surround->margin.top(); }
     const Length& marginBottom() const { return surround->margin.bottom(); }
     const Length& marginLeft() const { return surround->margin.left(); }
     const Length& marginRight() const { return surround->margin.right(); }
     const Length& marginBefore() const { return surround->margin.before(getWritingMode()); }
     const Length& marginAfter() const { return surround->margin.after(getWritingMode()); }
     const Length& marginStart() const { return surround->margin.start(getWritingMode(), direction()); }
     const Length& marginEnd() const { return surround->margin.end(getWritingMode(), direction()); }
     const Length& marginOver() const { return surround->margin.over(getWritingMode()); }
     const Length& marginUnder() const { return surround->margin.under(getWritingMode()); }
     const Length& marginStartUsing(const ComputedStyle* otherStyle) const { return surround->margin.start(otherStyle->getWritingMode(), otherStyle->direction()); }
     const Length& marginEndUsing(const ComputedStyle* otherStyle) const { return surround->margin.end(otherStyle->getWritingMode(), otherStyle->direction()); }
     const Length& marginBeforeUsing(const ComputedStyle* otherStyle) const { return surround->margin.before(otherStyle->getWritingMode()); }
     const Length& marginAfterUsing(const ComputedStyle* otherStyle) const { return surround->margin.after(otherStyle->getWritingMode()); }
 
     const LengthBox& paddingBox() const { return surround->padding; }
     const Length& paddingTop() const { return surround->padding.top(); }
     const Length& paddingBottom() const { return surround->padding.bottom(); }
     const Length& paddingLeft() const { return surround->padding.left(); }
     const Length& paddingRight() const { return surround->padding.right(); }
     const Length& paddingBefore() const { return surround->padding.before(getWritingMode()); }
     const Length& paddingAfter() const { return surround->padding.after(getWritingMode()); }
     const Length& paddingStart() const { return surround->padding.start(getWritingMode(), direction()); }
     const Length& paddingEnd() const { return surround->padding.end(getWritingMode(), direction()); }
     const Length& paddingOver() const { return surround->padding.over(getWritingMode()); }
     const Length& paddingUnder() const { return surround->padding.under(getWritingMode()); }
 
-    ECursor cursor() const { return static_cast<ECursor>(inherited_flags._cursor_style); }
+    ECursor cursor() const { return static_cast<ECursor>(inherited_data.m_cursorStyle); }
     CursorList* cursors() const { return rareInheritedData->cursorData.get(); }
 
-    EInsideLink insideLink() const { return static_cast<EInsideLink>(inherited_flags._insideLink); }
-    bool isLink() const { return noninherited_flags.isLink; }
+    EInsideLink insideLink() const { return static_cast<EInsideLink>(inherited_data.m_insideLink); }
+    bool isLink() const { return noninherited_data.m_isLink; }
 
     short widows() const { return rareInheritedData->widows; }
     short orphans() const { return rareInheritedData->orphans; }
-    EBreak breakAfter() const { return static_cast<EBreak>(noninherited_flags.breakAfter); }
-    EBreak breakBefore() const { return static_cast<EBreak>(noninherited_flags.breakBefore); }
-    EBreak breakInside() const { return static_cast<EBreak>(noninherited_flags.breakInside); }
+    EBreak breakAfter() const { return static_cast<EBreak>(noninherited_data.m_breakAfter); }
+    EBreak breakBefore() const { return static_cast<EBreak>(noninherited_data.m_breakBefore); }
+    EBreak breakInside() const { return static_cast<EBreak>(noninherited_data.m_breakInside); }
 
     TextSizeAdjust getTextSizeAdjust() const { return rareInheritedData->m_textSizeAdjust; }
 
     // CSS3 Getter Methods
 
     int outlineOffset() const
     {
         if (m_background->outline().style() == BorderStyleNone)
             return 0;
         return m_background->outline().offset();
     }
 
     ShadowList* textShadow() const { return rareInheritedData->textShadow.get(); }
 
     float textStrokeWidth() const { return rareInheritedData->textStrokeWidth; }
     float opacity() const { return rareNonInheritedData->opacity; }
     bool hasOpacity() const { return opacity() < 1.0f; }
     ControlPart appearance() const { return static_cast<ControlPart>(rareNonInheritedData->m_appearance); }
     EBoxAlignment boxAlign() const { return static_cast<EBoxAlignment>(rareNonInheritedData->m_deprecatedFlexibleBox->align); }
-    EBoxDirection boxDirection() const { return static_cast<EBoxDirection>(inherited_flags._box_direction); }
+    EBoxDirection boxDirection() const { return static_cast<EBoxDirection>(inherited_data.m_boxDirection); }
     float boxFlex() const { return rareNonInheritedData->m_deprecatedFlexibleBox->flex; }
     unsigned boxFlexGroup() const { return rareNonInheritedData->m_deprecatedFlexibleBox->flexGroup; }
     EBoxLines boxLines() const { return static_cast<EBoxLines>(rareNonInheritedData->m_deprecatedFlexibleBox->lines); }
     unsigned boxOrdinalGroup() const { return rareNonInheritedData->m_deprecatedFlexibleBox->ordinalGroup; }
     EBoxOrient boxOrient() const { return static_cast<EBoxOrient>(rareNonInheritedData->m_deprecatedFlexibleBox->orient); }
     EBoxPack boxPack() const { return static_cast<EBoxPack>(rareNonInheritedData->m_deprecatedFlexibleBox->pack); }
 
     int order() const { return rareNonInheritedData->m_order; }
     const Vector<String>& callbackSelectors() const { return rareNonInheritedData->m_callbackSelectors; }
     float flexGrow() const { return rareNonInheritedData->m_flexibleBox->m_flexGrow; }
@@ skipping 165 matching lines @@
     uint8_t snapHeightPosition() const { return rareInheritedData->m_snapHeightPosition; }
     uint8_t snapHeightUnit() const { return rareInheritedData->m_snapHeightUnit; }
 
     TabSize getTabSize() const { return rareInheritedData->m_tabSize; }
 
     RespectImageOrientationEnum respectImageOrientation() const { return static_cast<RespectImageOrientationEnum>(rareInheritedData->m_respectImageOrientation); }
 
     // End CSS3 Getters
 
     // Apple-specific property getter methods
-    EPointerEvents pointerEvents() const { return static_cast<EPointerEvents>(inherited_flags._pointerEvents); }
+    EPointerEvents pointerEvents() const { return static_cast<EPointerEvents>(inherited_data.m_pointerEvents); }
     const CSSAnimationData* animations() const { return rareNonInheritedData->m_animations.get(); }
     const CSSTransitionData* transitions() const { return rareNonInheritedData->m_transitions.get(); }
 
     CSSAnimationData& accessAnimations();
     CSSTransitionData& accessTransitions();
 
     ETransformStyle3D transformStyle3D() const { return static_cast<ETransformStyle3D>(rareNonInheritedData->m_transformStyle3D); }
     ETransformStyle3D usedTransformStyle3D() const { return hasGroupingProperty() ? TransformStyle3DFlat : transformStyle3D(); }
     bool preserves3D() const { return usedTransformStyle3D() != TransformStyle3DFlat; }
 
@@ skipping 15 matching lines @@
     bool isRunningOpacityAnimationOnCompositor() const { return rareNonInheritedData->m_runningOpacityAnimationOnCompositor; }
     bool isRunningTransformAnimationOnCompositor() const { return rareNonInheritedData->m_runningTransformAnimationOnCompositor; }
     bool isRunningFilterAnimationOnCompositor() const { return rareNonInheritedData->m_runningFilterAnimationOnCompositor; }
     bool isRunningBackdropFilterAnimationOnCompositor() const { return rareNonInheritedData->m_runningBackdropFilterAnimationOnCompositor; }
     bool isRunningAnimationOnCompositor() const { return isRunningOpacityAnimationOnCompositor() || isRunningTransformAnimationOnCompositor() || isRunningFilterAnimationOnCompositor() || isRunningBackdropFilterAnimationOnCompositor(); }
 
     const LineClampValue& lineClamp() const { return rareNonInheritedData->lineClamp; }
     Color tapHighlightColor() const { return rareInheritedData->tapHighlightColor; }
     ETextSecurity textSecurity() const { return static_cast<ETextSecurity>(rareInheritedData->textSecurity); }
 
-    WritingMode getWritingMode() const { return static_cast<WritingMode>(inherited_flags.m_writingMode); }
+    WritingMode getWritingMode() const { return static_cast<WritingMode>(inherited_data.m_writingMode); }
     bool isHorizontalWritingMode() const { return blink::isHorizontalWritingMode(getWritingMode()); }
     bool isFlippedLinesWritingMode() const { return blink::isFlippedLinesWritingMode(getWritingMode()); }
     bool isFlippedBlocksWritingMode() const { return blink::isFlippedBlocksWritingMode(getWritingMode()); }
 
     EImageRendering imageRendering() const { return static_cast<EImageRendering>(rareInheritedData->m_imageRendering); }
 
     ESpeak speak() const { return static_cast<ESpeak>(rareInheritedData->speak); }
 
     FilterOperations& mutableFilter() { return rareNonInheritedData.access()->m_filter.access()->m_operations; }
     const FilterOperations& filter() const { return rareNonInheritedData->m_filter->m_operations; }
@@ skipping 26 matching lines @@
     const Vector<CSSPropertyID>& willChangeProperties() const { return rareNonInheritedData->m_willChange->m_properties; }
     bool willChangeContents() const { return rareNonInheritedData->m_willChange->m_contents; }
     bool willChangeScrollPosition() const { return rareNonInheritedData->m_willChange->m_scrollPosition; }
     bool hasWillChangeCompositingHint() const;
     bool hasWillChangeOpacityHint() const { return willChangeProperties().contains(CSSPropertyOpacity); }
     bool hasWillChangeTransformHint() const;
     bool subtreeWillChangeContents() const { return rareInheritedData->m_subtreeWillChangeContents; }
 
 // attribute setter methods
 
-    void setDisplay(EDisplay v) { noninherited_flags.effectiveDisplay = v; }
-    void setOriginalDisplay(EDisplay v) { noninherited_flags.originalDisplay = v; }
-    void setPosition(EPosition v) { noninherited_flags.position = v; }
-    void setFloating(EFloat v) { noninherited_flags.floating = v; }
+    void setDisplay(EDisplay v) { noninherited_data.m_effectiveDisplay = v; }
+    void setOriginalDisplay(EDisplay v) { noninherited_data.m_originalDisplay = v; }
+    void setPosition(EPosition v) { noninherited_data.m_position = v; }
+    void setFloating(EFloat v) { noninherited_data.m_floating = v; }
 
     void setLeft(const Length& v) { SET_VAR(surround, offset.m_left, v); }
     void setRight(const Length& v) { SET_VAR(surround, offset.m_right, v); }
     void setTop(const Length& v) { SET_VAR(surround, offset.m_top, v); }
     void setBottom(const Length& v) { SET_VAR(surround, offset.m_bottom, v); }
 
     void setWidth(const Length& v) { SET_VAR(m_box, m_width, v); }
     void setHeight(const Length& v) { SET_VAR(m_box, m_height, v); }
 
     void setLogicalWidth(const Length& v)
@@ skipping 100 matching lines @@
         if (!otherStyle)
             return !hasOutline();
         return m_background->outline().visuallyEqual(otherStyle->m_background->outline());
     }
     void setOutlineFromStyle(const ComputedStyle& o)
     {
         ASSERT(!isOutlineEquivalent(&o));
         m_background.access()->m_outline = o.m_background->m_outline;
     }
 
-    void setOverflowX(EOverflow v) { noninherited_flags.overflowX = v; }
-    void setOverflowY(EOverflow v) { noninherited_flags.overflowY = v; }
-    void setVisibility(EVisibility v) { inherited_flags._visibility = v; }
-    void setVerticalAlign(EVerticalAlign v) { noninherited_flags.verticalAlign = v; }
+    void setOverflowX(EOverflow v) { noninherited_data.m_overflowX = v; }
+    void setOverflowY(EOverflow v) { noninherited_data.m_overflowY = v; }
+    void setVisibility(EVisibility v) { inherited_data.m_visibility = v; }
+    void setVerticalAlign(EVerticalAlign v) { noninherited_data.m_verticalAlign = v; }
     void setVerticalAlignLength(const Length& length) { setVerticalAlign(VerticalAlignLength); SET_VAR(m_box, m_verticalAlign, length); }
 
     void setHasAutoClip() { SET_VAR(visual, hasAutoClip, true); SET_VAR(visual, clip, ComputedStyle::initialClip()); }
     void setClip(const LengthBox& box) { SET_VAR(visual, hasAutoClip, false); SET_VAR(visual, clip, box); }
 
-    void setUnicodeBidi(EUnicodeBidi b) { noninherited_flags.unicodeBidi = b; }
+    void setUnicodeBidi(EUnicodeBidi b) { noninherited_data.m_unicodeBidi = b; }
 
-    void setClear(EClear v) { noninherited_flags.clear = v; }
-    void setTableLayout(ETableLayout v) { noninherited_flags.tableLayout = v; }
+    void setClear(EClear v) { noninherited_data.m_clear = v; }
+    void setTableLayout(ETableLayout v) { noninherited_data.m_tableLayout = v; }
 
     bool setFontDescription(const FontDescription&);
     void setFont(const Font&);
 
     void setTextAutosizingMultiplier(float);
 
     void setColor(const Color&);
     void setTextIndent(const Length& v) { SET_VAR(rareInheritedData, indent, v); }
     void setTextIndentLine(TextIndentLine v) { SET_VAR(rareInheritedData, m_textIndentLine, v); }
     void setTextIndentType(TextIndentType v) { SET_VAR(rareInheritedData, m_textIndentType, v); }
-    void setTextAlign(ETextAlign v) { inherited_flags._text_align = v; }
+    void setTextAlign(ETextAlign v) { inherited_data.m_textAlign = v; }
     void setTextAlignLast(TextAlignLast v) { SET_VAR(rareInheritedData, m_textAlignLast, v); }
     void setTextJustify(TextJustify v) { SET_VAR(rareInheritedData, m_textJustify, v); }
-    void setTextTransform(ETextTransform v) { inherited_flags._text_transform = v; }
+    void setTextTransform(ETextTransform v) { inherited_data.m_textTransform = v; }
     void applyTextDecorations();
     void clearAppliedTextDecorations();
     void setTextDecoration(TextDecoration v) { SET_VAR(visual, textDecoration, v); }
     void setTextUnderlinePosition(TextUnderlinePosition v) { SET_VAR(rareInheritedData, m_textUnderlinePosition, v); }
     void setTextDecorationStyle(TextDecorationStyle v) { SET_VAR(rareNonInheritedData, m_textDecorationStyle, v); }
-    void setDirection(TextDirection v) { inherited_flags._direction = v; }
+    void setDirection(TextDirection v) { inherited_data.m_direction = v; }
     void setSelfOrAncestorHasDirAutoAttribute(bool v) { SET_VAR(rareInheritedData, m_selfOrAncestorHasDirAutoAttribute, v); }
     void setLineHeight(const Length& specifiedLineHeight);
     bool setZoom(float);
     bool setEffectiveZoom(float);
     void clearMultiCol();
 
     void setImageRendering(EImageRendering v) { SET_VAR(rareInheritedData, m_imageRendering, v); }
 
-    void setWhiteSpace(EWhiteSpace v) { inherited_flags._white_space = v; }
+    void setWhiteSpace(EWhiteSpace v) { inherited_data.m_whiteSpace = v; }
 
     // FIXME: Remove these two and replace them with respective FontBuilder calls.
     void setWordSpacing(float);
     void setLetterSpacing(float);
 
     void adjustBackgroundLayers()
     {
         if (backgroundLayers().next()) {
             accessBackgroundLayers().cullEmptyLayers();
             accessBackgroundLayers().fillUnsetProperties();
@@ skipping 20 matching lines @@
     }
     void setMaskBoxImageWidth(const BorderImageLengthBox& slices)
     {
         rareNonInheritedData.access()->m_maskBoxImage.setBorderSlices(slices);
     }
     void setMaskBoxImageOutset(const BorderImageLengthBox& outset)
     {
         rareNonInheritedData.access()->m_maskBoxImage.setOutset(outset);
     }
 
-    void setBorderCollapse(EBorderCollapse collapse) { inherited_flags._border_collapse = collapse; }
+    void setBorderCollapse(EBorderCollapse collapse) { inherited_data.m_borderCollapse = collapse; }
     void setHorizontalBorderSpacing(short);
     void setVerticalBorderSpacing(short);
-    void setEmptyCells(EEmptyCells v) { inherited_flags._empty_cells = v; }
-    void setCaptionSide(ECaptionSide v) { inherited_flags._caption_side = v; }
+    void setEmptyCells(EEmptyCells v) { inherited_data.m_emptyCells = v; }
+    void setCaptionSide(ECaptionSide v) { inherited_data.m_captionSide = v; }
 
-    void setListStyleType(EListStyleType v) { inherited_flags._list_style_type = v; }
+    void setListStyleType(EListStyleType v) { inherited_data.m_listStyleType = v; }
     void setListStyleImage(StyleImage*);
-    void setListStylePosition(EListStylePosition v) { inherited_flags._list_style_position = v; }
+    void setListStylePosition(EListStylePosition v) { inherited_data.m_listStylePosition = v; }
 
     void setMarginTop(const Length& v) { SET_VAR(surround, margin.m_top, v); }
     void setMarginBottom(const Length& v) { SET_VAR(surround, margin.m_bottom, v); }
     void setMarginLeft(const Length& v) { SET_VAR(surround, margin.m_left, v); }
     void setMarginRight(const Length& v) { SET_VAR(surround, margin.m_right, v); }
     void setMarginStart(const Length&);
     void setMarginEnd(const Length&);
 
     void resetPadding() { SET_VAR(surround, padding, LengthBox(Fixed)); }
     void setPaddingBox(const LengthBox& b) { SET_VAR(surround, padding, b); }
     void setPaddingTop(const Length& v) { SET_VAR(surround, padding.m_top, v); }
     void setPaddingBottom(const Length& v) { SET_VAR(surround, padding.m_bottom, v); }
     void setPaddingLeft(const Length& v) { SET_VAR(surround, padding.m_left, v); }
     void setPaddingRight(const Length& v) { SET_VAR(surround, padding.m_right, v); }
 
-    void setCursor(ECursor c) { inherited_flags._cursor_style = c; }
+    void setCursor(ECursor c) { inherited_data.m_cursorStyle = c; }
     void addCursor(StyleImage*, bool hotSpotSpecified, const IntPoint& hotSpot = IntPoint());
     void setCursorList(CursorList*);
     void clearCursorList();
 
-    void setInsideLink(EInsideLink insideLink) { inherited_flags._insideLink = insideLink; }
-    void setIsLink(bool b) { noninherited_flags.isLink = b; }
+    void setInsideLink(EInsideLink insideLink) { inherited_data.m_insideLink = insideLink; }
+    void setIsLink(bool b) { noninherited_data.m_isLink = b; }
 
-    PrintColorAdjust getPrintColorAdjust() const { return static_cast<PrintColorAdjust>(inherited_flags.m_printColorAdjust); }
-    void setPrintColorAdjust(PrintColorAdjust value) { inherited_flags.m_printColorAdjust = value; }
+    PrintColorAdjust getPrintColorAdjust() const { return static_cast<PrintColorAdjust>(inherited_data.m_printColorAdjust); }
+    void setPrintColorAdjust(PrintColorAdjust value) { inherited_data.m_printColorAdjust = value; }
 
     // 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. In Blink, a stacking context is defined by non-auto
     // z-index'. This invariant is enforced by the logic in StyleAdjuster
     // See CSS 2.1, Appendix E (https://www.w3.org/TR/CSS21/zindex.html) for more details.
     bool isStackingContext() const { return !hasAutoZIndex(); }
 
     // Stacking contexts and positioned elements[1] are stacked (sorted in negZOrderList
     // and posZOrderList) in their enclosing stacking contexts.
     //
     // [1] According to CSS2.1, Appendix E.2.8 (https://www.w3.org/TR/CSS21/zindex.html),
     // positioned elements with 'z-index: auto' are "treated as if it created a new
     // stacking context" and z-ordered together with other elements with 'z-index: 0'.
     // The difference of them from normal stacking contexts is that they don't determine
     // the stacking of the elements underneath them.
     // (Note: There are also other elements treated as stacking context during painting,
     // but not managed in stacks. See ObjectPainter::paintAllPhasesAtomically().)
     bool isStacked() const { return isStackingContext() || position() != StaticPosition; }
 
     bool hasAutoZIndex() const { return m_box->hasAutoZIndex(); }
     void setHasAutoZIndex() { SET_VAR(m_box, m_hasAutoZIndex, true); SET_VAR(m_box, m_zIndex, 0); }
     int zIndex() const { return m_box->zIndex(); }
     void setZIndex(int v) { SET_VAR(m_box, m_hasAutoZIndex, false); SET_VAR(m_box, m_zIndex, v); }
     void setWidows(short w) { SET_VAR(rareInheritedData, widows, w); }
     void setOrphans(short o) { SET_VAR(rareInheritedData, orphans, o); }
-    void setBreakAfter(EBreak b) { ASSERT(b <= BreakValueLastAllowedForBreakAfterAndBefore); noninherited_flags.breakAfter = b; }
-    void setBreakBefore(EBreak b) { ASSERT(b <= BreakValueLastAllowedForBreakAfterAndBefore); noninherited_flags.breakBefore = b;  }
-    void setBreakInside(EBreak b) { ASSERT(b <= BreakValueLastAllowedForBreakInside); noninherited_flags.breakInside = b;  }
+    void setBreakAfter(EBreak b) { DCHECK_LE(b, BreakValueLastAllowedForBreakAfterAndBefore); noninherited_data.m_breakAfter = b; }
+    void setBreakBefore(EBreak b) { DCHECK_LE(b, BreakValueLastAllowedForBreakAfterAndBefore); noninherited_data.m_breakBefore = b;  }
+    void setBreakInside(EBreak b) { DCHECK_LE(b, BreakValueLastAllowedForBreakInside); noninherited_data.m_breakInside = b;  }
 
     void setTextSizeAdjust(TextSizeAdjust sizeAdjust) { SET_VAR(rareInheritedData, m_textSizeAdjust, sizeAdjust); }
 
     // CSS3 Setters
     void setOutlineOffset(int v) { SET_VAR(m_background, m_outline.m_offset, v); }
     void setTextShadow(PassRefPtr<ShadowList>);
     void setTextStrokeColor(const StyleColor& c) { SET_VAR_WITH_SETTER(rareInheritedData, textStrokeColor, setTextStrokeColor, c); }
     void setTextStrokeWidth(float w) { SET_VAR(rareInheritedData, textStrokeWidth, w); }
     void setTextFillColor(const StyleColor& c) { SET_VAR_WITH_SETTER(rareInheritedData, textFillColor, setTextFillColor, c); }
     void setOpacity(float f) { float v = clampTo<float>(f, 0, 1); SET_VAR(rareNonInheritedData, opacity, v); }
     void setAppearance(ControlPart a) { SET_VAR(rareNonInheritedData, m_appearance, a); }
     // For valid values of box-align see http://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#alignment
     void setBoxAlign(EBoxAlignment a) { SET_NESTED_VAR(rareNonInheritedData, m_deprecatedFlexibleBox, align, a); }
     void setBoxDecorationBreak(EBoxDecorationBreak b) { SET_VAR(m_box, m_boxDecorationBreak, b); }
-    void setBoxDirection(EBoxDirection d) { inherited_flags._box_direction = d; }
+    void setBoxDirection(EBoxDirection d) { inherited_data.m_boxDirection = d; }
     void setBoxFlex(float f) { SET_NESTED_VAR(rareNonInheritedData, m_deprecatedFlexibleBox, flex, f); }
     void setBoxFlexGroup(unsigned fg) { SET_NESTED_VAR(rareNonInheritedData, m_deprecatedFlexibleBox, flexGroup, fg); }
     void setBoxLines(EBoxLines l) { SET_NESTED_VAR(rareNonInheritedData, m_deprecatedFlexibleBox, lines, l); }
     void setBoxOrdinalGroup(unsigned og) { SET_NESTED_VAR(rareNonInheritedData, m_deprecatedFlexibleBox, ordinalGroup, og); }
     void setBoxOrient(EBoxOrient o) { SET_NESTED_VAR(rareNonInheritedData, m_deprecatedFlexibleBox, orient, o); }
     void setBoxPack(EBoxPack p) { SET_NESTED_VAR(rareNonInheritedData, m_deprecatedFlexibleBox, pack, p); }
     void setBoxShadow(PassRefPtr<ShadowList>);
     void setBoxReflect(PassRefPtr<StyleReflection> reflect) { if (rareNonInheritedData->m_boxReflect != reflect) rareNonInheritedData.access()->m_boxReflect = reflect; }
     void setBoxSizing(EBoxSizing s) { SET_VAR(m_box, m_boxSizing, s); }
     void setContain(Containment contain) { SET_VAR(rareNonInheritedData, m_contain, contain); }
@@ skipping 120 matching lines @@
     void setTabSize(TabSize size) { SET_VAR(rareInheritedData, m_tabSize, size); }
 
     void setRespectImageOrientation(RespectImageOrientationEnum v) { SET_VAR(rareInheritedData, m_respectImageOrientation, v); }
 
     // End CSS3 Setters
 
     void setWrapFlow(WrapFlow wrapFlow) { SET_VAR(rareNonInheritedData, m_wrapFlow, wrapFlow); }
     void setWrapThrough(WrapThrough wrapThrough) { SET_VAR(rareNonInheritedData, m_wrapThrough, wrapThrough); }
 
     // Apple-specific property setters
-    void setPointerEvents(EPointerEvents p) { inherited_flags._pointerEvents = p; }
+    void setPointerEvents(EPointerEvents p) { inherited_data.m_pointerEvents = p; }
 
     void setTransformStyle3D(ETransformStyle3D b) { SET_VAR(rareNonInheritedData, m_transformStyle3D, b); }
     void setBackfaceVisibility(EBackfaceVisibility b) { SET_VAR(rareNonInheritedData, m_backfaceVisibility, b); }
     void setPerspective(float p) { SET_VAR(rareNonInheritedData, m_perspective, p); }
     void setPerspectiveOriginX(const Length& v) { setPerspectiveOrigin(LengthPoint(v, perspectiveOriginY())); }
     void setPerspectiveOriginY(const Length& v) { setPerspectiveOrigin(LengthPoint(perspectiveOriginX(), v)); }
     void setPerspectiveOrigin(const LengthPoint& p) { SET_VAR(rareNonInheritedData, m_perspectiveOrigin, p); }
     void setPageSize(const FloatSize& s) { SET_VAR(rareNonInheritedData, m_pageSize, s); }
     void setPageSizeType(PageSizeType t) { SET_VAR(rareNonInheritedData, m_pageSizeType, t); }
     void resetPageSizeType() { SET_VAR(rareNonInheritedData, m_pageSizeType, PAGE_SIZE_AUTO); }
@@ skipping 118 matching lines @@
     CounterDirectiveMap& accessCounterDirectives();
     const CounterDirectives getCounterDirectives(const AtomicString& identifier) const;
     void clearIncrementDirectives();
     void clearResetDirectives();
 
     QuotesData* quotes() const { return rareInheritedData->quotes.get(); }
     void setQuotes(PassRefPtr<QuotesData>);
 
     const AtomicString& hyphenString() const;
 
-    bool inheritedNotEqual(const ComputedStyle&) const;
+    bool inheritedEqual(const ComputedStyle&) const;
+    bool nonInheritedEqual(const ComputedStyle&) const;
+    bool loadingCustomFontsEqual(const ComputedStyle&) const;
     bool inheritedDataShared(const ComputedStyle&) const;
 
     bool isDisplayReplacedType() const { return isDisplayReplacedType(display()); }
     bool isDisplayInlineType() const { return isDisplayInlineType(display()); }
     bool isOriginalDisplayInlineType() const { return isDisplayInlineType(originalDisplay()); }
     bool isDisplayFlexibleOrGridBox() const { return isDisplayFlexibleBox(display()) || isDisplayGridBox(display()); }
     bool isDisplayFlexibleBox() const { return isDisplayFlexibleBox(display()); }
 
 
     bool setWritingMode(WritingMode v)
     {
         if (v == getWritingMode())
             return false;
 
-        inherited_flags.m_writingMode = v;
+        inherited_data.m_writingMode = v;
         return true;
     }
 
     // A unique style is one that has matches something that makes it impossible to share.
-    bool unique() const { return noninherited_flags.unique; }
-    void setUnique() { noninherited_flags.unique = true; }
+    bool unique() const { return noninherited_data.m_unique; }
+    void setUnique() { noninherited_data.m_unique = true; }
 
     bool isSharable() const;
 
-    bool emptyState() const { return noninherited_flags.emptyState; }
-    void setEmptyState(bool b) { setUnique(); noninherited_flags.emptyState = b; }
+    bool emptyState() const { return noninherited_data.m_emptyState; }
+    void setEmptyState(bool b) { setUnique(); noninherited_data.m_emptyState = b; }
 
     Color visitedDependentColor(int colorProperty) const;
 
-    void setHasExplicitlyInheritedProperties() { noninherited_flags.explicitInheritance = true; }
-    bool hasExplicitlyInheritedProperties() const { return noninherited_flags.explicitInheritance; }
+    void setHasExplicitlyInheritedProperties() { noninherited_data.m_explicitInheritance = true; }
+    bool hasExplicitlyInheritedProperties() const { return noninherited_data.m_explicitInheritance; }
 
-    void setHasVariableReferenceFromNonInheritedProperty() { noninherited_flags.variableReference = true; }
-    bool hasVariableReferenceFromNonInheritedProperty() const { return noninherited_flags.variableReference; }
+    void setHasVariableReferenceFromNonInheritedProperty() { noninherited_data.m_variableReference = true; }
+    bool hasVariableReferenceFromNonInheritedProperty() const { return noninherited_data.m_variableReference; }
 
     bool hasChildDependentFlags() const { return emptyState() || hasExplicitlyInheritedProperties(); }
     void copyChildDependentFlagsFrom(const ComputedStyle&);
 
     bool hasBoxDecorations() const
     {
         return hasBorderDecoration()
             || hasBorderRadius()
             || hasOutline()
             || hasAppearance()
@@ skipping 214 matching lines @@
     void setVisitedLinkBorderRightColor(const StyleColor& v) { SET_VAR(rareNonInheritedData, m_visitedLinkBorderRightColor, v); }
     void setVisitedLinkBorderBottomColor(const StyleColor& v) { SET_VAR(rareNonInheritedData, m_visitedLinkBorderBottomColor, v); }
     void setVisitedLinkBorderTopColor(const StyleColor& v) { SET_VAR(rareNonInheritedData, m_visitedLinkBorderTopColor, v); }
     void setVisitedLinkOutlineColor(const StyleColor& v) { SET_VAR(rareNonInheritedData, m_visitedLinkOutlineColor, v); }
     void setVisitedLinkColumnRuleColor(const StyleColor& v) { SET_NESTED_VAR(rareNonInheritedData, m_multiCol, m_visitedLinkColumnRuleColor, v); }
     void setVisitedLinkTextDecorationColor(const StyleColor& v) { SET_VAR(rareNonInheritedData, m_visitedLinkTextDecorationColor, v); }
     void setVisitedLinkTextEmphasisColor(const StyleColor& v) { SET_VAR_WITH_SETTER(rareInheritedData, visitedLinkTextEmphasisColor, setVisitedLinkTextEmphasisColor, v); }
     void setVisitedLinkTextFillColor(const StyleColor& v) { SET_VAR_WITH_SETTER(rareInheritedData, visitedLinkTextFillColor, setVisitedLinkTextFillColor, v); }
     void setVisitedLinkTextStrokeColor(const StyleColor& v) { SET_VAR_WITH_SETTER(rareInheritedData, visitedLinkTextStrokeColor, setVisitedLinkTextStrokeColor, v); }
 
-    void inheritUnicodeBidiFrom(const ComputedStyle& parent) { noninherited_flags.unicodeBidi = parent.noninherited_flags.unicodeBidi; }
+    void inheritUnicodeBidiFrom(const ComputedStyle& parent) { noninherited_data.m_unicodeBidi = parent.noninherited_data.m_unicodeBidi; }
 
     bool isDisplayFlexibleBox(EDisplay display) const
     {
         return display == FLEX || display == INLINE_FLEX;
     }
 
     bool isDisplayGridBox(EDisplay display) const
     {
         return display == GRID || display == INLINE_GRID;
     }
@@ skipping 126 matching lines @@
 {
     if (compareEqual(rareInheritedData->m_textOrientation, textOrientation))
         return false;
 
     rareInheritedData.access()->m_textOrientation = textOrientation;
     return true;
 }
 
 inline bool ComputedStyle::hasAnyPublicPseudoStyles() const
 {
-    return PublicPseudoIdMask & noninherited_flags.pseudoBits;
+    return PublicPseudoIdMask & noninherited_data.m_pseudoBits;
 }
 
 inline bool ComputedStyle::hasPseudoStyle(PseudoId pseudo) const
 {
     ASSERT(pseudo > PseudoIdNone);
     ASSERT(pseudo < FirstInternalPseudoId);
-    return (1 << (pseudo - 1)) & noninherited_flags.pseudoBits;
+    return (1 << (pseudo - 1)) & noninherited_data.m_pseudoBits;
 }
 
 inline void ComputedStyle::setHasPseudoStyle(PseudoId pseudo)
 {
     ASSERT(pseudo > PseudoIdNone);
     ASSERT(pseudo < FirstInternalPseudoId);
-    noninherited_flags.pseudoBits |= 1 << (pseudo - 1);
+    noninherited_data.m_pseudoBits |= 1 << (pseudo - 1);
 }
 
 inline bool ComputedStyle::hasPseudoElementStyle() const
 {
-    return noninherited_flags.pseudoBits & ElementPseudoIdMask;
+    return noninherited_data.m_pseudoBits & ElementPseudoIdMask;
 }
 
 } // namespace blink
 
 #endif // ComputedStyle_h