Rename LayoutStyle to papayawhip

Source/core/paint/SVGInlineTextBoxPainter.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/SVGInlineTextBoxPainter.h"
 
 #include "core/dom/DocumentMarkerController.h"
 #include "core/dom/RenderedDocumentMarker.h"
 #include "core/editing/Editor.h"
@@ skipping 38 matching lines @@
     // If we ever need that for SVG, it's very easy to refactor and reuse the code.
 
     if (paintInfo.phase == PaintPhaseSelection && !shouldPaintSelection())
         return;
 
     LayoutSVGInlineText& textRenderer = toLayoutSVGInlineText(m_svgInlineTextBox.layoutObject());
     if (!textShouldBePainted(textRenderer))
         return;
 
     LayoutObject& parentRenderer = m_svgInlineTextBox.parent()->layoutObject();
-    const LayoutStyle& style = parentRenderer.styleRef();
+    const ComputedStyle& style = parentRenderer.styleRef();
 
     {
         DrawingRecorder recorder(paintInfo.context, m_svgInlineTextBox, DisplayItem::paintPhaseToDrawingType(paintInfo.phase), paintInfo.rect);
         if (!recorder.canUseCachedDrawing()) {
             InlineTextBoxPainter(m_svgInlineTextBox).paintDocumentMarkers(
                 paintInfo.context, FloatPoint(paintOffset), style,
                 textRenderer.scaledFont(), true);
 
             if (!m_svgInlineTextBox.textFragments().isEmpty())
                 paintTextFragments(paintInfo, parentRenderer);
         }
     }
 
     if (style.hasOutline() && parentRenderer.isLayoutInline())
         InlinePainter(toLayoutInline(parentRenderer)).paintOutline(paintInfo, paintOffset);
 }
 
 void SVGInlineTextBoxPainter::paintTextFragments(const PaintInfo& paintInfo, LayoutObject& parentRenderer)
 {
-    const LayoutStyle& style = parentRenderer.styleRef();
-    const SVGLayoutStyle& svgStyle = style.svgStyle();
+    const ComputedStyle& style = parentRenderer.styleRef();
+    const SVGComputedStyle& svgStyle = style.svgStyle();
 
     bool hasFill = svgStyle.hasFill();
     bool hasVisibleStroke = svgStyle.hasVisibleStroke();
 
-    const LayoutStyle* selectionStyle = &style;
+    const ComputedStyle* selectionStyle = &style;
     bool shouldPaintSelection = this->shouldPaintSelection();
     if (shouldPaintSelection) {
         selectionStyle = parentRenderer.getCachedPseudoStyle(SELECTION);
         if (selectionStyle) {
-            const SVGLayoutStyle& svgSelectionStyle = selectionStyle->svgStyle();
+            const SVGComputedStyle& svgSelectionStyle = selectionStyle->svgStyle();
 
             if (!hasFill)
                 hasFill = svgSelectionStyle.hasFill();
             if (!hasVisibleStroke)
                 hasVisibleStroke = svgSelectionStyle.hasVisibleStroke();
         } else {
             selectionStyle = &style;
         }
     }
 
@@ skipping 57 matching lines @@
         return;
 
     Color backgroundColor = m_svgInlineTextBox.layoutObject().selectionBackgroundColor();
     if (!backgroundColor.alpha())
         return;
 
     LayoutSVGInlineText& textRenderer = toLayoutSVGInlineText(m_svgInlineTextBox.layoutObject());
     if (!textShouldBePainted(textRenderer))
         return;
 
-    const LayoutStyle& style = m_svgInlineTextBox.parent()->layoutObject().styleRef();
+    const ComputedStyle& style = m_svgInlineTextBox.parent()->layoutObject().styleRef();
 
     int startPosition, endPosition;
     m_svgInlineTextBox.selectionStartEnd(startPosition, endPosition);
 
     int fragmentStartPosition = 0;
     int fragmentEndPosition = 0;
     AffineTransform fragmentTransform;
     unsigned textFragmentsSize = m_svgInlineTextBox.textFragments().size();
     for (unsigned i = 0; i < textFragmentsSize; ++i) {
         SVGTextFragment& fragment = m_svgInlineTextBox.textFragments().at(i);
@@ skipping 56 matching lines @@
 void SVGInlineTextBoxPainter::paintDecoration(const PaintInfo& paintInfo, TextDecoration decoration, const SVGTextFragment& fragment)
 {
     if (m_svgInlineTextBox.layoutObject().style()->textDecorationsInEffect() == TextDecorationNone)
         return;
 
     if (fragment.width <= 0)
         return;
 
     // Find out which render style defined the text-decoration, as its fill/stroke properties have to be used for drawing instead of ours.
     LayoutObject* decorationRenderer = findLayoutObjectDefininingTextDecoration(m_svgInlineTextBox.parent());
-    const LayoutStyle& decorationStyle = decorationRenderer->styleRef();
+    const ComputedStyle& decorationStyle = decorationRenderer->styleRef();
 
     if (decorationStyle.visibility() == HIDDEN)
         return;
 
     float scalingFactor = 1;
     Font scaledFont;
     LayoutSVGInlineText::computeNewScaledFontForStyle(decorationRenderer, &decorationStyle, scalingFactor, scaledFont);
     ASSERT(scalingFactor);
 
     float thickness = thicknessForDecoration(decoration, scaledFont);
     if (thickness <= 0)
         return;
 
     float decorationOffset = baselineOffsetForDecoration(decoration, scaledFont.fontMetrics(), thickness);
     FloatPoint decorationOrigin(fragment.x, fragment.y - decorationOffset / scalingFactor);
 
     Path path;
     path.addRect(FloatRect(decorationOrigin, FloatSize(fragment.width, thickness / scalingFactor)));
 
-    const SVGLayoutStyle& svgDecorationStyle = decorationStyle.svgStyle();
+    const SVGComputedStyle& svgDecorationStyle = decorationStyle.svgStyle();
 
     for (int i = 0; i < 3; i++) {
         switch (svgDecorationStyle.paintOrderType(i)) {
         case PT_FILL:
             if (svgDecorationStyle.hasFill()) {
                 GraphicsContextStateSaver stateSaver(*paintInfo.context, false);
                 if (!SVGLayoutSupport::updateGraphicsContext(paintInfo, stateSaver, decorationStyle, *decorationRenderer, ApplyToFillMode))
                     break;
                 paintInfo.context->fillPath(path);
             }
             break;
         case PT_STROKE:
             if (svgDecorationStyle.hasVisibleStroke()) {
                 // FIXME: Non-scaling stroke is not applied here.
                 GraphicsContextStateSaver stateSaver(*paintInfo.context, false);
                 if (!SVGLayoutSupport::updateGraphicsContext(paintInfo, stateSaver, decorationStyle, *decorationRenderer, ApplyToStrokeMode))
                     break;
                 paintInfo.context->strokePath(path);
             }
             break;
         case PT_MARKERS:
             break;
         default:
             ASSERT_NOT_REACHED();
         }
     }
 }
 
-void SVGInlineTextBoxPainter::paintTextWithShadows(const PaintInfo& paintInfo, const LayoutStyle& style,
+void SVGInlineTextBoxPainter::paintTextWithShadows(const PaintInfo& paintInfo, const ComputedStyle& style,
     TextRun& textRun, const SVGTextFragment& fragment, int startPosition, int endPosition,
     LayoutSVGResourceMode resourceMode)
 {
     LayoutSVGInlineText& textRenderer = toLayoutSVGInlineText(m_svgInlineTextBox.layoutObject());
 
     float scalingFactor = textRenderer.scalingFactor();
     ASSERT(scalingFactor);
 
     const Font& scaledFont = textRenderer.scaledFont();
     const ShadowList* shadowList = style.textShadow();
@@ skipping 37 matching lines @@
     textRunPaintInfo.from = startPosition;
     textRunPaintInfo.to = endPosition;
 
     float baseline = scaledFont.fontMetrics().floatAscent();
     textRunPaintInfo.bounds = FloatRect(textOrigin.x(), textOrigin.y() - baseline,
         textSize.width(), textSize.height());
 
     context->drawText(scaledFont, textRunPaintInfo, textOrigin);
 }
 
-void SVGInlineTextBoxPainter::paintText(const PaintInfo& paintInfo, const LayoutStyle& style,
-    const LayoutStyle& selectionStyle, const SVGTextFragment& fragment,
+void SVGInlineTextBoxPainter::paintText(const PaintInfo& paintInfo, const ComputedStyle& style,
+    const ComputedStyle& selectionStyle, const SVGTextFragment& fragment,
     LayoutSVGResourceMode resourceMode, bool shouldPaintSelection)
 {
     int startPosition = 0;
     int endPosition = 0;
     if (shouldPaintSelection) {
         m_svgInlineTextBox.selectionStartEnd(startPosition, endPosition);
         shouldPaintSelection = m_svgInlineTextBox.mapStartEndPositionsIntoFragmentCoordinates(fragment, startPosition, endPosition);
     }
 
     // Fast path if there is no selection, just draw the whole chunk part using the regular style
@@ skipping 21 matching lines @@
         StyleDifference diff;
         diff.setNeedsPaintInvalidationObject();
         SVGResourcesCache::clientStyleChanged(&m_svgInlineTextBox.parent()->layoutObject(), diff, style);
     }
 
     // Eventually draw text using regular style from the end position of the selection to the end of the current chunk part
     if (endPosition < static_cast<int>(fragment.length) && !paintSelectedTextOnly)
         paintTextWithShadows(paintInfo, style, textRun, fragment, endPosition, fragment.length, resourceMode);
 }
 
-void SVGInlineTextBoxPainter::paintTextMatchMarker(GraphicsContext* context, const FloatPoint&, DocumentMarker* marker, const LayoutStyle& style, const Font& font)
+void SVGInlineTextBoxPainter::paintTextMatchMarker(GraphicsContext* context, const FloatPoint&, DocumentMarker* marker, const ComputedStyle& style, const Font& font)
 {
     // SVG is only interested in the TextMatch markers.
     if (marker->type() != DocumentMarker::TextMatch)
         return;
 
     LayoutSVGInlineText& textRenderer = toLayoutSVGInlineText(m_svgInlineTextBox.layoutObject());
 
     FloatRect markerRect;
     AffineTransform fragmentTransform;
     for (InlineTextBox* box = textRenderer.firstTextBox(); box; box = box->nextTextBox()) {
@@ skipping 35 matching lines @@
 
             fragmentRect = fragmentTransform.mapRect(fragmentRect);
             markerRect.unite(fragmentRect);
         }
     }
 
     toRenderedDocumentMarker(marker)->setRenderedRect(LayoutRect(textRenderer.localToAbsoluteQuad(markerRect).enclosingBoundingBox()));
 }
 
 } // namespace blink