Add a fast-path for independent inherited properties

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

 /*
  * Copyright (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
  *
  * 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
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 46 matching lines @@
 
 namespace blink {
 
 struct SameSizeAsBorderValue {
     RGBA32 m_color;
     unsigned m_width;
 };
 
 static_assert(sizeof(BorderValue) == sizeof(SameSizeAsBorderValue), "BorderValue should stay small");
 
+// Since different platforms pack ComputedStyle differently, re-create the same

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

Are you sure this gets packed differently on different platforms? In any case,
any difference is more likely due to compiler/architecture rather than platform.

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

Done.

+// structure for an accurate size comparison.
 struct SameSizeAsComputedStyle : public RefCounted<SameSizeAsComputedStyle> {
     void* dataRefs[7];
     void* ownPtrs[1];
     void* dataRefSvgStyle;
 
     struct InheritedData {
         unsigned m_bitfields[2];
     } m_inheritedData;
 
     struct NonInheritedData {
         unsigned m_bitfields[3];
     } m_nonInheritedData;
+
+    struct IsInheritedFlags {
+        unsigned m_bitfields[1];
+    } m_isInheritedFlags;

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

merge this into m_nonInheritedData and it doesn't get any bigger

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

Woo done. :)

 };
 
 static_assert(sizeof(ComputedStyle) == sizeof(SameSizeAsComputedStyle), "ComputedStyle should stay small");
 
 PassRefPtr<ComputedStyle> ComputedStyle::create()
 {
     return adoptRef(new ComputedStyle());
 }
 
 PassRefPtr<ComputedStyle> ComputedStyle::createInitialStyle()
@@ skipping 64 matching lines @@
     , m_box(o.m_box)
     , m_visual(o.m_visual)
     , m_background(o.m_background)
     , m_surround(o.m_surround)
     , m_rareNonInheritedData(o.m_rareNonInheritedData)
     , m_rareInheritedData(o.m_rareInheritedData)
     , m_styleInheritedData(o.m_styleInheritedData)
     , m_svgStyle(o.m_svgStyle)
     , m_inheritedData(o.m_inheritedData)
     , m_nonInheritedData(o.m_nonInheritedData)
+    , m_isInheritedFlags(o.m_isInheritedFlags)
 {
 }
 
 static StyleRecalcChange diffPseudoStyles(const ComputedStyle& oldStyle, const ComputedStyle& newStyle)
 {
     // If the pseudoStyles have changed, we want any StyleRecalcChange that is not NoChange
     // because setStyle will do the right thing with anything else.
     if (!oldStyle.hasAnyPublicPseudoStyles())
         return NoChange;
     for (PseudoId pseudoId = FirstPublicPseudoId; pseudoId < FirstInternalPseudoId; pseudoId = static_cast<PseudoId>(pseudoId + 1)) {
@@ skipping 17 matching lines @@
     if (!oldStyle && !newStyle)
         return NoChange;
 
     if (oldStyle->display() != newStyle->display()
         || oldStyle->hasPseudoStyle(PseudoIdFirstLetter) != newStyle->hasPseudoStyle(PseudoIdFirstLetter)
         || !oldStyle->contentDataEquivalent(newStyle)
         || oldStyle->hasTextCombine() != newStyle->hasTextCombine()
         || oldStyle->justifyItems() != newStyle->justifyItems()) // TODO (lajava): We must avoid this Reattach.
         return Reattach;
 
+    if (!oldStyle->independentInheritedEqual(*newStyle)
+        && oldStyle->nonIndependentInheritedEqual(*newStyle)

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

this is a duplicate check with the inheritedEqual thing below I think? We're
comparing a bunch of inherited stuff here twice I guess only when you mess with
visibility or pointer-events?

I think this avoids it? Maybe you can phrase it better.

{
StyleRecalcChange change = NoChange;
if (!oldStyle->independentInheritedEqual(*newStyle)) {
  change = Inherit;
  if (oldStyle->nonIndependentInheritedEqual(*newStyle) &&
!oldStyle->hasExplicitlyInheritedProperties())
     change = IndependentInherit;
  return change;
}
}

if (!oldStyle->loadingCustomFontsEqual(*newStyle))
  return Inherit;

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

Unfortunately that doesn't quite work... See new code. I needed a boolean to
store one of them so I just made a boolean for both, unfortunately you need the
nonIndependentEqual check twice either way, can't think of a way to fix this...

One alternative might be:

    if (!independentEqual) {
        if (nonIndependentEqual &&
!oldStyle->hasExplicitlyInheritedProperties())
            return IndependentInherit;
        return Inherit;
    }

    if (!oldStyle->loadingCustomFontsEqual(*newStyle) || !nonIndependentEqual)
        return Inherit;

+        && !oldStyle->hasExplicitlyInheritedProperties())
+        return IndependentInherit;
+
     if (!oldStyle->inheritedEqual(*newStyle)
         || !oldStyle->loadingCustomFontsEqual(*newStyle))
         return Inherit;
 
     if (*oldStyle == *newStyle)
         return diffPseudoStyles(*oldStyle, *newStyle);
 
     if (oldStyle->hasExplicitlyInheritedProperties())
         return Inherit;
 
     return NoInherit;
 }
 
+// TODO(sashab): Generate this function.
+void ComputedStyle::propagateIndependentInheritedProperties(const ComputedStyle& parent, ComputedStyle& child)
+{
+    if (child.m_isInheritedFlags.m_isPointerEventsInherited)

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

I do wonder how fast this will be if there's a ton of properties in here, we can
start simple though.

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

Yeah, that's why the TODO to generate :)

+        child.setPointerEvents(parent.pointerEvents());
+    if (child.m_isInheritedFlags.m_isVisibilityInherited)
+        child.setVisibility(parent.visibility());
+}
+
 ItemPosition ComputedStyle::resolveAlignment(const ComputedStyle& parentStyle, const ComputedStyle& childStyle, ItemPosition resolvedAutoPositionForLayoutObject)
 {
     // The auto keyword computes to the parent's align-items computed value, or to "stretch", if not set or "auto".
     if (childStyle.alignSelfPosition() == ItemPositionAuto)
         return (parentStyle.alignItemsPosition() == ItemPositionAuto) ? resolvedAutoPositionForLayoutObject : parentStyle.alignItemsPosition();
     return childStyle.alignSelfPosition();
 }
 
 const StyleSelfAlignmentData ComputedStyle::resolvedAlignment(const ComputedStyle& parentStyle, ItemPosition resolvedAutoPositionForLayoutObject) const
 {
@@ skipping 111 matching lines @@
     // properties here, but the affectedBy flags will be set differently based on
     // the matching order of the :-webkit-any components.
     //
     // m_nonInheritedData.m_emptyState
     // m_nonInheritedData.m_affectedByFocus
     // m_nonInheritedData.m_affectedByHover
     // m_nonInheritedData.m_affectedByActive
     // m_nonInheritedData.m_affectedByDrag
     // m_nonInheritedData.m_isLink
 
+    // Any properties that are inherited on a style are also inherited on elements
+    // that share this style.
+    m_isInheritedFlags = other.m_isInheritedFlags;
+
     if (m_svgStyle != other.m_svgStyle)
         m_svgStyle.access()->copyNonInheritedFromCached(other.m_svgStyle.get());
     DCHECK_EQ(zoom(), initialZoom());
 }
 
 bool ComputedStyle::operator==(const ComputedStyle& o) const
 {
     return inheritedEqual(o)
         && nonInheritedEqual(o);
 }
@@ skipping 59 matching lines @@
         ComputedStyle* pseudoStyle = m_cachedPseudoStyles->at(i).get();
         if (pseudoStyle->styleType() == pid) {
             m_cachedPseudoStyles->remove(i);
             return;
         }
     }
 }
 
 bool ComputedStyle::inheritedEqual(const ComputedStyle& other) const
 {
-    return m_inheritedData == other.m_inheritedData
+    return independentInheritedEqual(other)
+        && nonIndependentInheritedEqual(other);
+}
+
+bool ComputedStyle::independentInheritedEqual(const ComputedStyle& other) const
+{
+    return m_inheritedData.compareEqualIndependent(other.m_inheritedData);
+}
+
+bool ComputedStyle::nonIndependentInheritedEqual(const ComputedStyle& other) const
+{
+    return m_inheritedData.compareEqualNonIndependent(other.m_inheritedData)
         && m_styleInheritedData == other.m_styleInheritedData
         && m_svgStyle->inheritedEqual(*other.m_svgStyle)
         && m_rareInheritedData == other.m_rareInheritedData;
 }
 
 bool ComputedStyle::loadingCustomFontsEqual(const ComputedStyle& other) const
 {
     return font().loadingCustomFonts() == other.font().loadingCustomFonts();
 }
 
@@ skipping 1500 matching lines @@
         if (value < 0)
             fvalue -= 0.5f;
         else
             fvalue += 0.5f;
     }
 
     return roundForImpreciseConversion<int>(fvalue / zoomFactor);
 }
 
 } // namespace blink