Improve RAII of StyleResolverState.

Source/core/css/resolver/StyleResolver.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 41 matching lines @@
 #include "core/css/CSSValueList.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/ElementRuleCollector.h"
 #include "core/css/FontFace.h"
 #include "core/css/MediaQueryEvaluator.h"
 #include "core/css/PageRuleCollector.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRuleImport.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/resolver/AnimatedStyleBuilder.h"
+#include "core/css/resolver/ElementResolveContext.h"
 #include "core/css/resolver/MatchResult.h"
 #include "core/css/resolver/MediaQueryResult.h"
 #include "core/css/resolver/SharedStyleFinder.h"
 #include "core/css/resolver/StyleAdjuster.h"
 #include "core/css/resolver/StyleResolverParentScope.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "core/css/resolver/StyleResolverStats.h"
 #include "core/css/resolver/ViewportStyleResolver.h"
 #include "core/dom/CSSSelectorWatch.h"
 #include "core/dom/NodeRenderStyle.h"
@@ skipping 48 matching lines @@
     return rightToLeftDecl;
 }
 
 static void addFontFaceRule(Document* document, CSSFontSelector* cssFontSelector, const StyleRuleFontFace* fontFaceRule)
 {
     RefPtrWillBeRawPtr<FontFace> fontFace = FontFace::create(document, fontFaceRule);
     if (fontFace)
         cssFontSelector->fontFaceCache()->add(cssFontSelector, fontFaceRule, fontFace);
 }
 
+class StyleBasisContext : public ElementResolveContext {

[rune, 2014/11/13 14:28:42]

I don't like the name StyleBasisContext. This is still a context for an element.
I think the name should reflect that.

How about calling the base class something like ElementStyleContext and this
class ElementResolveContext?

[andersr, 2014/11/13 14:57:20]

Yeah, that's pretty good.

+    STACK_ALLOCATED();
+public:
+    StyleBasisContext(Element* element, RenderStyle* parentStyle)
+        : ElementResolveContext(*element, parentStyle)
+        , m_pseudoElement(nullptr)
+        , m_activeAnimations(element->activeAnimations())
+        , m_baseRenderStyle(m_activeAnimations ? m_activeAnimations->baseRenderStyle() : nullptr)
+        , m_allowsInheritance(this->parentStyle())
+    {
+    }
+
+    StyleBasisContext(Element* element, RenderStyle* parentStyle, const PseudoStyleRequest& pseudoRequest)
+        : ElementResolveContext(*element, parentStyle)
+        , m_pseudoElement(element->pseudoElement(pseudoRequest.pseudoId))
+        , m_activeAnimations(m_pseudoElement ? m_pseudoElement->activeAnimations() : nullptr)
+        , m_baseRenderStyle(m_activeAnimations ? m_activeAnimations->baseRenderStyle() : nullptr)
+        , m_allowsInheritance(pseudoRequest.allowsInheritance(this->parentStyle()))
+    {
+    }
+
+    PseudoElement* pseudoElement() const { return m_pseudoElement; }
+    ActiveAnimations* activeAnimations() const { return m_activeAnimations; }
+    const RenderStyle* baseRenderStyle() const { return m_baseRenderStyle; }
+    bool allowsInheritance() const { return m_allowsInheritance; }
+private:
+    PseudoElement* m_pseudoElement;
+    ActiveAnimations* m_activeAnimations;
+    const RenderStyle* m_baseRenderStyle;
+    bool m_allowsInheritance;
+};
+
 StyleResolver::StyleResolver(Document& document)
     : m_document(document)
     , m_viewportStyleResolver(ViewportStyleResolver::create(&document))
     , m_needCollectFeatures(false)
     , m_printMediaType(false)
     , m_styleResourceLoader(document.fetcher())
     , m_styleSharingDepth(0)
     , m_styleResolverStatsSequence(0)
     , m_accessCount(0)
 {
@@ skipping 401 matching lines @@
 // Start loading resources referenced by this style.
 void StyleResolver::loadPendingResources(StyleResolverState& state)
 {
     m_styleResourceLoader.loadPendingResources(state.style(), state.elementStyleResources());
     document().styleEngine()->fontSelector()->fontLoader()->loadPendingFonts();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForElement(Element* element, RenderStyle* defaultParent, StyleSharingBehavior sharingBehavior,
     RuleMatchingBehavior matchingBehavior)
 {
+    ASSERT(element);
     ASSERT(document().frame());
     ASSERT(document().settings());
     ASSERT(!hasPendingAuthorStyleSheets());
     ASSERT(!m_needCollectFeatures);
 
     // Once an element has a renderer, we don't try to destroy it, since otherwise the renderer
     // will vanish if a style recalc happens during loading.
     if (sharingBehavior == AllowStyleSharing && !document().isRenderingReady() && !element->renderer()) {
         if (!s_styleNotYetAvailable) {
             s_styleNotYetAvailable = RenderStyle::create().leakRef();
             s_styleNotYetAvailable->setDisplay(NONE);
             s_styleNotYetAvailable->font().update(document().styleEngine()->fontSelector());
         }
 
         document().setHasNodesWithPlaceholderStyle();
         return s_styleNotYetAvailable;
     }
 
     didAccess();
 
     StyleResolverParentScope::ensureParentStackIsPushed();
 
     if (element == document().documentElement())
         resetDirectionAndWritingModeOnDocument(document());
-    StyleResolverState state(document(), element, defaultParent);
 
-    if (sharingBehavior == AllowStyleSharing && state.parentStyle()) {
-        SharedStyleFinder styleFinder(state.elementContext(), m_features, m_siblingRuleSet.get(), m_uncommonAttributeRuleSet.get(), *this);
+    StyleBasisContext styleContext(element, defaultParent);
+
+    if (sharingBehavior == AllowStyleSharing && styleContext.parentStyle()) {
+        SharedStyleFinder styleFinder(styleContext, m_features, m_siblingRuleSet.get(), m_uncommonAttributeRuleSet.get(), *this);
         if (RefPtr<RenderStyle> sharedStyle = styleFinder.findSharedStyle())
             return sharedStyle.release();
     }
 
-    ActiveAnimations* activeAnimations = element->activeAnimations();
-    const RenderStyle* baseRenderStyle = activeAnimations ? activeAnimations->baseRenderStyle() : nullptr;
+    StyleResolverState state(document(), styleContext, styleForContext(styleContext), parentStyleForContext(styleContext));
 
-    if (baseRenderStyle) {
-        state.setStyle(RenderStyle::clone(baseRenderStyle));
-        if (!state.parentStyle())
-            state.setParentStyle(defaultStyleForElement());
-    } else {
-        if (state.parentStyle()) {
-            state.setStyle(RenderStyle::create());
-            state.style()->inheritFrom(state.parentStyle(), isAtShadowBoundary(element) ? RenderStyle::AtShadowBoundary : RenderStyle::NotAtShadowBoundary);
-        } else {
-            state.setStyle(defaultStyleForElement());
-            state.setParentStyle(RenderStyle::clone(state.style()));
-        }
-    }
+    if (!styleContext.baseRenderStyle() && styleContext.allowsInheritance())
+        state.style()->inheritFrom(styleContext.parentStyle(), isAtShadowBoundary(element) ? RenderStyle::AtShadowBoundary : RenderStyle::NotAtShadowBoundary);
 
     // contenteditable attribute (implemented by -webkit-user-modify) should
     // be propagated from shadow host to distributed node.
     if (state.distributedToInsertionPoint()) {
         if (Element* parent = element->parentElement()) {
             if (RenderStyle* styleOfShadowHost = parent->renderStyle())
                 state.style()->setUserModify(styleOfShadowHost->userModify());
         }
     }
 
     if (element->isLink()) {
         state.style()->setIsLink(true);
         EInsideLink linkState = state.elementLinkState();
         if (linkState != NotInsideLink) {
             bool forceVisited = InspectorInstrumentation::forcePseudoState(element, CSSSelector::PseudoVisited);
             if (forceVisited)
                 linkState = InsideVisitedLink;
         }
         state.style()->setInsideLink(linkState);
     }
 
-    if (!baseRenderStyle) {
+    if (!styleContext.baseRenderStyle()) {
 
         bool needsCollection = false;
         CSSDefaultStyleSheets::instance().ensureDefaultStyleSheetsForElement(element, needsCollection);
         if (needsCollection)
             collectFeatures();
 
         ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
 
         matchAllRules(state, collector, matchingBehavior != MatchAllRulesExcludingSMIL);
 
         applyMatchedProperties(state, collector.matchedResult());
         applyCallbackSelectors(state);
 
         addContentAttrValuesToFeatures(state.contentAttrValues(), m_features);
 
         // Cache our original display.
         state.style()->setOriginalDisplay(state.style()->display());
 
         adjustRenderStyle(state, element);
 
-        if (activeAnimations)
-            activeAnimations->updateBaseRenderStyle(state.style());
+        if (styleContext.activeAnimations())
+            styleContext.activeAnimations()->updateBaseRenderStyle(state.style());
     }
 
     // FIXME: The CSSWG wants to specify that the effects of animations are applied before
     // important rules, but this currently happens here as we require adjustment to have happened
     // before deciding which properties to transition.
     if (applyAnimatedProperties(state, element))
         adjustRenderStyle(state, element);
 
     if (isHTMLBodyElement(*element))
         document().textLinkColors().setTextColor(state.style()->color());
 
     setAnimationUpdateIfNeeded(state, *element);
 
     if (state.style()->hasViewportUnits())
         document().setHasViewportUnits();
 
     // Now return the style.
     return state.takeStyle();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForKeyframe(Element& element, const RenderStyle& elementStyle, RenderStyle* parentStyle, const StyleKeyframe* keyframe, const AtomicString& animationName)
 {
     ASSERT(document().frame());
     ASSERT(document().settings());
     ASSERT(!hasPendingAuthorStyleSheets());
 
     if (&element == document().documentElement())
         resetDirectionAndWritingModeOnDocument(document());
-    StyleResolverState state(document(), &element, parentStyle);
+    StyleResolverState state(document(), &element, RenderStyle::clone(&elementStyle), parentStyle);
 
     MatchResult result;
     result.addMatchedProperties(&keyframe->properties());
 
-    ASSERT(!state.style());
-
-    // Create the style
-    state.setStyle(RenderStyle::clone(&elementStyle));
 
     // We don't need to bother with !important. Since there is only ever one
     // decl, there's nothing to override. So just add the first properties.
     // We also don't need to bother with animation properties since the only
     // relevant one is animation-timing-function and we special-case that in
     // CSSAnimations.cpp
     bool inheritedOnly = false;
     applyMatchedProperties<HighPriorityProperties>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 
     // If our font got dirtied, go ahead and update it now.
@@ skipping 11 matching lines @@
 
 // This function is used by the WebAnimations JavaScript API method animate().
 // FIXME: Remove this when animate() switches away from resolution-dependent parsing.
 PassRefPtrWillBeRawPtr<AnimatableValue> StyleResolver::createAnimatableValueSnapshot(Element& element, CSSPropertyID property, CSSValue& value)
 {
     RefPtr<RenderStyle> style;
     if (element.renderStyle())
         style = RenderStyle::clone(element.renderStyle());
     else
         style = RenderStyle::create();
-    StyleResolverState state(element.document(), &element);
-    state.setStyle(style);
+    StyleResolverState state(element.document(), &element, style);
     return createAnimatableValueSnapshot(state, property, value);
 }
 
 PassRefPtrWillBeRawPtr<AnimatableValue> StyleResolver::createAnimatableValueSnapshot(StyleResolverState& state, CSSPropertyID property, CSSValue& value)
 {
     StyleBuilder::applyProperty(property, state, &value);
     return CSSAnimatableValueFactory::create(property, *state.style());
 }
 
+PassRefPtr<RenderStyle> StyleResolver::styleForContext(const StyleBasisContext& styleContext)
+{
+    if (styleContext.baseRenderStyle())
+        return RenderStyle::clone(styleContext.baseRenderStyle());
+    if (styleContext.allowsInheritance())
+        return RenderStyle::create();
+    return initialRenderStyle();
+}
+
+PassRefPtr<RenderStyle> StyleResolver::parentStyleForContext(const StyleBasisContext& styleContext)
+{
+    if (styleContext.allowsInheritance())
+        return styleContext.parentStyle();
+    if (styleContext.baseRenderStyle())
+        return initialRenderStyle();
+    return nullptr;

[rune, 2014/11/13 14:28:42]

Would it be better to do the clone() here instead of returning a nullptr, and
then skip the cloning in the StyleResolverState constructors?

[andersr, 2014/11/13 14:57:20]

I wanted to avoid this verbosity at each call site, which would then be
necessary:

RefPtr<RenderStyle> style = styleForContext(styleContext);
RefPtr<RenderStyle> parentStyle = parentStyleForContext(styleContext,
style.get());
StyleResolverState state(document(), styleContext, style.release(),
parentStyle.release());

But I guess it's more proper.

+}
+
 PassRefPtrWillBeRawPtr<PseudoElement> StyleResolver::createPseudoElementIfNeeded(Element& parent, PseudoId pseudoId)
 {
     RenderObject* parentRenderer = parent.renderer();
     if (!parentRenderer)
         return nullptr;
 
     if (pseudoId < FIRST_INTERNAL_PSEUDOID && !parentRenderer->style()->hasPseudoStyle(pseudoId))
         return nullptr;
 
     if (pseudoId == BACKDROP && !parent.isInTopLayer())
         return nullptr;
 
     if (!parentRenderer->canHaveGeneratedChildren())
         return nullptr;
 
     RenderStyle* parentStyle = parentRenderer->style();
     if (RenderStyle* cachedStyle = parentStyle->getCachedPseudoStyle(pseudoId)) {
         if (!pseudoElementRendererIsNeeded(cachedStyle))
             return nullptr;
         return PseudoElement::create(&parent, pseudoId);
     }
 
-    StyleResolverState state(document(), &parent, parentStyle);
-    if (!pseudoStyleForElementInternal(parent, pseudoId, parentStyle, state))
+    StyleBasisContext styleContext(&parent, parentStyle, pseudoId);
+    StyleResolverState state(document(), styleContext, styleForContext(styleContext), parentStyleForContext(styleContext));
+    if (!pseudoStyleForElementInternal(pseudoId, state, styleContext))
         return nullptr;
     RefPtr<RenderStyle> style = state.takeStyle();
     ASSERT(style);
     parentStyle->addCachedPseudoStyle(style);
 
     if (!pseudoElementRendererIsNeeded(style.get()))
         return nullptr;
 
     RefPtrWillBeRawPtr<PseudoElement> pseudo = PseudoElement::create(&parent, pseudoId);
 
     setAnimationUpdateIfNeeded(state, *pseudo);
     if (ActiveAnimations* activeAnimations = pseudo->activeAnimations())
         activeAnimations->cssAnimations().maybeApplyPendingUpdate(pseudo.get());
     return pseudo.release();
 }
 
-bool StyleResolver::pseudoStyleForElementInternal(Element& element, const PseudoStyleRequest& pseudoStyleRequest, RenderStyle* parentStyle, StyleResolverState& state)
+bool StyleResolver::pseudoStyleForElementInternal(const PseudoStyleRequest& pseudoStyleRequest, StyleResolverState& state, const StyleBasisContext& styleContext)
 {
     ASSERT(document().frame());
     ASSERT(document().settings());
     ASSERT(pseudoStyleRequest.pseudoId != FIRST_LINE_INHERITED);
     ASSERT(state.parentStyle());
 
     StyleResolverParentScope::ensureParentStackIsPushed();
 
-    Element* pseudoElement = element.pseudoElement(pseudoStyleRequest.pseudoId);
-
-    ActiveAnimations* activeAnimations = pseudoElement ? pseudoElement->activeAnimations() : nullptr;
-    const RenderStyle* baseRenderStyle = activeAnimations ? activeAnimations->baseRenderStyle() : nullptr;
-
-    if (baseRenderStyle) {
-        state.setStyle(RenderStyle::clone(baseRenderStyle));
-    } else if (pseudoStyleRequest.allowsInheritance(state.parentStyle())) {
-        state.setStyle(RenderStyle::create());
-        state.style()->inheritFrom(state.parentStyle());
-    } else {
-        state.setStyle(defaultStyleForElement());
-        state.setParentStyle(RenderStyle::clone(state.style()));
-    }
+    if (!styleContext.baseRenderStyle() && styleContext.allowsInheritance())
+        state.style()->inheritFrom(styleContext.parentStyle());
 
     state.style()->setStyleType(pseudoStyleRequest.pseudoId);
 
     // Since we don't use pseudo-elements in any of our quirk/print
     // user agent rules, don't waste time walking those rules.
 
-    if (!baseRenderStyle) {
+    if (!styleContext.baseRenderStyle()) {
+
         // Check UA, user and author rules.
-        ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
+        ElementRuleCollector collector(styleContext, m_selectorFilter, state.style());
         collector.setPseudoStyleRequest(pseudoStyleRequest);
 
         matchUARules(collector);
         matchAuthorRules(state.element(), collector, false);
 
         if (collector.matchedResult().matchedProperties.isEmpty())
             return false;
 
         applyMatchedProperties(state, collector.matchedResult());
         applyCallbackSelectors(state);
 
         addContentAttrValuesToFeatures(state.contentAttrValues(), m_features);
 
         // Cache our original display.
         state.style()->setOriginalDisplay(state.style()->display());
 
         // FIXME: Passing 0 as the Element* introduces a lot of complexity
         // in the adjustRenderStyle code.
         adjustRenderStyle(state, 0);
 
-        if (activeAnimations)
-            activeAnimations->updateBaseRenderStyle(state.style());
+        if (styleContext.activeAnimations())
+            styleContext.activeAnimations()->updateBaseRenderStyle(state.style());
     }
 
     // FIXME: The CSSWG wants to specify that the effects of animations are applied before
     // important rules, but this currently happens here as we require adjustment to have happened
     // before deciding which properties to transition.
-    if (applyAnimatedProperties(state, pseudoElement))
+    if (applyAnimatedProperties(state, styleContext.pseudoElement()))
         adjustRenderStyle(state, 0);
 
     didAccess();
 
     if (state.style()->hasViewportUnits())
         document().setHasViewportUnits();
 
     return true;
 }
 
 PassRefPtr<RenderStyle> StyleResolver::pseudoStyleForElement(Element* element, const PseudoStyleRequest& pseudoStyleRequest, RenderStyle* parentStyle)
 {
     ASSERT(parentStyle);
     if (!element)
         return nullptr;
 
-    StyleResolverState state(document(), element, parentStyle);
-    if (!pseudoStyleForElementInternal(*element, pseudoStyleRequest, parentStyle, state)) {
+    StyleBasisContext styleContext(element, parentStyle, pseudoStyleRequest);
+    StyleResolverState state(document(), styleContext, styleForContext(styleContext), parentStyleForContext(styleContext));
+    if (!pseudoStyleForElementInternal(pseudoStyleRequest, state, styleContext)) {
         if (pseudoStyleRequest.type == PseudoStyleRequest::ForRenderer)
             return nullptr;
         return state.takeStyle();
     }
 
     if (PseudoElement* pseudoElement = element->pseudoElement(pseudoStyleRequest.pseudoId))
         setAnimationUpdateIfNeeded(state, *pseudoElement);
 
     // Now return the style.
     return state.takeStyle();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForPage(int pageIndex)
 {
     ASSERT(!hasPendingAuthorStyleSheets());
     resetDirectionAndWritingModeOnDocument(document());
-    StyleResolverState state(document(), document().documentElement()); // m_rootElementStyle will be set to the document style.
+    StyleResolverState state(document(), document().documentElement(), RenderStyle::create()); // m_rootElementStyle will be set to the document style.
 
-    state.setStyle(RenderStyle::create());
     const RenderStyle* rootElementStyle = state.rootElementStyle() ? state.rootElementStyle() : document().renderStyle();
     ASSERT(rootElementStyle);
     state.style()->inheritFrom(rootElementStyle);
 
     PageRuleCollector collector(rootElementStyle, pageIndex);
 
     collector.matchPageRules(CSSDefaultStyleSheets::instance().defaultPrintStyle());
 
     if (ScopedStyleResolver* scopedResolver = document().scopedStyleResolver())
         scopedResolver->matchPageRules(collector);
@@ skipping 28 matching lines @@
 
     if (document().isMobileDocument())
         viewportStyleResolver()->collectViewportRules(defaultStyleSheets.defaultXHTMLMobileProfileStyle(), ViewportStyleResolver::UserAgentOrigin);
 
     if (ScopedStyleResolver* scopedResolver = document().scopedStyleResolver())
         scopedResolver->collectViewportRulesTo(this);
 
     viewportStyleResolver()->resolve();
 }
 
-PassRefPtr<RenderStyle> StyleResolver::defaultStyleForElement()
+PassRefPtr<RenderStyle> StyleResolver::initialRenderStyle()
 {
-    StyleResolverState state(document(), 0);
-    state.setStyle(RenderStyle::create());
-    state.fontBuilder().setInitial(state.style()->effectiveZoom());
-    state.style()->font().update(document().styleEngine()->fontSelector());
-    return state.takeStyle();
+    RefPtr<RenderStyle> style = RenderStyle::create();
+    FontBuilder fontBuilder(document(), style.get());
+    fontBuilder.setInitial(style->effectiveZoom());
+    style->font().update(document().styleEngine()->fontSelector());
+    return style.release();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForText(Text* textNode)
 {
     ASSERT(textNode);
 
     Node* parentNode = NodeRenderingTraversal::parent(textNode);
     if (!parentNode || !parentNode->renderStyle())
-        return defaultStyleForElement();
+        return initialRenderStyle();
     return parentNode->renderStyle();
 }
 
 void StyleResolver::updateFont(StyleResolverState& state)
 {
     state.fontBuilder().createFont(document().styleEngine()->fontSelector(), state.parentStyle(), state.style());
 }
 
 PassRefPtrWillBeRawPtr<StyleRuleList> StyleResolver::styleRulesForElement(Element* element, unsigned rulesToInclude)
 {
     ASSERT(element);
-    StyleResolverState state(document(), element);
-    ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
+    ElementResolveContext elementContext(*element, nullptr);
+    ElementRuleCollector collector(elementContext, m_selectorFilter, nullptr);
     collector.setMode(SelectorChecker::CollectingStyleRules);
     collectPseudoRulesForElement(element, collector, NOPSEUDO, rulesToInclude);
     return collector.matchedStyleRuleList();
 }
 
 PassRefPtrWillBeRawPtr<CSSRuleList> StyleResolver::pseudoCSSRulesForElement(Element* element, PseudoId pseudoId, unsigned rulesToInclude)
 {
     ASSERT(element);
-    StyleResolverState state(document(), element);
-    ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
+    ElementResolveContext elementContext(*element, nullptr);
+    ElementRuleCollector collector(elementContext, m_selectorFilter, nullptr);
     collector.setMode(SelectorChecker::CollectingCSSRules);
     collectPseudoRulesForElement(element, collector, pseudoId, rulesToInclude);
     return collector.matchedCSSRuleList();
 }
 
 PassRefPtrWillBeRawPtr<CSSRuleList> StyleResolver::cssRulesForElement(Element* element, unsigned rulesToInclude)
 {
     return pseudoCSSRulesForElement(element, NOPSEUDO, rulesToInclude);
 }
 
@@ skipping 568 matching lines @@
     if (!m_styleResolverStats)
         return;
     fprintf(stderr, "=== Style Resolver Stats (resolve #%u) (%s) ===\n", ++m_styleResolverStatsSequence, document().url().string().utf8().data());
     fprintf(stderr, "%s\n", m_styleResolverStats->report().utf8().data());
     fprintf(stderr, "== Totals ==\n");
     fprintf(stderr, "%s\n", m_styleResolverStatsTotals->report().utf8().data());
 }
 
 void StyleResolver::applyPropertiesToStyle(const CSSPropertyValue* properties, size_t count, RenderStyle* style)
 {
-    StyleResolverState state(document(), document().documentElement(), style);
-    state.setStyle(style);
+    StyleResolverState state(document(), document().documentElement(), style, style);
 
     for (size_t i = 0; i < count; ++i) {
         if (properties[i].value) {
             // As described in BUG66291, setting font-size and line-height on a font may entail a CSSPrimitiveValue::computeLengthDouble call,
             // which assumes the fontMetrics are available for the affected font, otherwise a crash occurs (see http://trac.webkit.org/changeset/96122).
             // The updateFont() call below updates the fontMetrics and ensure the proper setting of font-size and line-height.
             switch (properties[i].property) {
             case CSSPropertyFontSize:
             case CSSPropertyLineHeight:
                 updateFont(state);
@@ skipping 34 matching lines @@
     visitor->trace(m_uncommonAttributeRuleSet);
     visitor->trace(m_watchedSelectorsRules);
     visitor->trace(m_treeBoundaryCrossingRules);
     visitor->trace(m_styleSharingLists);
     visitor->trace(m_pendingStyleSheets);
     visitor->trace(m_document);
 #endif
 }
 
 } // namespace blink