Add a fast-path for independent inherited properties

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 146 matching lines @@
     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 InheritedData {
         bool operator==(const InheritedData& other) const
         {
+            return compareEqualIndependent(other)
+                && compareEqualNonIndependent(other);
+        }
+
+        bool operator!=(const InheritedData& other) const { return !(*this == other); }
+
+        inline bool compareEqualIndependent(const InheritedData& other) const
+        {
+            // These must match the properties tagged 'independent' in
+            // CSSProperties.in.
+            // TODO(sashab): Generate this function.
+            return (m_visibility == other.m_visibility)
+                && (m_pointerEvents == other.m_pointerEvents);
+        }
+
+        inline bool compareEqualNonIndependent(const InheritedData& other) const
+        {
             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)
                 && (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)
-                && (m_pointerEvents == other.m_pointerEvents)
                 && (m_insideLink == other.m_insideLink)
                 && (m_writingMode == other.m_writingMode);
         }
 
-        bool operator!=(const InheritedData& other) const { return !(*this == other); }
-
         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 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 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
     } m_inheritedData;
 
 // don't inherit
     struct NonInheritedData {
-        // Compare computed styles, differences in other flags should not cause an inequality.
+        // Compare computed styles, differences in inherited bits or other flags
+        // should not cause an inequality.
         bool operator==(const NonInheritedData& other) const
         {
             return m_effectiveDisplay == other.m_effectiveDisplay
                 && m_originalDisplay == other.m_originalDisplay
                 && m_overflowAnchor == other.m_overflowAnchor
                 && 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
                 && 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
+                // isInherited flags
         }
 
         bool operator!=(const NonInheritedData& other) const { return !(*this == other); }
 
         unsigned m_effectiveDisplay : 5; // EDisplay
         unsigned m_originalDisplay : 5; // EDisplay
         unsigned m_overflowAnchor : 2; // EOverflowAnchor
         unsigned m_overflowX : 3; // EOverflow
         unsigned m_overflowY : 3; // EOverflow
         unsigned m_verticalAlign : 4; // EVerticalAlign
@@ skipping 24 matching lines @@
         unsigned m_affectedByFocus : 1;
         unsigned m_affectedByHover : 1;
         unsigned m_affectedByActive : 1;
         unsigned m_affectedByDrag : 1;
 
         // 64 bits
 
         unsigned m_isLink : 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;
+
         // If you add more style bits here, you will also need to update ComputedStyle::copyNonInheritedFromCached()
-        // 66 bits
+        // 68 bits
     } m_nonInheritedData;
 
 // !END SYNC!
 
     void setBitDefaults()
     {
         m_inheritedData.m_emptyCells = initialEmptyCells();
         m_inheritedData.m_captionSide = initialCaptionSide();
         m_inheritedData.m_listStyleType = initialListStyleType();
         m_inheritedData.m_listStylePosition = initialListStylePosition();
@@ skipping 31 matching lines @@
         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_hasRemUnits = false;
+
+        // All independently inherited properties default to being inherited.
+        m_nonInheritedData.m_isPointerEventsInherited = true;
+        m_nonInheritedData.m_isVisibilityInherited = true;
     }
 
 private:
     // TODO(sashab): Move these to the bottom of ComputedStyle.
     ALWAYS_INLINE ComputedStyle();
 
     enum InitialStyleTag {
         InitialStyle
     };
     ALWAYS_INLINE explicit ComputedStyle(InitialStyleTag);
@@ skipping 10 matching lines @@
 public:
     static PassRefPtr<ComputedStyle> create();
     static PassRefPtr<ComputedStyle> createAnonymousStyleWithDisplay(const ComputedStyle& parentStyle, EDisplay);
     static PassRefPtr<ComputedStyle> clone(const ComputedStyle&);
     static const ComputedStyle& initialStyle() { return mutableInitialStyle(); }
     static void invalidateInitialStyle();
 
     // Computes how the style change should be propagated down the tree.
     static StyleRecalcChange stylePropagationDiff(const ComputedStyle* oldStyle, const ComputedStyle* newStyle);
 
+    // Copies the values of any independent inherited properties from the parent
+    // that are not explicitly set in this style.
+    void propagateIndependentInheritedProperties(const ComputedStyle& parentStyle);
+
     ContentPosition resolvedJustifyContentPosition(const StyleContentAlignmentData& normalValueBehavior) const;
     ContentDistributionType resolvedJustifyContentDistribution(const StyleContentAlignmentData& normalValueBehavior) const;
     ContentPosition resolvedAlignContentPosition(const StyleContentAlignmentData& normalValueBehavior) const;
     ContentDistributionType resolvedAlignContentDistribution(const StyleContentAlignmentData& normalValueBehavior) const;
     const StyleSelfAlignmentData resolvedAlignment(const ComputedStyle& parentStyle, ItemPosition resolvedAutoPositionForLayoutObject) const;
     static ItemPosition resolveAlignment(const ComputedStyle& parentStyle, const ComputedStyle& childStyle, ItemPosition resolvedAutoPositionForLayoutObject);
     static ItemPosition resolveJustification(const ComputedStyle& parentStyle, const ComputedStyle& childStyle, ItemPosition resolvedAutoPositionForLayoutObject);
 
     StyleDifference visualInvalidationDiff(const ComputedStyle&) const;
 
@@ skipping 1005 matching lines @@
 
     // overflow-wrap (aka word-wrap)
     static EOverflowWrap initialOverflowWrap() { return NormalOverflowWrap; }
     EOverflowWrap overflowWrap() const { return static_cast<EOverflowWrap>(m_rareInheritedData->overflowWrap); }
     void setOverflowWrap(EOverflowWrap b) { SET_VAR(m_rareInheritedData, overflowWrap, b); }
 
     // pointer-events
     static EPointerEvents initialPointerEvents() { return PE_AUTO; }
     EPointerEvents pointerEvents() const { return static_cast<EPointerEvents>(m_inheritedData.m_pointerEvents); }
     void setPointerEvents(EPointerEvents p) { m_inheritedData.m_pointerEvents = p; }
+    void setPointerEventsIsInherited(bool isInherited) { m_nonInheritedData.m_isPointerEventsInherited = isInherited; }
 
     // quotes
     static QuotesData* initialQuotes() { return 0; }
     QuotesData* quotes() const { return m_rareInheritedData->quotes.get(); }
     void setQuotes(PassRefPtr<QuotesData>);
 
     // snap-height
     uint8_t snapHeightPosition() const { return m_rareInheritedData->m_snapHeightPosition; }
     uint8_t snapHeightUnit() const { return m_rareInheritedData->m_snapHeightUnit; }
     void setSnapHeightPosition(uint8_t position) { SET_VAR(m_rareInheritedData, m_snapHeightPosition, position); }
@@ skipping 57 matching lines @@
 
     // text-transform (aka -epub-text-transform)
     static ETextTransform initialTextTransform() { return TTNONE; }
     ETextTransform textTransform() const { return static_cast<ETextTransform>(m_inheritedData.m_textTransform); }
     void setTextTransform(ETextTransform v) { m_inheritedData.m_textTransform = v; }
 
     // visibility
     static EVisibility initialVisibility() { return VISIBLE; }
     EVisibility visibility() const { return static_cast<EVisibility>(m_inheritedData.m_visibility); }
     void setVisibility(EVisibility v) { m_inheritedData.m_visibility = v; }
+    void setVisibilityIsInherited(bool isInherited) { m_nonInheritedData.m_isVisibilityInherited = isInherited; }
 
     // white-space inherited
     static EWhiteSpace initialWhiteSpace() { return NORMAL; }
     EWhiteSpace whiteSpace() const { return static_cast<EWhiteSpace>(m_inheritedData.m_whiteSpace); }
     void setWhiteSpace(EWhiteSpace v) { m_inheritedData.m_whiteSpace = v; }
 
     // word-break inherited (aka -epub-word-break)
     static EWordBreak initialWordBreak() { return NormalWordBreak; }
     EWordBreak wordBreak() const { return static_cast<EWordBreak>(m_rareInheritedData->wordBreak); }
     void setWordBreak(EWordBreak b) { SET_VAR(m_rareInheritedData, wordBreak, b); }
@@ skipping 222 matching lines @@
     // stroke-width
     const UnzoomedLength& strokeWidth() const { return svgStyle().strokeWidth(); }
     void setStrokeWidth(const UnzoomedLength& w) { accessSVGStyle().setStrokeWidth(w); }
 
     // Comparison operators
     bool operator==(const ComputedStyle& other) const;
     bool operator!=(const ComputedStyle& other) const { return !(*this == other); }
 
     bool inheritedEqual(const ComputedStyle&) const;
     bool nonInheritedEqual(const ComputedStyle&) const;
+    inline bool independentInheritedEqual(const ComputedStyle&) const;
+    inline bool nonIndependentInheritedEqual(const ComputedStyle&) const;
     bool loadingCustomFontsEqual(const ComputedStyle&) const;
     bool inheritedDataShared(const ComputedStyle&) const;
 
     bool hasChildDependentFlags() const { return emptyState() || hasExplicitlyInheritedProperties(); }
     void copyChildDependentFlagsFrom(const ComputedStyle&);
 
     // Counters.
     const CounterDirectiveMap* counterDirectives() const;
     CounterDirectiveMap& accessCounterDirectives();
     const CounterDirectives getCounterDirectives(const AtomicString& identifier) const;
@@ skipping 828 matching lines @@
 }
 
 inline bool ComputedStyle::hasPseudoElementStyle() const
 {
     return m_nonInheritedData.m_pseudoBits & ElementPseudoIdMask;
 }
 
 } // namespace blink
 
 #endif // ComputedStyle_h