Revert of Add a fast-path for independent inherited properties

third_party/WebKit/Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc. All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 1692 matching lines @@
 void Element::recalcStyle(StyleRecalcChange change, Text* nextTextSibling)
 {
     DCHECK(document().inStyleRecalc());
     DCHECK(!document().lifecycle().inDetach());
     DCHECK(!parentOrShadowHostNode()->needsStyleRecalc());
     DCHECK(inActiveDocument());
 
     if (hasCustomStyleCallbacks())
         willRecalcStyle(change);
 
-    if (change >= IndependentInherit || needsStyleRecalc()) {
+    if (change >= Inherit || needsStyleRecalc()) {
         if (hasRareData()) {
             ElementRareData* data = elementRareData();
-            if (change != IndependentInherit)
-                data->clearComputedStyle();
+            data->clearComputedStyle();
 
-            if (change >= IndependentInherit) {
+            if (change >= Inherit) {
                 if (ElementAnimations* elementAnimations = data->elementAnimations())
                     elementAnimations->setAnimationStyleChange(false);
             }
         }
         if (parentComputedStyle())
             change = recalcOwnStyle(change);
         clearNeedsStyleRecalc();
     }
 
     // If we reattached we don't need to recalc the style of our descendants anymore.
@@ skipping 23 matching lines @@
         clearChildNeedsStyleRecalc();
     }
 
     if (hasCustomStyleCallbacks())
         didRecalcStyle(change);
 
     if (change == Reattach)
         reattachWhitespaceSiblingsIfNeeded(nextTextSibling);
 }
 
-PassRefPtr<ComputedStyle> Element::propagateInheritedProperties(StyleRecalcChange change)
-{
-    if (change != IndependentInherit)
-        return nullptr;
-    if (needsStyleRecalc())
-        return nullptr;
-    if (hasAnimations())
-        return nullptr;
-    const ComputedStyle* parentStyle = parentComputedStyle();
-    DCHECK(parentStyle);
-    const ComputedStyle* style = computedStyle();
-    if (!style || style->animations() || style->transitions())
-        return nullptr;
-    RefPtr<ComputedStyle> newStyle = ComputedStyle::clone(*style);
-    newStyle->propagateIndependentInheritedProperties(*parentStyle);
-    INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), independentInheritedStylesPropagated, 1);
-    return newStyle;
-}
-
 StyleRecalcChange Element::recalcOwnStyle(StyleRecalcChange change)
 {
     DCHECK(document().inStyleRecalc());
     DCHECK(!parentOrShadowHostNode()->needsStyleRecalc());
-    DCHECK(change >= IndependentInherit || needsStyleRecalc());
+    DCHECK(change >= Inherit || needsStyleRecalc());
     DCHECK(parentComputedStyle());
 
     RefPtr<ComputedStyle> oldStyle = mutableComputedStyle();
-
-    // When propagating inherited changes, we don't need to do a full style recalc
-    // if the only changed properties are independent. In this case, we can simply
-    // set these directly on the ComputedStyle object.
-    RefPtr<ComputedStyle> newStyle = propagateInheritedProperties(change);
-    if (!newStyle)
-        newStyle = styleForLayoutObject();
+    RefPtr<ComputedStyle> newStyle = styleForLayoutObject();
     DCHECK(newStyle);
 
     StyleRecalcChange localChange = ComputedStyle::stylePropagationDiff(oldStyle.get(), newStyle.get());
     if (localChange == NoChange) {
         INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), stylesUnchanged, 1);
     } else {
         INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), stylesChanged, 1);
     }
 
     if (localChange == Reattach) {
@@ skipping 19 matching lines @@
             layoutObject->setStyleInternal(newStyle.get());
         }
     }
 
     if (getStyleChangeType() >= SubtreeStyleChange)
         return Force;
 
     if (change > Inherit || localChange > Inherit)
         return max(localChange, change);
 
-    if (localChange < IndependentInherit) {
+    if (localChange < Inherit) {
         if (oldStyle->hasChildDependentFlags()) {
             if (childNeedsStyleRecalc())
                 return Inherit;
             newStyle->copyChildDependentFlagsFrom(*oldStyle);
         }
         if (oldStyle->hasPseudoElementStyle() || newStyle->hasPseudoElementStyle())
             return UpdatePseudoElements;
     }
 
     return localChange;
@@ skipping 1948 matching lines @@
 
 DEFINE_TRACE_WRAPPERS(Element)
 {
     if (hasRareData()) {
         visitor->traceWrappers(elementRareData());
     }
     ContainerNode::traceWrappers(visitor);
 }
 
 } // namespace blink