Rename LayoutStyle to papayawhip

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 52 matching lines @@
 #include "core/css/resolver/MediaQueryResult.h"
 #include "core/css/resolver/ScopedStyleResolver.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/FirstLetterPseudoElement.h"
-#include "core/dom/NodeLayoutStyle.h"
+#include "core/dom/NodeComputedStyle.h"
 #include "core/dom/StyleEngine.h"
 #include "core/dom/Text.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLIFrameElement.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/layout/LayoutView.h"
@@ skipping 14 matching lines @@
     if (state.animationUpdate())
         element.ensureElementAnimations().cssAnimations().setPendingUpdate(state.takeAnimationUpdate());
 }
 
 } // namespace
 
 namespace blink {
 
 using namespace HTMLNames;
 
-LayoutStyle* StyleResolver::s_styleNotYetAvailable;
+ComputedStyle* StyleResolver::s_styleNotYetAvailable;
 
 static StylePropertySet* leftToRightDeclaration()
 {
     DEFINE_STATIC_REF_WILL_BE_PERSISTENT(MutableStylePropertySet, leftToRightDecl, (MutableStylePropertySet::create()));
     if (leftToRightDecl->isEmpty())
         leftToRightDecl->setProperty(CSSPropertyDirection, CSSValueLtr);
     return leftToRightDecl;
 }
 
 static StylePropertySet* rightToLeftDeclaration()
@@ skipping 349 matching lines @@
             bool isInlineStyleCacheable = !state.element()->inlineStyle()->isMutable();
             collector.addElementStyleProperties(state.element()->inlineStyle(), isInlineStyleCacheable);
         }
 
         // Now check SMIL animation override style.
         if (includeSMILProperties && state.element()->isSVGElement())
             collector.addElementStyleProperties(toSVGElement(state.element())->animatedSMILStyleProperties(), false /* isCacheable */);
     }
 }
 
-PassRefPtr<LayoutStyle> StyleResolver::styleForDocument(Document& document)
+PassRefPtr<ComputedStyle> StyleResolver::styleForDocument(Document& document)
 {
     const LocalFrame* frame = document.frame();
 
-    RefPtr<LayoutStyle> documentStyle = LayoutStyle::create();
+    RefPtr<ComputedStyle> documentStyle = ComputedStyle::create();
     documentStyle->setRTLOrdering(document.visuallyOrdered() ? VisualOrder : LogicalOrder);
     documentStyle->setZoom(frame && !document.printing() ? frame->pageZoomFactor() : 1);
     documentStyle->setLocale(document.contentLanguage());
     documentStyle->setZIndex(0);
     documentStyle->setUserModify(document.inDesignMode() ? READ_WRITE : READ_ONLY);
     // These are designed to match the user-agent stylesheet values for the document element
-    // so that the common case doesn't need to create a new LayoutStyle in
+    // so that the common case doesn't need to create a new ComputedStyle in
     // Document::inheritHtmlAndBodyElementStyles.
     documentStyle->setDisplay(BLOCK);
     documentStyle->setScrollBlocksOn(WebScrollBlocksOnStartTouch | WebScrollBlocksOnWheelEvent);
 
     document.setupFontBuilder(*documentStyle);
 
     return documentStyle.release();
 }
 
 AuthorStyleInfo StyleResolver::authorStyleInfo(StyleResolverState& state)
@@ skipping 11 matching lines @@
     backgroundLayersCopy.setRepeatX(NoRepeatFill);
     backgroundLayersCopy.setRepeatY(NoRepeatFill);
 
     bool backgroundChanged = backgroundLayersCopy != backgroundCopy
         || state.style()->backgroundColor() != cachedUAStyle->backgroundColor;
     bool borderChanged = state.style()->border() != cachedUAStyle->border;
 
     return AuthorStyleInfo(backgroundChanged, borderChanged);
 }
 
-void StyleResolver::adjustLayoutStyle(StyleResolverState& state, Element* element)
+void StyleResolver::adjustComputedStyle(StyleResolverState& state, Element* element)
 {
     StyleAdjuster adjuster(document().inQuirksMode());
-    adjuster.adjustLayoutStyle(state.mutableStyleRef(), *state.parentStyle(), element, authorStyleInfo(state));
+    adjuster.adjustComputedStyle(state.mutableStyleRef(), *state.parentStyle(), element, authorStyleInfo(state));
 }
 
 // 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<LayoutStyle> StyleResolver::styleForElement(Element* element, const LayoutStyle* defaultParent, StyleSharingBehavior sharingBehavior,
+PassRefPtr<ComputedStyle> StyleResolver::styleForElement(Element* element, const ComputedStyle* defaultParent, StyleSharingBehavior sharingBehavior,
     RuleMatchingBehavior matchingBehavior)
 {
     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->layoutObject()) {
         if (!s_styleNotYetAvailable) {
-            s_styleNotYetAvailable = LayoutStyle::create().leakRef();
+            s_styleNotYetAvailable = ComputedStyle::create().leakRef();
             s_styleNotYetAvailable->setDisplay(NONE);
             s_styleNotYetAvailable->font().update(document().styleEngine().fontSelector());
         }
 
         document().setHasNodesWithPlaceholderStyle();
         return s_styleNotYetAvailable;
     }
 
     didAccess();
 
     StyleResolverParentScope::ensureParentStackIsPushed();
 
     ElementResolveContext elementContext(*element);
 
     if (sharingBehavior == AllowStyleSharing && (defaultParent || elementContext.parentStyle())) {
         SharedStyleFinder styleFinder(elementContext, m_features, m_siblingRuleSet.get(), m_uncommonAttributeRuleSet.get(), *this);
-        if (RefPtr<LayoutStyle> sharedStyle = styleFinder.findSharedStyle())
+        if (RefPtr<ComputedStyle> sharedStyle = styleFinder.findSharedStyle())
             return sharedStyle.release();
     }
 
     StyleResolverState state(document(), elementContext, defaultParent);
 
     ElementAnimations* elementAnimations = element->elementAnimations();
-    const LayoutStyle* baseLayoutStyle = elementAnimations ? elementAnimations->baseLayoutStyle() : nullptr;
+    const ComputedStyle* baseComputedStyle = elementAnimations ? elementAnimations->baseComputedStyle() : nullptr;
 
-    if (baseLayoutStyle) {
-        state.setStyle(LayoutStyle::clone(*baseLayoutStyle));
+    if (baseComputedStyle) {
+        state.setStyle(ComputedStyle::clone(*baseComputedStyle));
         if (!state.parentStyle())
             state.setParentStyle(initialStyleForElement());
     } else {
         if (state.parentStyle()) {
-            RefPtr<LayoutStyle> style = LayoutStyle::create();
-            style->inheritFrom(*state.parentStyle(), isAtShadowBoundary(element) ? LayoutStyle::AtShadowBoundary : LayoutStyle::NotAtShadowBoundary);
+            RefPtr<ComputedStyle> style = ComputedStyle::create();
+            style->inheritFrom(*state.parentStyle(), isAtShadowBoundary(element) ? ComputedStyle::AtShadowBoundary : ComputedStyle::NotAtShadowBoundary);
             state.setStyle(style.release());
         } else {
             state.setStyle(initialStyleForElement());
-            state.setParentStyle(LayoutStyle::clone(*state.style()));
+            state.setParentStyle(ComputedStyle::clone(*state.style()));
         }
     }
 
     // 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 (LayoutStyle* styleOfShadowHost = parent->mutableLayoutStyle())
+            if (ComputedStyle* styleOfShadowHost = parent->mutableComputedStyle())
                 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 (!baseLayoutStyle) {
+    if (!baseComputedStyle) {
 
         bool needsCollection = false;
         CSSDefaultStyleSheets::instance().ensureDefaultStyleSheetsForElement(element, needsCollection);
         if (needsCollection)
             collectFeatures();
 
         ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
 
         matchAllRules(state, collector, matchingBehavior != MatchAllRulesExcludingSMIL);
 
-        if (element->layoutStyle() && element->layoutStyle()->textAutosizingMultiplier() != state.style()->textAutosizingMultiplier()) {
+        if (element->computedStyle() && element->computedStyle()->textAutosizingMultiplier() != state.style()->textAutosizingMultiplier()) {
             // Preserve the text autosizing multiplier on style recalc. Autosizer will update it during layout if needed.
             // NOTE: this must occur before applyMatchedProperties for correct computation of font-relative lengths.
-            state.style()->setTextAutosizingMultiplier(element->layoutStyle()->textAutosizingMultiplier());
+            state.style()->setTextAutosizingMultiplier(element->computedStyle()->textAutosizingMultiplier());
             state.style()->setUnique();
         }
 
         if (state.hasDirAutoAttribute())
             state.style()->setSelfOrAncestorHasDirAutoAttribute(true);
 
         applyMatchedProperties(state, collector.matchedResult());
         applyCallbackSelectors(state);
 
         // Cache our original display.
         state.style()->setOriginalDisplay(state.style()->display());
 
-        adjustLayoutStyle(state, element);
+        adjustComputedStyle(state, element);
 
         if (elementAnimations)
-            elementAnimations->updateBaseLayoutStyle(state.style());
+            elementAnimations->updateBaseComputedStyle(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))
-        adjustLayoutStyle(state, element);
+        adjustComputedStyle(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<LayoutStyle> StyleResolver::styleForKeyframe(Element& element, const LayoutStyle& elementStyle, const LayoutStyle* parentStyle, const StyleRuleKeyframe* keyframe, const AtomicString& animationName)
+PassRefPtr<ComputedStyle> StyleResolver::styleForKeyframe(Element& element, const ComputedStyle& elementStyle, const ComputedStyle* parentStyle, const StyleRuleKeyframe* keyframe, const AtomicString& animationName)
 {
     ASSERT(document().frame());
     ASSERT(document().settings());
     ASSERT(!hasPendingAuthorStyleSheets());
 
     StyleResolverState state(document(), &element, parentStyle);
 
     MatchResult result;
     result.addMatchedProperties(&keyframe->properties());
 
     ASSERT(!state.style());
 
     // Create the style
-    state.setStyle(LayoutStyle::clone(elementStyle));
+    state.setStyle(ComputedStyle::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<HighPropertyPriority>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 
     // If our font got dirtied, go ahead and update it now.
     updateFont(state);
 
     // Now do rest of the properties.
     applyMatchedProperties<LowPropertyPriority>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 
     loadPendingResources(state);
 
     didAccess();
 
     return state.takeStyle();
 }
 
 // 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, const LayoutStyle* baseStyle, CSSPropertyID property, CSSValue* value)
+PassRefPtrWillBeRawPtr<AnimatableValue> StyleResolver::createAnimatableValueSnapshot(Element& element, const ComputedStyle* baseStyle, CSSPropertyID property, CSSValue* value)
 {
     StyleResolverState state(element.document(), &element);
-    state.setStyle(baseStyle ? LayoutStyle::clone(*baseStyle) : LayoutStyle::create());
+    state.setStyle(baseStyle ? ComputedStyle::clone(*baseStyle) : ComputedStyle::create());
     return createAnimatableValueSnapshot(state, property, value);
 }
 
 PassRefPtrWillBeRawPtr<AnimatableValue> StyleResolver::createAnimatableValueSnapshot(StyleResolverState& state, CSSPropertyID property, CSSValue* value)
 {
     if (value) {
         StyleBuilder::applyProperty(property, state, value);
         state.fontBuilder().createFont(state.document().styleEngine().fontSelector(), state.mutableStyleRef());
     }
     return CSSAnimatableValueFactory::create(property, *state.style());
@@ skipping 19 matching lines @@
 
     if (pseudoId == BACKDROP && !parent.isInTopLayer())
         return nullptr;
 
     if (pseudoId == FIRST_LETTER && (parent.isSVGElement() || !FirstLetterPseudoElement::firstLetterTextRenderer(parent)))
         return nullptr;
 
     if (!parentRenderer->canHaveGeneratedChildren())
         return nullptr;
 
-    LayoutStyle* parentStyle = parentRenderer->style();
-    if (LayoutStyle* cachedStyle = parentStyle->getCachedPseudoStyle(pseudoId)) {
+    ComputedStyle* parentStyle = parentRenderer->style();
+    if (ComputedStyle* cachedStyle = parentStyle->getCachedPseudoStyle(pseudoId)) {
         if (!pseudoElementRendererIsNeeded(cachedStyle))
             return nullptr;
         return createPseudoElement(&parent, pseudoId);
     }
 
     StyleResolverState state(document(), &parent, parentStyle);
     if (!pseudoStyleForElementInternal(parent, pseudoId, parentStyle, state))
         return nullptr;
-    RefPtr<LayoutStyle> style = state.takeStyle();
+    RefPtr<ComputedStyle> style = state.takeStyle();
     ASSERT(style);
     parentStyle->addCachedPseudoStyle(style);
 
     if (!pseudoElementRendererIsNeeded(style.get()))
         return nullptr;
 
     RefPtrWillBeRawPtr<PseudoElement> pseudo = createPseudoElement(&parent, pseudoId);
 
     setAnimationUpdateIfNeeded(state, *pseudo);
     if (ElementAnimations* elementAnimations = pseudo->elementAnimations())
         elementAnimations->cssAnimations().maybeApplyPendingUpdate(pseudo.get());
     return pseudo.release();
 }
 
-bool StyleResolver::pseudoStyleForElementInternal(Element& element, const PseudoStyleRequest& pseudoStyleRequest, const LayoutStyle* parentStyle, StyleResolverState& state)
+bool StyleResolver::pseudoStyleForElementInternal(Element& element, const PseudoStyleRequest& pseudoStyleRequest, const ComputedStyle* parentStyle, StyleResolverState& state)
 {
     ASSERT(document().frame());
     ASSERT(document().settings());
     ASSERT(pseudoStyleRequest.pseudoId != FIRST_LINE_INHERITED);
     ASSERT(state.parentStyle());
 
     StyleResolverParentScope::ensureParentStackIsPushed();
 
     Element* pseudoElement = element.pseudoElement(pseudoStyleRequest.pseudoId);
 
     ElementAnimations* elementAnimations = pseudoElement ? pseudoElement->elementAnimations() : nullptr;
-    const LayoutStyle* baseLayoutStyle = elementAnimations ? elementAnimations->baseLayoutStyle() : nullptr;
+    const ComputedStyle* baseComputedStyle = elementAnimations ? elementAnimations->baseComputedStyle() : nullptr;
 
-    if (baseLayoutStyle) {
-        state.setStyle(LayoutStyle::clone(*baseLayoutStyle));
+    if (baseComputedStyle) {
+        state.setStyle(ComputedStyle::clone(*baseComputedStyle));
     } else if (pseudoStyleRequest.allowsInheritance(state.parentStyle())) {
-        RefPtr<LayoutStyle> style = LayoutStyle::create();
+        RefPtr<ComputedStyle> style = ComputedStyle::create();
         style->inheritFrom(*state.parentStyle());
         state.setStyle(style.release());
     } else {
         state.setStyle(initialStyleForElement());
-        state.setParentStyle(LayoutStyle::clone(*state.style()));
+        state.setParentStyle(ComputedStyle::clone(*state.style()));
     }
 
     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 (!baseLayoutStyle) {
+    if (!baseComputedStyle) {
         // Check UA, user and author rules.
         ElementRuleCollector collector(state.elementContext(), 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);
 
         // Cache our original display.
         state.style()->setOriginalDisplay(state.style()->display());
 
         // FIXME: Passing 0 as the Element* introduces a lot of complexity
-        // in the adjustLayoutStyle code.
-        adjustLayoutStyle(state, 0);
+        // in the adjustComputedStyle code.
+        adjustComputedStyle(state, 0);
 
         if (elementAnimations)
-            elementAnimations->updateBaseLayoutStyle(state.style());
+            elementAnimations->updateBaseComputedStyle(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))
-        adjustLayoutStyle(state, 0);
+        adjustComputedStyle(state, 0);
 
     didAccess();
 
     if (state.style()->hasViewportUnits())
         document().setHasViewportUnits();
 
     return true;
 }
 
-PassRefPtr<LayoutStyle> StyleResolver::pseudoStyleForElement(Element* element, const PseudoStyleRequest& pseudoStyleRequest, const LayoutStyle* parentStyle)
+PassRefPtr<ComputedStyle> StyleResolver::pseudoStyleForElement(Element* element, const PseudoStyleRequest& pseudoStyleRequest, const ComputedStyle* parentStyle)
 {
     ASSERT(parentStyle);
     if (!element)
         return nullptr;
 
     StyleResolverState state(document(), element, parentStyle);
     if (!pseudoStyleForElementInternal(*element, pseudoStyleRequest, parentStyle, state)) {
         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<LayoutStyle> StyleResolver::styleForPage(int pageIndex)
+PassRefPtr<ComputedStyle> StyleResolver::styleForPage(int pageIndex)
 {
     ASSERT(!hasPendingAuthorStyleSheets());
     StyleResolverState state(document(), document().documentElement()); // m_rootElementStyle will be set to the document style.
 
-    RefPtr<LayoutStyle> style = LayoutStyle::create();
-    const LayoutStyle* rootElementStyle = state.rootElementStyle() ? state.rootElementStyle() : document().layoutStyle();
+    RefPtr<ComputedStyle> style = ComputedStyle::create();
+    const ComputedStyle* rootElementStyle = state.rootElementStyle() ? state.rootElementStyle() : document().computedStyle();
     ASSERT(rootElementStyle);
     style->inheritFrom(*rootElementStyle);
     state.setStyle(style.release());
 
     PageRuleCollector collector(rootElementStyle, pageIndex);
 
     collector.matchPageRules(CSSDefaultStyleSheets::instance().defaultPrintStyle());
 
     if (ScopedStyleResolver* scopedResolver = document().scopedStyleResolver())
         scopedResolver->matchPageRules(collector);
 
     bool inheritedOnly = false;
 
     MatchResult& result = collector.matchedResult();
     applyMatchedProperties<HighPropertyPriority>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 
     // If our font got dirtied, go ahead and update it now.
     updateFont(state);
 
     applyMatchedProperties<LowPropertyPriority>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 
     loadPendingResources(state);
 
     didAccess();
 
     // Now return the style.
     return state.takeStyle();
 }
 
-PassRefPtr<LayoutStyle> StyleResolver::initialStyleForElement()
+PassRefPtr<ComputedStyle> StyleResolver::initialStyleForElement()
 {
-    RefPtr<LayoutStyle> style = LayoutStyle::create();
+    RefPtr<ComputedStyle> style = ComputedStyle::create();
     FontBuilder fontBuilder(document());
     fontBuilder.setInitial(style->effectiveZoom());
     fontBuilder.createFont(document().styleEngine().fontSelector(), *style);
     return style.release();
 }
 
-PassRefPtr<LayoutStyle> StyleResolver::styleForText(Text* textNode)
+PassRefPtr<ComputedStyle> StyleResolver::styleForText(Text* textNode)
 {
     ASSERT(textNode);
 
     Node* parentNode = NodeRenderingTraversal::parent(*textNode);
-    if (!parentNode || !parentNode->layoutStyle())
+    if (!parentNode || !parentNode->computedStyle())
         return initialStyleForElement();
-    return parentNode->mutableLayoutStyle();
+    return parentNode->mutableComputedStyle();
 }
 
 void StyleResolver::updateFont(StyleResolverState& state)
 {
     state.fontBuilder().createFont(document().styleEngine().fontSelector(), state.mutableStyleRef());
     state.setConversionFontSizes(CSSToLengthConversionData::FontSizes(state.style(), state.rootElementStyle()));
     state.setConversionZoom(state.style()->effectiveZoom());
 }
 
 PassRefPtrWillBeRawPtr<StyleRuleList> StyleResolver::styleRulesForElement(Element* element, unsigned rulesToInclude)
@@ skipping 419 matching lines @@
 
     unsigned cacheHash = matchResult.isCacheable ? computeMatchedPropertiesHash(matchResult.matchedProperties.data(), matchResult.matchedProperties.size()) : 0;
     bool applyInheritedOnly = false;
     const CachedMatchedProperties* cachedMatchedProperties = cacheHash ? m_matchedPropertiesCache.find(cacheHash, state, matchResult) : 0;
 
     if (cachedMatchedProperties && MatchedPropertiesCache::isCacheable(element, *state.style(), *state.parentStyle())) {
         INCREMENT_STYLE_STATS_COUNTER(*this, matchedPropertyCacheHit);
         // We can build up the style by copying non-inherited properties from an earlier style object built using the same exact
         // style declarations. We then only need to apply the inherited properties, if any, as their values can depend on the
         // element context. This is fast and saves memory by reusing the style data structures.
-        state.style()->copyNonInheritedFromCached(*cachedMatchedProperties->layoutStyle);
-        if (state.parentStyle()->inheritedDataShared(*cachedMatchedProperties->parentLayoutStyle) && !isAtShadowBoundary(element)
+        state.style()->copyNonInheritedFromCached(*cachedMatchedProperties->computedStyle);
+        if (state.parentStyle()->inheritedDataShared(*cachedMatchedProperties->parentComputedStyle) && !isAtShadowBoundary(element)
             && (!state.distributedToInsertionPoint() || state.style()->userModify() == READ_ONLY)) {
             INCREMENT_STYLE_STATS_COUNTER(*this, matchedPropertyCacheInheritedHit);
 
             EInsideLink linkStatus = state.style()->insideLink();
             // If the cache item parent style has identical inherited properties to the current parent style then the
             // resulting style will be identical too. We copy the inherited properties over from the cache and are done.
-            state.style()->inheritFrom(*cachedMatchedProperties->layoutStyle);
+            state.style()->inheritFrom(*cachedMatchedProperties->computedStyle);
 
             // Unfortunately the link status is treated like an inherited property. We need to explicitly restore it.
             state.style()->setInsideLink(linkStatus);
 
             updateFont(state);
 
             return;
         }
         applyInheritedOnly = true;
     }
 
     // Now we have all of the matched rules in the appropriate order. Walk the rules and apply
     // high-priority properties first, i.e., those properties that other properties depend on.
     // The order is (1) high-priority not important, (2) high-priority important, (3) normal not important
     // and (4) normal important.
     applyMatchedProperties<HighPropertyPriority>(state, matchResult, false, 0, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
     applyMatchedProperties<HighPropertyPriority>(state, matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
     applyMatchedProperties<HighPropertyPriority>(state, matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
 
     if (UNLIKELY(isSVGForeignObjectElement(element))) {
         // LayoutSVGRoot handles zooming for the whole SVG subtree, so foreignObject content should not be scaled again.
         //
         // FIXME: The following hijacks the zoom property for foreignObject so that children of foreignObject get the
         // correct font-size in case of zooming. 'zoom' has HighPropertyPriority, along with other font-related
         // properties used as input to the FontBuilder, so resetting it here may cause the FontBuilder to recompute the
         // font used as inheritable font for foreignObject content. If we want to support zoom on foreignObject we'll
         // need to find another way of handling the SVG zoom model.
-        state.setEffectiveZoom(LayoutStyle::initialZoom());
+        state.setEffectiveZoom(ComputedStyle::initialZoom());
     }
 
-    if (cachedMatchedProperties && cachedMatchedProperties->layoutStyle->effectiveZoom() != state.style()->effectiveZoom()) {
+    if (cachedMatchedProperties && cachedMatchedProperties->computedStyle->effectiveZoom() != state.style()->effectiveZoom()) {
         state.fontBuilder().didChangeEffectiveZoom();
         applyInheritedOnly = false;
     }
 
     // If our font got dirtied, go ahead and update it now.
     updateFont(state);
 
     // Many properties depend on the font. If it changes we just apply all properties.
-    if (cachedMatchedProperties && cachedMatchedProperties->layoutStyle->fontDescription() != state.style()->fontDescription())
+    if (cachedMatchedProperties && cachedMatchedProperties->computedStyle->fontDescription() != state.style()->fontDescription())
         applyInheritedOnly = false;
 
     // Now do the normal priority UA properties.
     applyMatchedProperties<LowPropertyPriority>(state, matchResult, false, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
 
-    // Cache the UA properties to pass them to LayoutTheme in adjustLayoutStyle.
+    // Cache the UA properties to pass them to LayoutTheme in adjustComputedStyle.
     state.cacheUserAgentBorderAndBackground();
 
     // Now do the author and user normal priority properties and all the !important properties.
     applyMatchedProperties<LowPropertyPriority>(state, matchResult, false, matchResult.ranges.lastUARule + 1, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
     applyMatchedProperties<LowPropertyPriority>(state, matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
     applyMatchedProperties<LowPropertyPriority>(state, matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
 
     loadPendingResources(state);
 
     if (!cachedMatchedProperties && cacheHash && MatchedPropertiesCache::isCacheable(element, *state.style(), *state.parentStyle())) {
@@ skipping 50 matching lines @@
 void StyleResolver::printStats()
 {
     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, LayoutStyle* style)
+void StyleResolver::applyPropertiesToStyle(const CSSPropertyValue* properties, size_t count, ComputedStyle* style)
 {
     StyleResolverState state(document(), document().documentElement(), style);
     state.setStyle(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) {
@@ skipping 37 matching lines @@
     visitor->trace(m_watchedSelectorsRules);
     visitor->trace(m_treeBoundaryCrossingRules);
     visitor->trace(m_styleResourceLoader);
     visitor->trace(m_styleSharingLists);
     visitor->trace(m_pendingStyleSheets);
     visitor->trace(m_document);
 #endif
 }
 
 } // namespace blink