Make pseudo element update work with LocalStyleChange.

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 1572 matching lines @@
                 if (ActiveAnimations* activeAnimations = data->activeAnimations())
                     activeAnimations->setAnimationStyleChange(false);
             }
         }
         if (parentRenderStyle())
             change = recalcOwnStyle(change);
         clearNeedsStyleRecalc();
     }
 
     // If we reattached we don't need to recalc the style of our descendants anymore.
-    if ((change >= Inherit && change < Reattach) || childNeedsStyleRecalc())
+    if ((change >= Inherit && change < Reattach) || childNeedsStyleRecalc()) {
         recalcChildStyle(change);
-    clearChildNeedsStyleRecalc();
+        clearChildNeedsStyleRecalc();
+    } else if (change == UpdatePseudoElements) {
+        updatePseudoElement(BEFORE, change);
+        updatePseudoElement(AFTER, change);
+        updatePseudoElement(BACKDROP, change);

[esprehn, 2014/01/24 22:53:49]

Can you just merge this into recalcChildStyle? If a pseudo element requests a
recalc then childNeedsStyleRecalc() will be true and we won't even get here. So
the updatePseudoElement() logic is code duplication.

I'd rather you added checks inside recalcChildStyle so that it only recalced the
pseudos.

[rune, 2014/01/25 00:00:38]

I've tried in patch set 6. I've changed it so that you'll not get
UpdatePseudoElements if childNeedsStyleRecalc() is true to avoid more
complicated checks inside recalcChildStyle. Still there is more indentation
which might make it less readable. See what you think.

+    }
 
     if (hasCustomStyleCallbacks())
         didRecalcStyle(change);
 
     if (change == Reattach)
         reattachWhitespaceSiblings(nextTextSibling);
 }
 
 StyleRecalcChange Element::recalcOwnStyle(StyleRecalcChange change)
 {
@@ skipping 38 matching lines @@
     // all the way down the tree. This is simpler than having to maintain a cache of objects (and such font size changes should be rare anyway).
     if (document().styleEngine()->usesRemUnits() && document().documentElement() == this && oldStyle->fontSize() != newStyle->fontSize()) {
         // Cached RenderStyles may depend on the re units.
         document().ensureStyleResolver().invalidateMatchedPropertiesCache();
         return Force;
     }
 
     if (styleChangeType() >= SubtreeStyleChange)
         return Force;
 
-    if (change <= Inherit)
-        return localChange;
+    if (change > Inherit || localChange > Inherit)
+        return max(localChange, change);
 
-    return max(localChange, change);
+    if (localChange < Inherit && (oldStyle->hasContentPseudoStyle() || newStyle->hasContentPseudoStyle()))
+        return UpdatePseudoElements;
+
+    return localChange;
 }
 
 void Element::recalcChildStyle(StyleRecalcChange change)
 {
     ASSERT(document().inStyleRecalc());
     ASSERT(change >= Inherit || childNeedsStyleRecalc());
     ASSERT(!needsStyleRecalc());
 
     StyleResolverParentPusher parentPusher(*this);
 
@@ skipping 1093 matching lines @@
     if (!hasAttributes())
         return;
     for (unsigned i = 0; i < attributeCount(); ++i) {
         if (RefPtr<Attr> attr = attrIfExists(attributeItem(i)->name()))
             attr->normalize();
     }
 }
 
 void Element::updatePseudoElement(PseudoId pseudoId, StyleRecalcChange change)
 {
+    ASSERT(!needsStyleRecalc());
     PseudoElement* element = pseudoElement(pseudoId);
-    if (element && (needsStyleRecalc() || shouldRecalcStyle(change, element))) {
+    if (element && (change == UpdatePseudoElements || shouldRecalcStyle(change, element))) {
+
         // Need to clear the cached style if the PseudoElement wants a recalc so it
         // computes a new style.
         if (element->needsStyleRecalc())
             renderer()->style()->removeCachedPseudoStyle(pseudoId);
 
         // PseudoElement styles hang off their parent element's style so if we needed
         // a style recalc we should Force one on the pseudo.
         // FIXME: We should figure out the right text sibling to pass.
-        element->recalcStyle(needsStyleRecalc() ? Force : change);
+        element->recalcStyle(change == UpdatePseudoElements ? Force : change);
 
         // Wait until our parent is not displayed or pseudoElementRendererIsNeeded
         // is false, otherwise we could continously create and destroy PseudoElements
         // when RenderObject::isChildAllowed on our parent returns false for the
         // PseudoElement's renderer for each style recalc.
         if (!renderer() || !pseudoElementRendererIsNeeded(renderer()->getCachedPseudoStyle(pseudoId)))
             elementRareData()->setPseudoElement(pseudoId, 0);
-    } else if (change >= Inherit || needsStyleRecalc())
+    } else if (change >= UpdatePseudoElements) {
         createPseudoElementIfNeeded(pseudoId);
+    }
 }
 
 bool Element::needsPseudoElement(PseudoId pseudoId, const RenderStyle& style) const
 {
     if (pseudoId == BACKDROP && !isInTopLayer())
         return false;
     if (!renderer() || !pseudoElementRendererIsNeeded(&style))
         return false;
     /* It's safe to have a backdrop since its renderer is always a child of RenderView. */
     if (pseudoId != BACKDROP && !renderer()->canHaveGeneratedChildren())
@@ skipping 841 matching lines @@
     // Before doing so, we need to resolve issues in HTMLSelectElement::recalcListItems
     // and RenderMenuList::setText. See also https://bugs.webkit.org/show_bug.cgi?id=88405
     if (hasTagName(optionTag) || hasTagName(optgroupTag))
         return false;
     if (FullscreenElementStack::isActiveFullScreenElement(this))
         return false;
     return true;
 }
 
 } // namespace WebCore