Track reasons for |Node::SetNeedsStyleRecalc|

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 940 matching lines @@
 
     document().incDOMTreeVersion();
 
     StyleResolver* styleResolver = document().styleResolver();
     bool testShouldInvalidateStyle = inActiveDocument() && styleResolver && styleChangeType() < SubtreeStyleChange;
 
     if (isStyledElement() && name == styleAttr) {
         styleAttributeChanged(newValue, reason);
     } else if (isStyledElement() && isPresentationAttribute(name)) {
         elementData()->m_presentationAttributeStyleIsDirty = true;
-        setNeedsStyleRecalc(LocalStyleChange);
+        setNeedsStyleRecalc(StyleRecalcDueToAttribute, LocalStyleChange);
     }
 
     if (isIdAttributeName(name)) {
         AtomicString oldId = elementData()->idForStyleResolution();
         AtomicString newId = makeIdForStyleResolution(newValue, document().inQuirksMode());
         if (newId != oldId) {
             elementData()->setIdForStyleResolution(newId);
             if (testShouldInvalidateStyle)
                 styleResolver->ensureUpdatedRuleFeatureSet().scheduleStyleInvalidationForIdChange(oldId, newId, *this);
         }
     } else if (name == classAttr) {
         classAttributeChanged(newValue);
     } else if (name == HTMLNames::nameAttr) {
         setHasName(!newValue.isNull());
     }
 
     invalidateNodeListCachesInAncestors(&name, this);
 
     // If there is currently no StyleResolver, we can't be sure that this attribute change won't affect style.
     if (!styleResolver)
-        setNeedsStyleRecalc(SubtreeStyleChange);
+        setNeedsStyleRecalc(StyleRecalcDueToAttribute, SubtreeStyleChange);
 
     if (AXObjectCache* cache = document().existingAXObjectCache())
         cache->handleAttributeChanged(name, this);
 }
 
 bool Element::hasLegalLinkAttribute(const QualifiedName&) const
 {
     return false;
 }
 
@@ skipping 638 matching lines @@
     return hasRareData() ? elementRareData()->shadow() : 0;
 }
 
 ElementShadow& Element::ensureShadow()
 {
     return ensureElementRareData().ensureShadow();
 }
 
 void Element::didAffectSelector(AffectedSelectorMask mask)
 {
-    setNeedsStyleRecalc(SubtreeStyleChange);
+    setNeedsStyleRecalc(StyleRecalcDueToSelector, SubtreeStyleChange);
     if (ElementShadow* elementShadow = shadowWhereNodeCanBeDistributed(*this))
         elementShadow->didAffectSelector(mask);
 }
 
 void Element::setAnimationStyleChange(bool animationStyleChange)
 {
     if (animationStyleChange && document().inStyleRecalc())
         return;
     if (ActiveAnimations* activeAnimations = elementRareData()->activeAnimations())
         activeAnimations->setAnimationStyleChange(animationStyleChange);
 }
 
 void Element::setNeedsAnimationStyleRecalc()
 {
     if (styleChangeType() != NoStyleChange)
         return;
 
-    setNeedsStyleRecalc(LocalStyleChange);
+    setNeedsStyleRecalc(StyleRecalcDueToAnimation, LocalStyleChange);
     setAnimationStyleChange(true);
 }
 
 void Element::setNeedsCompositingUpdate()
 {
     if (!document().isActive())
         return;
     RenderBoxModelObject* renderer = renderBoxModelObject();
     if (!renderer)
         return;
@@ skipping 81 matching lines @@
 }
 
 void Element::checkForEmptyStyleChange()
 {
     RenderStyle* style = renderStyle();
 
     if (!style && !styleAffectedByEmpty())
         return;
 
     if (!style || (styleAffectedByEmpty() && (!style->emptyState() || hasChildren())))
-        setNeedsStyleRecalc(SubtreeStyleChange);
+        setNeedsStyleRecalc(StyleRecalcDueToEmptyPseudoClass, SubtreeStyleChange);
 }
 
 void Element::childrenChanged(const ChildrenChange& change)
 {
     ContainerNode::childrenChanged(change);
 
     checkForEmptyStyleChange();
     if (!change.byParser && change.isChildElementChange())
         checkForSiblingStyleChanges(change.type == ElementRemoved ? SiblingElementRemoved : SiblingElementInserted, change.siblingBeforeChange, change.siblingAfterChange);
 
@@ skipping 897 matching lines @@
 }
 
 void Element::setFloatingPointAttribute(const QualifiedName& attributeName, double value)
 {
     setAttribute(attributeName, AtomicString::number(value));
 }
 
 void Element::setContainsFullScreenElement(bool flag)
 {
     setElementFlag(ContainsFullScreenElement, flag);
-    setNeedsStyleRecalc(SubtreeStyleChange);
+    setNeedsStyleRecalc(StyleRecalcDueToFullScreen, SubtreeStyleChange);
 }
 
 static Element* parentCrossingFrameBoundaries(Element* element)
 {
     ASSERT(element);
     return element->parentElement() ? element->parentElement() : element->document().ownerElement();
 }
 
 void Element::setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(bool flag)
 {
@@ skipping 444 matching lines @@
         startLineNumber = document().scriptableDocumentParser()->lineNumber();
 
     if (newStyleString.isNull()) {
         ensureUniqueElementData().m_inlineStyle.clear();
     } else if (modificationReason == ModifiedByCloning || document().contentSecurityPolicy()->allowInlineStyle(document().url(), startLineNumber)) {
         setInlineStyleFromString(newStyleString);
     }
 
     elementData()->m_styleAttributeIsDirty = false;
 
-    setNeedsStyleRecalc(LocalStyleChange);
+    setNeedsStyleRecalc(StyleRecalcDueToStyleSheetChange, LocalStyleChange);
     InspectorInstrumentation::didInvalidateStyleAttr(this);
 }
 
 void Element::inlineStyleChanged()
 {
     ASSERT(isStyledElement());
-    setNeedsStyleRecalc(LocalStyleChange);
+    setNeedsStyleRecalc(StyleRecalcDueToInline, LocalStyleChange);
     ASSERT(elementData());
     elementData()->m_styleAttributeIsDirty = true;
     InspectorInstrumentation::didInvalidateStyleAttr(this);
 }
 
 bool Element::setInlineStyleProperty(CSSPropertyID propertyID, CSSValueID identifier, bool important)
 {
     ASSERT(isStyledElement());
     ensureMutableInlineStyle().setProperty(propertyID, cssValuePool().createIdentifierValue(identifier), important);
     inlineStyleChanged();
@@ skipping 137 matching lines @@
         return v8::Handle<v8::Object>();
 
     wrapper->SetPrototype(binding->prototype());
 
     wrapperType->refObject(toScriptWrappableBase());
     V8DOMWrapper::associateObjectWithWrapperNonTemplate(this, wrapperType, wrapper, isolate);
     return wrapper;
 }
 
 } // namespace blink