Rename LayoutStyle to papayawhip

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 44 matching lines @@
 #include "core/dom/ElementDataCache.h"
 #include "core/dom/ElementRareData.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/FirstLetterPseudoElement.h"
 #include "core/dom/Fullscreen.h"
 #include "core/dom/LayoutTreeBuilder.h"
 #include "core/dom/MutationObserverInterestGroup.h"
 #include "core/dom/MutationRecord.h"
 #include "core/dom/NamedNodeMap.h"
-#include "core/dom/NodeLayoutStyle.h"
+#include "core/dom/NodeComputedStyle.h"
 #include "core/dom/PresentationAttributeStyle.h"
 #include "core/dom/PseudoElement.h"
 #include "core/dom/ScriptableDocumentParser.h"
 #include "core/dom/SelectorQuery.h"
 #include "core/dom/StyleChangeReason.h"
 #include "core/dom/StyleEngine.h"
 #include "core/dom/Text.h"
 #include "core/dom/custom/CustomElement.h"
 #include "core/dom/custom/CustomElementRegistrationContext.h"
 #include "core/dom/shadow/InsertionPoint.h"
@@ skipping 475 matching lines @@
     // other, this bookkeeping remains accurate.
     scrollState.setCurrentNativeScrollingElement(this);
     if (scrollState.fromUserInput())
         document().frame()->view()->setWasScrolledByUser(true);
 };
 
 static float localZoomForRenderer(LayoutObject& renderer)
 {
     // FIXME: This does the wrong thing if two opposing zooms are in effect and canceled each
     // other out, but the alternative is that we'd have to crawl up the whole render tree every
-    // time (or store an additional bit in the LayoutStyle to indicate that a zoom was specified).
+    // time (or store an additional bit in the ComputedStyle to indicate that a zoom was specified).
     float zoomFactor = 1;
     if (renderer.style()->effectiveZoom() != 1) {
         // Need to find the nearest enclosing LayoutObject that set up
         // a differing zoom, and then we divide our result by it to eliminate the zoom.
         LayoutObject* prev = &renderer;
         for (LayoutObject* curr = prev->parent(); curr; curr = curr->parent()) {
             if (curr->style()->effectiveZoom() != prev->style()->effectiveZoom()) {
                 zoomFactor = prev->style()->zoom();
                 break;
             }
@@ skipping 812 matching lines @@
         return base;
 
     return KURL(parentBase, baseAttribute);
 }
 
 const AtomicString Element::imageSourceURL() const
 {
     return getAttribute(srcAttr);
 }
 
-bool Element::layoutObjectIsNeeded(const LayoutStyle& style)
+bool Element::layoutObjectIsNeeded(const ComputedStyle& style)
 {
     return style.display() != NONE;
 }
 
-LayoutObject* Element::createLayoutObject(const LayoutStyle& style)
+LayoutObject* Element::createLayoutObject(const ComputedStyle& style)
 {
     return LayoutObject::createObject(this, style);
 }
 
 Node::InsertionNotificationRequest Element::insertedInto(ContainerNode* insertionPoint)
 {
     // need to do superclass processing first so inDocument() is true
     // by the time we reach updateId
     ContainerNode::insertedInto(insertionPoint);
 
@@ skipping 137 matching lines @@
                 // FIXME: We call detach from within style recalc, so compositingState is not up to date.
                 // https://code.google.com/p/chromium/issues/detail?id=339847
                 DisableCompositingQueryAsserts disabler;
 
                 // FIXME: restart compositor animations rather than pull back to the main thread
                 elementAnimations->restartAnimationOnCompositor();
             } else {
                 elementAnimations->cssAnimations().cancel();
                 elementAnimations->setAnimationStyleChange(false);
             }
-            elementAnimations->clearBaseLayoutStyle();
+            elementAnimations->clearBaseComputedStyle();
         }
 
         if (ElementShadow* shadow = data->shadow())
             shadow->detach(context);
     }
 
     ContainerNode::detach(context);
 
     ASSERT(needsAttach());
     if (svgFilterNeedsLayerUpdate())
         document().unscheduleSVGFilterLayerUpdateHack(*this);
 }
 
-bool Element::pseudoStyleCacheIsInvalid(const LayoutStyle* currentStyle, LayoutStyle* newStyle)
+bool Element::pseudoStyleCacheIsInvalid(const ComputedStyle* currentStyle, ComputedStyle* newStyle)
 {
-    ASSERT(currentStyle == layoutStyle());
+    ASSERT(currentStyle == computedStyle());
     ASSERT(layoutObject());
 
     if (!currentStyle)
         return false;
 
     const PseudoStyleCache* pseudoStyleCache = currentStyle->cachedPseudoStyles();
     if (!pseudoStyleCache)
         return false;
 
     size_t cacheSize = pseudoStyleCache->size();
     for (size_t i = 0; i < cacheSize; ++i) {
-        RefPtr<LayoutStyle> newPseudoStyle;
+        RefPtr<ComputedStyle> newPseudoStyle;
         PseudoId pseudoId = pseudoStyleCache->at(i)->styleType();
         if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED)
             newPseudoStyle = layoutObject()->uncachedFirstLineStyle(newStyle);
         else
             newPseudoStyle = layoutObject()->getUncachedPseudoStyle(PseudoStyleRequest(pseudoId), newStyle, newStyle);
         if (!newPseudoStyle)
             return true;
         if (*newPseudoStyle != *pseudoStyleCache->at(i)) {
             if (pseudoId < FIRST_INTERNAL_PSEUDOID)
                 newStyle->setHasPseudoStyle(pseudoId);
             newStyle->addCachedPseudoStyle(newPseudoStyle);
             if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED) {
                 // FIXME: We should do an actual diff to determine whether a repaint vs. layout
                 // is needed, but for now just assume a layout will be required. The diff code
                 // in LayoutObject::setStyle would need to be factored out so that it could be reused.
                 layoutObject()->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
             }
             return true;
         }
     }
     return false;
 }
 
-PassRefPtr<LayoutStyle> Element::styleForLayoutObject()
+PassRefPtr<ComputedStyle> Element::styleForLayoutObject()
 {
     ASSERT(document().inStyleRecalc());
 
-    RefPtr<LayoutStyle> style;
+    RefPtr<ComputedStyle> style;
 
     // FIXME: Instead of clearing updates that may have been added from calls to styleForElement
     // outside recalcStyle, we should just never set them if we're not inside recalcStyle.
     if (ElementAnimations* elementAnimations = this->elementAnimations())
         elementAnimations->cssAnimations().setPendingUpdate(nullptr);
 
     if (hasCustomStyleCallbacks())
         style = customStyleForLayoutObject();
     if (!style)
         style = originalStyleForLayoutObject();
     ASSERT(style);
 
     // styleForElement() might add active animations so we need to get it again.
     if (ElementAnimations* elementAnimations = this->elementAnimations()) {
         elementAnimations->cssAnimations().maybeApplyPendingUpdate(this);
         elementAnimations->updateAnimationFlags(*style);
     }
 
     if (style->hasTransform()) {
         if (const StylePropertySet* inlineStyle = this->inlineStyle())
             style->setHasInlineTransform(inlineStyle->hasProperty(CSSPropertyTransform) || inlineStyle->hasProperty(CSSPropertyWebkitTransform));
     }
 
     document().didRecalculateStyleForElement();
     return style.release();
 }
 
-PassRefPtr<LayoutStyle> Element::originalStyleForLayoutObject()
+PassRefPtr<ComputedStyle> Element::originalStyleForLayoutObject()
 {
     ASSERT(document().inStyleRecalc());
     return document().ensureStyleResolver().styleForElement(this);
 }
 
 void Element::recalcStyle(StyleRecalcChange change, Text* nextTextSibling)
 {
     ASSERT(document().inStyleRecalc());
     ASSERT(!parentOrShadowHostNode()->needsStyleRecalc());
     ASSERT(inActiveDocument());
 
     if (hasCustomStyleCallbacks())
         willRecalcStyle(change);
 
     if (change >= Inherit || needsStyleRecalc()) {
         if (hasRareData()) {
             ElementRareData* data = elementRareData();
             data->clearComputedStyle();
 
             if (change >= Inherit) {
                 if (ElementAnimations* elementAnimations = data->elementAnimations())
                     elementAnimations->setAnimationStyleChange(false);
             }
         }
-        if (parentLayoutStyle())
+        if (parentComputedStyle())
             change = recalcOwnStyle(change);
         clearNeedsStyleRecalc();
     }
 
     // If we reattached we don't need to recalc the style of our descendants anymore.
     if ((change >= UpdatePseudoElements && change < Reattach) || childNeedsStyleRecalc()) {
         StyleResolverParentScope parentScope(*this);
 
         updatePseudoElement(BEFORE, change);
 
@@ skipping 22 matching lines @@
 
     if (change == Reattach)
         reattachWhitespaceSiblingsIfNeeded(nextTextSibling);
 }
 
 StyleRecalcChange Element::recalcOwnStyle(StyleRecalcChange change)
 {
     ASSERT(document().inStyleRecalc());
     ASSERT(!parentOrShadowHostNode()->needsStyleRecalc());
     ASSERT(change >= Inherit || needsStyleRecalc());
-    ASSERT(parentLayoutStyle());
+    ASSERT(parentComputedStyle());
 
-    RefPtr<LayoutStyle> oldStyle = mutableLayoutStyle();
-    RefPtr<LayoutStyle> newStyle = styleForLayoutObject();
-    StyleRecalcChange localChange = LayoutStyle::stylePropagationDiff(oldStyle.get(), newStyle.get());
+    RefPtr<ComputedStyle> oldStyle = mutableComputedStyle();
+    RefPtr<ComputedStyle> newStyle = styleForLayoutObject();
+    StyleRecalcChange localChange = ComputedStyle::stylePropagationDiff(oldStyle.get(), newStyle.get());
 
     ASSERT(newStyle);
 
     if (localChange == Reattach) {
         AttachContext reattachContext;
         reattachContext.resolvedStyle = newStyle.get();
         bool rendererWillChange = needsAttach() || layoutObject();
         reattach(reattachContext);
         if (rendererWillChange || layoutObject())
             return Reattach;
@@ skipping 22 matching lines @@
 
     if (change > Inherit || localChange > Inherit)
         return max(localChange, change);
 
     if (localChange < Inherit && (oldStyle->hasPseudoElementStyle() || newStyle->hasPseudoElementStyle()))
         return UpdatePseudoElements;
 
     return localChange;
 }
 
-void Element::updateCallbackSelectors(const LayoutStyle* oldStyle, const LayoutStyle* newStyle)
+void Element::updateCallbackSelectors(const ComputedStyle* oldStyle, const ComputedStyle* newStyle)
 {
     Vector<String> emptyVector;
     const Vector<String>& oldCallbackSelectors = oldStyle ? oldStyle->callbackSelectors() : emptyVector;
     const Vector<String>& newCallbackSelectors = newStyle ? newStyle->callbackSelectors() : emptyVector;
     if (oldCallbackSelectors.isEmpty() && newCallbackSelectors.isEmpty())
         return;
     if (oldCallbackSelectors != newCallbackSelectors)
         CSSSelectorWatch::from(document()).updateSelectorMatches(oldCallbackSelectors, newCallbackSelectors);
 }
 
 void Element::addCallbackSelectors()
 {
-    updateCallbackSelectors(0, layoutStyle());
+    updateCallbackSelectors(0, computedStyle());
 }
 
 void Element::removeCallbackSelectors()
 {
-    updateCallbackSelectors(layoutStyle(), 0);
+    updateCallbackSelectors(computedStyle(), 0);
 }
 
 ElementShadow* Element::shadow() const
 {
     return hasRareData() ? elementRareData()->shadow() : nullptr;
 }
 
 ElementShadow& Element::ensureShadow()
 {
     return ensureElementRareData().ensureShadow();
@@ skipping 128 matching lines @@
     case CDATA_SECTION_NODE:
         return true;
     default:
         break;
     }
     return false;
 }
 
 void Element::checkForEmptyStyleChange()
 {
-    const LayoutStyle* style = layoutStyle();
+    const ComputedStyle* style = computedStyle();
 
     if (!style && !styleAffectedByEmpty())
         return;
     if (styleChangeType() >= SubtreeStyleChange)
         return;
     if (!inActiveDocument())
         return;
     if (!document().styleResolver())
         return;
 
@@ skipping 657 matching lines @@
     return hasRareData() ? elementRareData()->minimumSizeForResizing() : defaultMinimumSizeForResizing();
 }
 
 void Element::setMinimumSizeForResizing(const LayoutSize& size)
 {
     if (!hasRareData() && size == defaultMinimumSizeForResizing())
         return;
     ensureElementRareData().setMinimumSizeForResizing(size);
 }
 
-const LayoutStyle* Element::computedStyle(PseudoId pseudoElementSpecifier)
+const ComputedStyle* Element::ensureComputedStyle(PseudoId pseudoElementSpecifier)
 {
     if (PseudoElement* element = pseudoElement(pseudoElementSpecifier))
-        return element->computedStyle();
+        return element->ensureComputedStyle();
 
     if (!inActiveDocument()) {
         // FIXME: Try to do better than this. Ensure that styleForElement() works for elements that are not in the
         // document tree and figure out when to destroy the computed style for such elements.
         return nullptr;
     }
 
     // FIXME: Find and use the renderer from the pseudo element instead of the actual element so that the 'length'
     // properties, which are only known by the renderer because it did the layout, will be correct and so that the
     // values returned for the ":selection" pseudo-element will be correct.
-    LayoutStyle* elementStyle = mutableLayoutStyle();
+    ComputedStyle* elementStyle = mutableComputedStyle();
     if (!elementStyle) {
         ElementRareData& rareData = ensureElementRareData();
-        if (!rareData.computedStyle())
+        if (!rareData.ensureComputedStyle())
             rareData.setComputedStyle(document().styleForElementIgnoringPendingStylesheets(this));
-        elementStyle = rareData.computedStyle();
+        elementStyle = rareData.ensureComputedStyle();
     }
 
     if (!pseudoElementSpecifier)
         return elementStyle;
 
-    if (LayoutStyle* pseudoElementStyle = elementStyle->getCachedPseudoStyle(pseudoElementSpecifier))
+    if (ComputedStyle* pseudoElementStyle = elementStyle->getCachedPseudoStyle(pseudoElementSpecifier))
         return pseudoElementStyle;
 
-    RefPtr<LayoutStyle> result = document().ensureStyleResolver().pseudoStyleForElement(this, PseudoStyleRequest(pseudoElementSpecifier, PseudoStyleRequest::ForComputedStyle), elementStyle);
+    RefPtr<ComputedStyle> result = document().ensureStyleResolver().pseudoStyleForElement(this, PseudoStyleRequest(pseudoElementSpecifier, PseudoStyleRequest::ForComputedStyle), elementStyle);
     ASSERT(result);
     return elementStyle->addCachedPseudoStyle(result.release());
 }
 
 AtomicString Element::computeInheritedLanguage() const
 {
     const Node* n = this;
     AtomicString value;
     // The language property is inherited, so we iterate over the parents to find the first language.
     do {
@@ skipping 535 matching lines @@
 {
     ASSERT(hasCustomStyleCallbacks());
 }
 
 void Element::didRecalcStyle(StyleRecalcChange)
 {
     ASSERT(hasCustomStyleCallbacks());
 }
 
 
-PassRefPtr<LayoutStyle> Element::customStyleForLayoutObject()
+PassRefPtr<ComputedStyle> Element::customStyleForLayoutObject()
 {
     ASSERT(hasCustomStyleCallbacks());
     return nullptr;
 }
 
 void Element::cloneAttributesFromElement(const Element& other)
 {
     if (hasSyntheticAttrChildNodes())
         detachAllAttrNodesFromElement();
 
@@ skipping 263 matching lines @@
 {
 #if ENABLE(OILPAN)
     if (hasRareData())
         visitor->trace(elementRareData());
     visitor->trace(m_elementData);
 #endif
     ContainerNode::trace(visitor);
 }
 
 } // namespace blink