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 145 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
+        {
+            return (m_visibility == other.m_visibility)

[esprehn, 2016/07/19 03:46:26]

add a comment that these must match the .in file and only properties tagged
independent can be here?

[sashab, 2016/07/19 06:32:38]

Nice, yup done. Also added a TODO to generate this.. Haha :)

+                && (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
@@ skipping 82 matching lines @@
 
         // 64 bits
 
         unsigned m_isLink : 1;
 
         mutable unsigned m_hasRemUnits : 1;
         // If you add more style bits here, you will also need to update ComputedStyle::copyNonInheritedFromCached()
         // 66 bits
     } m_nonInheritedData;
 
+    // For each inherited property, store a 1 if the stored value was inherited
+    // from its parent, or 0 if it is explicitly set on this element.
+    // Each bit in this struct corresponds to a single inherited property;
+    // eventually, all properties will have a bit in here to store whether they
+    // were inherited from their parent or not.
+    // Since two ComputedStyles are equal if their nonInheritedData is equal
+    // regardless of the isInherited flags, this struct is stored separately
+    // to avoid too many subset comparison functions.
+    // TODO(sashab): Move isInheritedFlags closer to inheritedData so that it's
+    // clear which inherited properties have a flag stored and which don't.
+    struct IsInheritedFlags {
+        bool operator==(const IsInheritedFlags& other) const
+        {
+            return m_isPointerEventsInherited == other.m_isPointerEventsInherited
+                && m_isVisibilityInherited == other.m_isVisibilityInherited;
+        }
+
+        bool operator!=(const IsInheritedFlags& other) const { return !(*this == other); }
+
+        // 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;

[esprehn, 2016/07/19 03:46:26]

no m_ on public fields, ComputedStyle is a huge mess of bad naming, sorry it's
confusing :)

[sashab, 2016/07/19 06:32:39]

?? Oh, they are all called m_, so I just changed that... What is it meant to be
called? What style guide are you referring to? If that's the case I'll just
change them all in one go

+        unsigned m_isVisibilityInherited : 1;

[esprehn, 2016/07/19 03:46:26]

why can't we put this in NonInheritedFlags to avoid the bloat?

[sashab, 2016/07/19 06:32:38]

Yeah, that's a good point. Originally I didn't do that because I had to split
the compareEqual() function everywhere, but I've had to do that anyway so now
it's worth it. Thanks!!

P.S. This is a GREAT!!! idea. Makes the patch way smaller & takes up less space,
can't believe I didn't think of it before!! Although a little more confusing
with them all being in NonInheritedData, but this is getting generated anyway so
who cares. Awesome. :D

+    } m_isInheritedFlags;
+
 // !END SYNC!
 
 protected:
     void setBitDefaults()
     {
         m_inheritedData.m_emptyCells = initialEmptyCells();
         m_inheritedData.m_captionSide = initialCaptionSide();
         m_inheritedData.m_listStyleType = initialListStyleType();
         m_inheritedData.m_listStylePosition = initialListStylePosition();
         m_inheritedData.m_visibility = initialVisibility();
@@ skipping 29 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_isInheritedFlags.m_isPointerEventsInherited = true;
+        m_isInheritedFlags.m_isVisibilityInherited = true;
     }
 
 private:
     ALWAYS_INLINE ComputedStyle();
 
     enum InitialStyleTag {
         InitialStyle
     };
     ALWAYS_INLINE explicit ComputedStyle(InitialStyleTag);
     ALWAYS_INLINE ComputedStyle(const ComputedStyle&);
 
     static PassRefPtr<ComputedStyle> createInitialStyle();
     static inline ComputedStyle& mutableInitialStyle()
     {
         LEAK_SANITIZER_DISABLED_SCOPE;
         DEFINE_STATIC_REF(ComputedStyle, s_initialStyle, (ComputedStyle::createInitialStyle()));
         return *s_initialStyle;
     }
 
 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 parent to
+    // child that are not explicitly set in child.
+    static void propagateIndependentInheritedProperties(const ComputedStyle& parent, ComputedStyle& child);

[Timothy Loh, 2016/07/19 01:29:32]

Why static?

[sashab, 2016/07/19 03:31:35]

Done.

+
     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 1237 matching lines @@
     void clearResetDirectives();
 
     QuotesData* quotes() const { return m_rareInheritedData->quotes.get(); }
     void setQuotes(PassRefPtr<QuotesData>);
 
     const AtomicString& hyphenString() const;
 
     bool inheritedEqual(const ComputedStyle&) const;
     bool nonInheritedEqual(const ComputedStyle&) const;
     bool loadingCustomFontsEqual(const ComputedStyle&) const;
+
+    inline bool independentInheritedEqual(const ComputedStyle&) const;
+    inline bool nonIndependentInheritedEqual(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)
@@ skipping 40 matching lines @@
     bool borderObscuresBackground() const;
     void getBorderEdgeInfo(BorderEdge edges[], bool includeLogicalLeftEdge = true, bool includeLogicalRightEdge = true) const;
 
     void setHasAuthorBackground(bool authorBackground) { SET_VAR(m_rareNonInheritedData, m_hasAuthorBackground, authorBackground); }
     void setHasAuthorBorder(bool authorBorder) { SET_VAR(m_rareNonInheritedData, m_hasAuthorBorder, authorBorder); }
     bool hasAuthorBackground() const { return m_rareNonInheritedData->m_hasAuthorBackground; };
     bool hasAuthorBorder() const { return m_rareNonInheritedData->m_hasAuthorBorder; };
 
     void addPaintImage(StyleImage*);
 
+    // Inherited setters.
+    void setPointerEventsIsInherited(bool isInherited) { m_isInheritedFlags.m_isPointerEventsInherited = isInherited; }
+    void setVisibilityIsInherited(bool isInherited) { m_isInheritedFlags.m_isVisibilityInherited = isInherited; }
+
     // Initial values for all the properties
     static EBorderCollapse initialBorderCollapse() { return BorderCollapseSeparate; }
     static EBorderStyle initialBorderStyle() { return BorderStyleNone; }
     static OutlineIsAuto initialOutlineStyleIsAuto() { return OutlineIsAutoOff; }
     static NinePieceImage initialNinePieceImage() { return NinePieceImage(); }
     static LengthSize initialBorderRadius() { return LengthSize(Length(0, Fixed), Length(0, Fixed)); }
     static ECaptionSide initialCaptionSide() { return CaptionSideTop; }
     static EClear initialClear() { return ClearNone; }
     static LengthBox initialClip() { return LengthBox(); }
     static Containment initialContain() { return ContainsNone; }
@@ skipping 360 matching lines @@
 }
 
 inline bool ComputedStyle::hasPseudoElementStyle() const
 {
     return m_nonInheritedData.m_pseudoBits & ElementPseudoIdMask;
 }
 
 } // namespace blink
 
 #endif // ComputedStyle_h