Rename LayoutStyle to papayawhip

Source/core/layout/LayoutBoxModelObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 110 matching lines @@
                     frameView->removeViewportConstrainedObject(this);
             }
         }
     }
 
     LayoutObject::willBeDestroyed();
 
     destroyLayer();
 }
 
-void LayoutBoxModelObject::styleWillChange(StyleDifference diff, const LayoutStyle& newStyle)
+void LayoutBoxModelObject::styleWillChange(StyleDifference diff, const ComputedStyle& newStyle)
 {
     // This object's layer may cease to be a stacking context, in which case the paint
     // invalidation container of the children may change. Thus we need to invalidate paint
     // eagerly for all such children.
     if (hasLayer()
         && enclosingLayer()->stackingNode()
         && enclosingLayer()->stackingNode()->isStackingContext()
         && newStyle.hasAutoZIndex()) {
         // The following disablers are valid because we need to invalidate based on the current
         // status.
         DisableCompositingQueryAsserts compositingDisabler;
         DisablePaintInvalidationStateAsserts paintDisabler;
         invalidatePaintIncludingNonCompositingDescendants();
     }
 
     s_wasFloating = isFloating();
 
-    if (const LayoutStyle* oldStyle = style()) {
+    if (const ComputedStyle* oldStyle = style()) {
         if (parent() && diff.needsPaintInvalidationLayer()) {
             if (oldStyle->hasAutoClip() != newStyle.hasAutoClip()
                 || oldStyle->clip() != newStyle.clip())
                 layer()->clipper().clearClipRectsIncludingDescendants();
         }
     }
 
     LayoutObject::styleWillChange(diff, newStyle);
 }
 
-void LayoutBoxModelObject::styleDidChange(StyleDifference diff, const LayoutStyle* oldStyle)
+void LayoutBoxModelObject::styleDidChange(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     bool hadTransform = hasTransformRelatedProperty();
     bool hadLayer = hasLayer();
     bool layerWasSelfPainting = hadLayer && layer()->isSelfPaintingLayer();
 
     LayoutObject::styleDidChange(diff, oldStyle);
     updateFromStyle();
 
     DeprecatedPaintLayerType type = layerTypeRequired();
     if (type != NoDeprecatedPaintLayer) {
@@ skipping 160 matching lines @@
                 rect.moveBy(additionalOffset);
                 rects.append(rect);
             }
         }
     }
 }
 
 
 bool LayoutBoxModelObject::calculateHasBoxDecorations() const
 {
-    const LayoutStyle& styleToUse = styleRef();
+    const ComputedStyle& styleToUse = styleRef();
     return hasBackground() || styleToUse.hasBorder() || styleToUse.hasAppearance() || styleToUse.boxShadow();
 }
 
 void LayoutBoxModelObject::updateFromStyle()
 {
-    const LayoutStyle& styleToUse = styleRef();
+    const ComputedStyle& styleToUse = styleRef();
     setHasBoxDecorationBackground(calculateHasBoxDecorations());
     setInline(styleToUse.isDisplayInlineType());
     setPositionState(styleToUse.position());
     setHorizontalWritingMode(styleToUse.isHorizontalWritingMode());
 }
 
 static LayoutSize accumulateInFlowPositionOffsets(const LayoutObject* child)
 {
     if (!child->isAnonymousBlock() || !child->isRelPositioned())
         return LayoutSize();
@@ skipping 357 matching lines @@
 }
 
 LayoutRect LayoutBoxModelObject::localCaretRectForEmptyElement(LayoutUnit width, LayoutUnit textIndentOffset)
 {
     ASSERT(!slowFirstChild());
 
     // FIXME: This does not take into account either :first-line or :first-letter
     // However, as soon as some content is entered, the line boxes will be
     // constructed and this kludge is not called any more. So only the caret size
     // of an empty :first-line'd block is wrong. I think we can live with that.
-    const LayoutStyle& currentStyle = firstLineStyleRef();
+    const ComputedStyle& currentStyle = firstLineStyleRef();
 
     enum CaretAlignment { AlignLeft, AlignRight, AlignCenter };
 
     CaretAlignment alignment = AlignLeft;
 
     switch (currentStyle.textAlign()) {
     case LEFT:
     case WEBKIT_LEFT:
         break;
     case CENTER:
@@ skipping 150 matching lines @@
     ASSERT(!beforeChild || toBoxModelObject == beforeChild->parent());
     for (LayoutObject* child = startChild; child && child != endChild; ) {
         // Save our next sibling as moveChildTo will clear it.
         LayoutObject* nextSibling = child->nextSibling();
         moveChildTo(toBoxModelObject, child, beforeChild, fullRemoveInsert);
         child = nextSibling;
     }
 }
 
 } // namespace blink