Rename LayoutStyle to papayawhip

Source/core/layout/LayoutObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 133 matching lines @@
     ASSERT(isMainThread());
     return partitionAlloc(Partitions::getRenderingPartition(), sz);
 }
 
 void LayoutObject::operator delete(void* ptr)
 {
     ASSERT(isMainThread());
     partitionFree(ptr);
 }
 
-LayoutObject* LayoutObject::createObject(Element* element, const LayoutStyle& style)
+LayoutObject* LayoutObject::createObject(Element* element, const ComputedStyle& style)
 {
     ASSERT(isAllowedToModifyRenderTreeStructure(element->document()));
 
     // Minimal support for content properties replacing an entire element.
     // Works only if we have exactly one piece of content and it's a URL.
     // Otherwise acts as if we didn't support this feature.
     const ContentData* contentData = style.contentData();
     if (contentData && !contentData->next() && contentData->isImage() && !element->isPseudoElement()) {
         LayoutImage* image = new LayoutImage(element);
         // LayoutImageResourceStyleImage requires a style being present on the image but we don't want to
         // trigger a style change now as the node is not fully attached. Moving this code to style change
         // doesn't make sense as it should be run once at renderer creation.
-        image->setStyleInternal(const_cast<LayoutStyle*>(&style));
+        image->setStyleInternal(const_cast<ComputedStyle*>(&style));
         if (const StyleImage* styleImage = toImageContentData(contentData)->image()) {
             image->setImageResource(LayoutImageResourceStyleImage::create(const_cast<StyleImage*>(styleImage)));
             image->setIsGeneratedContent();
         } else {
             image->setImageResource(LayoutImageResource::create());
         }
         image->setStyleInternal(nullptr);
         return image;
     }
 
@@ skipping 1338 matching lines @@
 bool LayoutObject::isSelectable() const
 {
     return !isInert() && !(style()->userSelect() == SELECT_NONE && style()->userModify() == READ_ONLY);
 }
 
 Color LayoutObject::selectionBackgroundColor() const
 {
     if (!isSelectable())
         return Color::transparent;
 
-    if (RefPtr<LayoutStyle> pseudoStyle = getUncachedPseudoStyleFromParentOrShadowHost())
+    if (RefPtr<ComputedStyle> pseudoStyle = getUncachedPseudoStyleFromParentOrShadowHost())
         return resolveColor(*pseudoStyle, CSSPropertyBackgroundColor).blendWithWhite();
     return frame()->selection().isFocusedAndActive() ?
         LayoutTheme::theme().activeSelectionBackgroundColor() :
         LayoutTheme::theme().inactiveSelectionBackgroundColor();
 }
 
 Color LayoutObject::selectionColor(int colorProperty) const
 {
     // If the element is unselectable, or we are only painting the selection,
     // don't override the foreground color with the selection foreground color.
     if (!isSelectable() || (frame()->view()->paintBehavior() & PaintBehaviorSelectionOnly))
         return resolveColor(colorProperty);
 
-    if (RefPtr<LayoutStyle> pseudoStyle = getUncachedPseudoStyleFromParentOrShadowHost())
+    if (RefPtr<ComputedStyle> pseudoStyle = getUncachedPseudoStyleFromParentOrShadowHost())
         return resolveColor(*pseudoStyle, colorProperty);
     if (!LayoutTheme::theme().supportsSelectionForegroundColors())
         return resolveColor(colorProperty);
     return frame()->selection().isFocusedAndActive() ?
         LayoutTheme::theme().activeSelectionForegroundColor() :
         LayoutTheme::theme().inactiveSelectionForegroundColor();
 }
 
 Color LayoutObject::selectionForegroundColor() const
 {
@@ skipping 73 matching lines @@
 
     // If we have no layer(), just treat a PaintInvalidationLayer hint as a normal paint invalidation.
     if (diff.needsPaintInvalidationLayer() && !hasLayer()) {
         diff.clearNeedsPaintInvalidation();
         diff.setNeedsPaintInvalidationObject();
     }
 
     return diff;
 }
 
-void LayoutObject::setPseudoStyle(PassRefPtr<LayoutStyle> pseudoStyle)
+void LayoutObject::setPseudoStyle(PassRefPtr<ComputedStyle> pseudoStyle)
 {
     ASSERT(pseudoStyle->styleType() == BEFORE || pseudoStyle->styleType() == AFTER || pseudoStyle->styleType() == FIRST_LETTER);
 
     // FIXME: We should consider just making all pseudo items use an inherited style.
 
     // Images are special and must inherit the pseudoStyle so the width and height of
     // the pseudo element doesn't change the size of the image. In all other cases we
     // can just share the style.
     //
     // Quotes are also LayoutInline, so we need to create an inherited style to avoid
     // getting an inline with positioning or an invalid display.
     //
     if (isImage() || isQuote()) {
-        RefPtr<LayoutStyle> style = LayoutStyle::create();
+        RefPtr<ComputedStyle> style = ComputedStyle::create();
         style->inheritFrom(*pseudoStyle);
         setStyle(style.release());
         return;
     }
 
     setStyle(pseudoStyle);
 }
 
 void LayoutObject::markContainingBlocksForOverflowRecalc()
 {
     for (LayoutBlock* container = containingBlock(); container && !container->childNeedsOverflowRecalcAfterStyleChange(); container = container->containingBlock())
         container->setChildNeedsOverflowRecalcAfterStyleChange(true);
 }
 
 void LayoutObject::setNeedsOverflowRecalcAfterStyleChange()
 {
     bool neededRecalc = needsOverflowRecalcAfterStyleChange();
     setSelfNeedsOverflowRecalcAfterStyleChange(true);
     if (!neededRecalc)
         markContainingBlocksForOverflowRecalc();
 }
 
-void LayoutObject::setStyle(PassRefPtr<LayoutStyle> style)
+void LayoutObject::setStyle(PassRefPtr<ComputedStyle> style)
 {
     ASSERT(style);
 
     if (m_style == style) {
         // We need to run through adjustStyleDifference() for iframes, plugins, and canvas so
         // style sharing is disabled for them. That should ensure that we never hit this code path.
         ASSERT(!isLayoutIFrame() && !isEmbeddedObject() && !isCanvas());
         return;
     }
 
     StyleDifference diff;
     if (m_style)
         diff = m_style->visualInvalidationDiff(*style);
 
     diff = adjustStyleDifference(diff);
 
     styleWillChange(diff, *style);
 
-    RefPtr<LayoutStyle> oldStyle = m_style.release();
+    RefPtr<ComputedStyle> oldStyle = m_style.release();
     setStyleInternal(style);
 
     updateFillImages(oldStyle ? &oldStyle->backgroundLayers() : 0, m_style->backgroundLayers());
     updateFillImages(oldStyle ? &oldStyle->maskLayers() : 0, m_style->maskLayers());
 
     updateImage(oldStyle ? oldStyle->borderImage().image() : 0, m_style->borderImage().image());
     updateImage(oldStyle ? oldStyle->maskBoxImage().image() : 0, m_style->maskBoxImage().image());
 
     updateShapeImage(oldStyle ? oldStyle->shapeOutside() : 0, m_style->shapeOutside());
 
@@ skipping 28 matching lines @@
         toLayoutBoxModelObject(this)->layer()->setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
     else if (diff.needsPaintInvalidationObject() || updatedDiff.needsPaintInvalidationObject())
         setShouldDoFullPaintInvalidation();
 }
 
 static inline bool rendererHasBackground(const LayoutObject* renderer)
 {
     return renderer && renderer->hasBackground();
 }
 
-void LayoutObject::styleWillChange(StyleDifference diff, const LayoutStyle& newStyle)
+void LayoutObject::styleWillChange(StyleDifference diff, const ComputedStyle& newStyle)
 {
     if (m_style) {
         // If our z-index changes value or our visibility changes,
         // we need to dirty our stacking context's z-order list.
         bool visibilityChanged = m_style->visibility() != newStyle.visibility()
             || m_style->zIndex() != newStyle.zIndex()
             || m_style->hasAutoZIndex() != newStyle.hasAutoZIndex();
         if (visibilityChanged) {
             document().setAnnotatedRegionsDirty(true);
             if (AXObjectCache* cache = document().existingAXObjectCache())
@@ skipping 71 matching lines @@
     TouchAction oldTouchAction = m_style ? m_style->touchAction() : TouchActionAuto;
     if (node() && !node()->isTextNode() && (oldTouchAction == TouchActionAuto) != (newStyle.touchAction() == TouchActionAuto)) {
         EventHandlerRegistry& registry = document().frameHost()->eventHandlerRegistry();
         if (newStyle.touchAction() != TouchActionAuto)
             registry.didAddEventHandler(*node(), EventHandlerRegistry::TouchEvent);
         else
             registry.didRemoveEventHandler(*node(), EventHandlerRegistry::TouchEvent);
     }
 }
 
-static bool areNonIdenticalCursorListsEqual(const LayoutStyle* a, const LayoutStyle* b)
+static bool areNonIdenticalCursorListsEqual(const ComputedStyle* a, const ComputedStyle* b)
 {
     ASSERT(a->cursors() != b->cursors());
     return a->cursors() && b->cursors() && *a->cursors() == *b->cursors();
 }
 
-static inline bool areCursorsEqual(const LayoutStyle* a, const LayoutStyle* b)
+static inline bool areCursorsEqual(const ComputedStyle* a, const ComputedStyle* b)
 {
     return a->cursor() == b->cursor() && (a->cursors() == b->cursors() || areNonIdenticalCursorListsEqual(a, b));
 }
 
-void LayoutObject::styleDidChange(StyleDifference diff, const LayoutStyle* oldStyle)
+void LayoutObject::styleDidChange(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     if (s_affectsParentBlock)
         handleDynamicFloatPositionChange();
 
     if (!m_parent)
         return;
 
     if (diff.needsFullLayout()) {
         LayoutCounter::rendererStyleChanged(*this, oldStyle, *m_style);
 
@@ skipping 30 matching lines @@
     for (LayoutObject* child = slowFirstChild(); child; child = child->nextSibling()) {
         if (!child->isAnonymous() || child->style()->styleType() != NOPSEUDO)
             continue;
 
         if (blockChildrenOnly && !child->isLayoutBlock())
             continue;
 
         if (child->isLayoutFullScreen() || child->isLayoutFullScreenPlaceholder())
             continue;
 
-        RefPtr<LayoutStyle> newStyle = LayoutStyle::createAnonymousStyleWithDisplay(styleRef(), child->style()->display());
+        RefPtr<ComputedStyle> newStyle = ComputedStyle::createAnonymousStyleWithDisplay(styleRef(), child->style()->display());
         if (!RuntimeEnabledFeatures::regionBasedColumnsEnabled()) {
             if (style()->specifiesColumns()) {
                 if (child->style()->specifiesColumns())
                     newStyle->inheritColumnPropertiesFrom(styleRef());
                 if (child->style()->columnSpan())
                     newStyle->setColumnSpan(ColumnSpanAll);
             }
         }
 
         // Preserve the position style of anonymous block continuations as they can have relative position when
@@ skipping 743 matching lines @@
 {
     setNormalChildNeedsLayout(true);
     layout();
 }
 
 enum StyleCacheState {
     Cached,
     Uncached
 };
 
-static PassRefPtr<LayoutStyle> firstLineStyleForCachedUncachedType(StyleCacheState type, const LayoutObject* renderer, LayoutStyle* style)
+static PassRefPtr<ComputedStyle> firstLineStyleForCachedUncachedType(StyleCacheState type, const LayoutObject* renderer, ComputedStyle* style)
 {
     const LayoutObject* rendererForFirstLineStyle = renderer;
     if (renderer->isBeforeOrAfterContent())
         rendererForFirstLineStyle = renderer->parent();
 
     if (rendererForFirstLineStyle->isLayoutBlockFlow() || rendererForFirstLineStyle->isLayoutButton()) {
         if (LayoutBlock* firstLineBlock = rendererForFirstLineStyle->firstLineBlock()) {
             if (type == Cached)
                 return firstLineBlock->getCachedPseudoStyle(FIRST_LINE, style);
             return firstLineBlock->getUncachedPseudoStyle(PseudoStyleRequest(FIRST_LINE), style, firstLineBlock == renderer ? style : 0);
         }
     } else if (!rendererForFirstLineStyle->isAnonymous() && rendererForFirstLineStyle->isLayoutInline()
         && !rendererForFirstLineStyle->node()->isFirstLetterPseudoElement()) {
-        const LayoutStyle* parentStyle = rendererForFirstLineStyle->parent()->firstLineStyle();
+        const ComputedStyle* parentStyle = rendererForFirstLineStyle->parent()->firstLineStyle();
         if (parentStyle != rendererForFirstLineStyle->parent()->style()) {
             if (type == Cached) {
                 // A first-line style is in effect. Cache a first-line style for ourselves.
                 rendererForFirstLineStyle->mutableStyleRef().setHasPseudoStyle(FIRST_LINE_INHERITED);
                 return rendererForFirstLineStyle->getCachedPseudoStyle(FIRST_LINE_INHERITED, parentStyle);
             }
             return rendererForFirstLineStyle->getUncachedPseudoStyle(PseudoStyleRequest(FIRST_LINE_INHERITED), parentStyle, style);
         }
     }
     return nullptr;
 }
 
-PassRefPtr<LayoutStyle> LayoutObject::uncachedFirstLineStyle(LayoutStyle* style) const
+PassRefPtr<ComputedStyle> LayoutObject::uncachedFirstLineStyle(ComputedStyle* style) const
 {
     if (!document().styleEngine().usesFirstLineRules())
         return nullptr;
 
     ASSERT(!isText());
 
     return firstLineStyleForCachedUncachedType(Uncached, this, style);
 }
 
-LayoutStyle* LayoutObject::cachedFirstLineStyle() const
+ComputedStyle* LayoutObject::cachedFirstLineStyle() const
 {
     ASSERT(document().styleEngine().usesFirstLineRules());
 
-    if (RefPtr<LayoutStyle> style = firstLineStyleForCachedUncachedType(Cached, isText() ? parent() : this, m_style.get()))
+    if (RefPtr<ComputedStyle> style = firstLineStyleForCachedUncachedType(Cached, isText() ? parent() : this, m_style.get()))
         return style.get();
 
     return m_style.get();
 }
 
-LayoutStyle* LayoutObject::getCachedPseudoStyle(PseudoId pseudo, const LayoutStyle* parentStyle) const
+ComputedStyle* LayoutObject::getCachedPseudoStyle(PseudoId pseudo, const ComputedStyle* parentStyle) const
 {
     if (pseudo < FIRST_INTERNAL_PSEUDOID && !style()->hasPseudoStyle(pseudo))
         return 0;
 
-    LayoutStyle* cachedStyle = style()->getCachedPseudoStyle(pseudo);
+    ComputedStyle* cachedStyle = style()->getCachedPseudoStyle(pseudo);
     if (cachedStyle)
         return cachedStyle;
 
-    RefPtr<LayoutStyle> result = getUncachedPseudoStyle(PseudoStyleRequest(pseudo), parentStyle);
+    RefPtr<ComputedStyle> result = getUncachedPseudoStyle(PseudoStyleRequest(pseudo), parentStyle);
     if (result)
         return mutableStyleRef().addCachedPseudoStyle(result.release());
     return 0;
 }
 
-PassRefPtr<LayoutStyle> LayoutObject::getUncachedPseudoStyle(const PseudoStyleRequest& pseudoStyleRequest, const LayoutStyle* parentStyle, const LayoutStyle* ownStyle) const
+PassRefPtr<ComputedStyle> LayoutObject::getUncachedPseudoStyle(const PseudoStyleRequest& pseudoStyleRequest, const ComputedStyle* parentStyle, const ComputedStyle* ownStyle) const
 {
     if (pseudoStyleRequest.pseudoId < FIRST_INTERNAL_PSEUDOID && !ownStyle && !style()->hasPseudoStyle(pseudoStyleRequest.pseudoId))
         return nullptr;
 
     if (!parentStyle) {
         ASSERT(!ownStyle);
         parentStyle = style();
     }
 
     if (!node())
         return nullptr;
 
     Element* element = Traversal<Element>::firstAncestorOrSelf(*node());
     if (!element)
         return nullptr;
 
     if (pseudoStyleRequest.pseudoId == FIRST_LINE_INHERITED) {
-        RefPtr<LayoutStyle> result = document().ensureStyleResolver().styleForElement(element, parentStyle, DisallowStyleSharing);
+        RefPtr<ComputedStyle> result = document().ensureStyleResolver().styleForElement(element, parentStyle, DisallowStyleSharing);
         result->setStyleType(FIRST_LINE_INHERITED);
         return result.release();
     }
 
     return document().ensureStyleResolver().pseudoStyleForElement(element, pseudoStyleRequest, parentStyle);
 }
 
-PassRefPtr<LayoutStyle> LayoutObject::getUncachedPseudoStyleFromParentOrShadowHost() const
+PassRefPtr<ComputedStyle> LayoutObject::getUncachedPseudoStyleFromParentOrShadowHost() const
 {
     if (!node())
         return nullptr;
 
     if (ShadowRoot* root = node()->containingShadowRoot()) {
         if (root->type() == ShadowRoot::ClosedShadowRoot) {
             if (Element* shadowHost = node()->shadowHost()) {
                 return shadowHost->layoutObject()->getUncachedPseudoStyle(PseudoStyleRequest(SELECTION));
             }
         }
     }
 
     return getUncachedPseudoStyle(PseudoStyleRequest(SELECTION));
 }
 
 void LayoutObject::getTextDecorations(unsigned decorations, AppliedTextDecoration& underline, AppliedTextDecoration& overline, AppliedTextDecoration& linethrough, bool quirksMode, bool firstlineStyle)
 {
     LayoutObject* curr = this;
-    const LayoutStyle* styleToUse = 0;
+    const ComputedStyle* styleToUse = 0;
     unsigned currDecs = TextDecorationNone;
     Color resultColor;
     TextDecorationStyle resultStyle;
     do {
         styleToUse = curr->style(firstlineStyle);
         currDecs = styleToUse->textDecoration();
         currDecs &= decorations;
         resultColor = styleToUse->visitedDependentColor(CSSPropertyTextDecorationColor);
         resultStyle = styleToUse->textDecorationStyle();
         // Parameter 'decorations' is cast as an int to enable the bitwise operations below.
@@ skipping 455 matching lines @@
 {
     if (object1) {
         const blink::LayoutObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
     }
 }
 
 #endif