Rename LayoutStyle to papayawhip

Source/core/paint/InlineFlowBoxPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/paint/InlineFlowBoxPainter.h"
 
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutView.h"
@@ skipping 99 matching lines @@
         // We have a fill image that spans multiple lines.
         // FIXME: frameSize ought to be the same as rect.size().
         LayoutSize frameSize(m_inlineFlowBox.width().toLayoutUnit(), m_inlineFlowBox.height().toLayoutUnit());
         LayoutRect imageStripPaintRect = paintRectForImageStrip(rect.location(), frameSize, m_inlineFlowBox.layoutObject().style()->direction());
         GraphicsContextStateSaver stateSaver(*paintInfo.context);
         paintInfo.context->clip(LayoutRect(rect.x(), rect.y(), m_inlineFlowBox.width(), m_inlineFlowBox.height()));
         BoxPainter::paintFillLayerExtended(*m_inlineFlowBox.boxModelObject(), paintInfo, c, fillLayer, imageStripPaintRect, BackgroundBleedNone, &m_inlineFlowBox, rect.size(), op);
     }
 }
 
-void InlineFlowBoxPainter::paintBoxShadow(const PaintInfo& info, const LayoutStyle& s, ShadowStyle shadowStyle, const LayoutRect& paintRect)
+void InlineFlowBoxPainter::paintBoxShadow(const PaintInfo& info, const ComputedStyle& s, ShadowStyle shadowStyle, const LayoutRect& paintRect)
 {
     if ((!m_inlineFlowBox.prevLineBox() && !m_inlineFlowBox.nextLineBox()) || !m_inlineFlowBox.parent()) {
         BoxPainter::paintBoxShadow(info, paintRect, s, shadowStyle);
     } else {
         // FIXME: We can do better here in the multi-line case. We want to push a clip so that the shadow doesn't
         // protrude incorrectly at the edges, and we want to possibly include shadows cast from the previous/following lines
         BoxPainter::paintBoxShadow(info, paintRect, s, shadowStyle, m_inlineFlowBox.includeLogicalLeftEdge(), m_inlineFlowBox.includeLogicalRightEdge());
     }
 }
 
 
 static LayoutRect clipRectForNinePieceImageStrip(InlineFlowBox* box, const NinePieceImage& image, const LayoutRect& paintRect)
 {
     LayoutRect clipRect(paintRect);
-    const LayoutStyle& style = box->layoutObject().styleRef();
+    const ComputedStyle& style = box->layoutObject().styleRef();
     LayoutRectOutsets outsets = style.imageOutsets(image);
     if (box->isHorizontal()) {
         clipRect.setY(paintRect.y() - outsets.top());
         clipRect.setHeight(paintRect.height() + outsets.top() + outsets.bottom());
         if (box->includeLogicalLeftEdge()) {
             clipRect.setX(paintRect.x() - outsets.left());
             clipRect.setWidth(paintRect.width() + outsets.left());
         }
         if (box->includeLogicalRightEdge())
             clipRect.setWidth(clipRect.width() + outsets.right());
@@ skipping 40 matching lines @@
     return LayoutRect(stripX, stripY, stripWidth, stripHeight);
 }
 
 
 InlineFlowBoxPainter::BorderPaintingType InlineFlowBoxPainter::getBorderPaintType(const LayoutRect& adjustedFrameRect, LayoutRect& adjustedClipRect) const
 {
     adjustedClipRect = adjustedFrameRect;
     if (m_inlineFlowBox.parent() && m_inlineFlowBox.layoutObject().style()->hasBorder()) {
         const NinePieceImage& borderImage = m_inlineFlowBox.layoutObject().style()->borderImage();
         StyleImage* borderImageSource = borderImage.image();
-        const LayoutStyle* styleToUse = m_inlineFlowBox.layoutObject().style(m_inlineFlowBox.isFirstLineStyle());
+        const ComputedStyle* styleToUse = m_inlineFlowBox.layoutObject().style(m_inlineFlowBox.isFirstLineStyle());
         bool hasBorderImage = borderImageSource && borderImageSource->canRender(m_inlineFlowBox.layoutObject(), styleToUse->effectiveZoom());
         if (hasBorderImage && !borderImageSource->isLoaded())
             return DontPaintBorders;
 
         // The simple case is where we either have no border image or we are the only box for this object.
         // In those cases only a single call to draw is required.
         if (!hasBorderImage || (!m_inlineFlowBox.prevLineBox() && !m_inlineFlowBox.nextLineBox()))
             return PaintBordersWithoutClip;
 
         // We have a border image that spans multiple lines.
         adjustedClipRect = clipRectForNinePieceImageStrip(&m_inlineFlowBox, borderImage, adjustedFrameRect);
         return PaintBordersWithClip;
     }
     return DontPaintBorders;
 }
 
 void InlineFlowBoxPainter::paintBoxDecorationBackground(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     ASSERT(paintInfo.phase == PaintPhaseForeground);
     if (!paintInfo.shouldPaintWithinRoot(&m_inlineFlowBox.layoutObject()) || m_inlineFlowBox.layoutObject().style()->visibility() != VISIBLE)
         return;
 
     // You can use p::first-line to specify a background. If so, the root line boxes for
     // a line may actually have to paint a background.
-    const LayoutStyle* styleToUse = m_inlineFlowBox.layoutObject().style(m_inlineFlowBox.isFirstLineStyle());
+    const ComputedStyle* styleToUse = m_inlineFlowBox.layoutObject().style(m_inlineFlowBox.isFirstLineStyle());
     bool shouldPaintBoxDecorationBackground;
     if (m_inlineFlowBox.parent())
         shouldPaintBoxDecorationBackground = m_inlineFlowBox.layoutObject().hasBoxDecorationBackground();
     else
         shouldPaintBoxDecorationBackground = m_inlineFlowBox.isFirstLineStyle() && styleToUse != m_inlineFlowBox.layoutObject().style();
 
     if (!shouldPaintBoxDecorationBackground)
         return;
 
     LayoutRect frameRect = roundedFrameRectClampedToLineTopAndBottomIfNeeded();
@@ skipping 118 matching lines @@
             rect.setHeight(logicalHeight);
         } else {
             rect.setX(logicalTop);
             rect.setWidth(logicalHeight);
         }
     }
     return rect;
 }
 
 } // namespace blink