Make RenderObject::style() return a const object

Source/core/rendering/InlineFlowBox.cpp

 /*
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple 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
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 102 matching lines @@
     if (child->isText()) {
         if (child->renderer().parent() == renderer())
             m_hasTextChildren = true;
         setHasTextDescendantsOnAncestors(this);
     } else if (child->isInlineFlowBox()) {
         if (toInlineFlowBox(child)->hasTextDescendants())
             setHasTextDescendantsOnAncestors(this);
     }
 
     if (descendantsHaveSameLineHeightAndBaseline() && !child->renderer().isOutOfFlowPositioned()) {
-        RenderStyle* parentStyle = renderer().style(isFirstLineStyle());
-        RenderStyle* childStyle = child->renderer().style(isFirstLineStyle());
+        const RenderStyle* parentStyle = renderer().style(isFirstLineStyle());
+        const RenderStyle* childStyle = child->renderer().style(isFirstLineStyle());
         bool shouldClearDescendantsHaveSameLineHeightAndBaseline = false;
         if (child->renderer().isReplaced())
             shouldClearDescendantsHaveSameLineHeightAndBaseline = true;
         else if (child->isText()) {
             if (child->renderer().isBR() || child->renderer().parent() != renderer()) {
                 if (!parentStyle->font().fontMetrics().hasIdenticalAscentDescentAndLineGap(childStyle->font().fontMetrics())
                     || parentStyle->lineHeight() != childStyle->lineHeight()
                     || (parentStyle->verticalAlign() != BASELINE && !isRootInlineBox()) || childStyle->verticalAlign() != BASELINE)
                     shouldClearDescendantsHaveSameLineHeightAndBaseline = true;
             }
@@ skipping 16 matching lines @@
                     shouldClearDescendantsHaveSameLineHeightAndBaseline = true;
             }
         }
 
         if (shouldClearDescendantsHaveSameLineHeightAndBaseline)
             clearDescendantsHaveSameLineHeightAndBaseline();
     }
 
     if (!child->renderer().isOutOfFlowPositioned()) {
         if (child->isText()) {
-            RenderStyle* childStyle = child->renderer().style(isFirstLineStyle());
+            const RenderStyle* childStyle = child->renderer().style(isFirstLineStyle());
             if (childStyle->letterSpacing() < 0 || childStyle->textShadow() || childStyle->textEmphasisMark() != TextEmphasisMarkNone || childStyle->textStrokeWidth())
                 child->clearKnownToHaveNoOverflow();
         } else if (child->renderer().isReplaced()) {
             RenderBox& box = toRenderBox(child->renderer());
             if (box.hasRenderOverflow() || box.hasSelfPaintingLayer())
                 child->clearKnownToHaveNoOverflow();
         } else if (!child->renderer().isBR() && (child->renderer().style(isFirstLineStyle())->boxShadow() || child->boxModelObject()->hasSelfPaintingLayer()
             || (child->renderer().isListMarker() && !toRenderListMarker(child->renderer()).isInside())
             || child->renderer().style(isFirstLineStyle())->hasBorderImageOutsets()
             || child->renderer().style(isFirstLineStyle())->hasOutline())) {
@@ skipping 604 matching lines @@
             curr->setLogicalTop(lineBottom - (curr->logicalTop() - lineTop) - curr->logicalHeight());
     }
 }
 
 inline void InlineFlowBox::addBoxShadowVisualOverflow(LayoutRect& logicalVisualOverflow)
 {
     // box-shadow on root line boxes is applying to the block and not to the lines.
     if (!parent())
         return;
 
-    RenderStyle* style = renderer().style(isFirstLineStyle());
+    const RenderStyle* style = renderer().style(isFirstLineStyle());
     WritingMode writingMode = style->writingMode();
     ShadowList* boxShadow = style->boxShadow();
     if (!boxShadow)
         return;
 
     LayoutRectOutsets outsets(boxShadow->rectOutsetsIncludingOriginal());
     // Similar to how glyph overflow works, if our lines are flipped, then it's actually the opposite shadow that applies, since
     // the line is "upside down" in terms of block coordinates.
     LayoutRectOutsets logicalOutsets(outsets.logicalOutsetsWithFlippedLines(writingMode));
 
     LayoutRect shadowBounds(logicalFrameRect().toLayoutRect());
     shadowBounds.expand(logicalOutsets);
     logicalVisualOverflow.unite(shadowBounds);
 }
 
 inline void InlineFlowBox::addBorderOutsetVisualOverflow(LayoutRect& logicalVisualOverflow)
 {
     // border-image-outset on root line boxes is applying to the block and not to the lines.
     if (!parent())
         return;
 
-    RenderStyle* style = renderer().style(isFirstLineStyle());
+    const RenderStyle* style = renderer().style(isFirstLineStyle());
     if (!style->hasBorderImageOutsets())
         return;
 
     // Similar to how glyph overflow works, if our lines are flipped, then it's actually the opposite border that applies, since
     // the line is "upside down" in terms of block coordinates. vertical-rl and horizontal-bt are the flipped line modes.
     LayoutRectOutsets logicalOutsets = style->borderImageOutsets().logicalOutsetsWithFlippedLines(style->writingMode());
 
     if (!includeLogicalLeftEdge())
         logicalOutsets.setLeft(LayoutUnit());
     if (!includeLogicalRightEdge())
         logicalOutsets.setRight(LayoutUnit());
 
     LayoutRect borderOutsetBounds(logicalFrameRect().toLayoutRect());
     borderOutsetBounds.expand(logicalOutsets);
     logicalVisualOverflow.unite(borderOutsetBounds);
 }
 
 inline void InlineFlowBox::addOutlineVisualOverflow(LayoutRect& logicalVisualOverflow)
 {
     // Outline on root line boxes is applied to the block and not to the lines.
     if (!parent())
         return;
 
-    RenderStyle* style = renderer().style(isFirstLineStyle());
+    const RenderStyle* style = renderer().style(isFirstLineStyle());
     if (!style->hasOutline())
         return;
 
     logicalVisualOverflow.inflate(style->outlineSize());
 }
 
 inline void InlineFlowBox::addTextBoxVisualOverflow(InlineTextBox* textBox, GlyphOverflowAndFallbackFontsMap& textBoxDataMap, LayoutRect& logicalVisualOverflow)
 {
     if (textBox->knownToHaveNoOverflow())
         return;
 
-    RenderStyle* style = textBox->renderer().style(isFirstLineStyle());
+    const RenderStyle* style = textBox->renderer().style(isFirstLineStyle());
 
     GlyphOverflowAndFallbackFontsMap::iterator it = textBoxDataMap.find(textBox);
     GlyphOverflow* glyphOverflow = it == textBoxDataMap.end() ? 0 : &it->value.second;
     bool isFlippedLine = style->isFlippedLinesWritingMode();
 
     int topGlyphEdge = glyphOverflow ? (isFlippedLine ? glyphOverflow->bottom : glyphOverflow->top) : 0;
     int bottomGlyphEdge = glyphOverflow ? (isFlippedLine ? glyphOverflow->top : glyphOverflow->bottom) : 0;
     int leftGlyphEdge = glyphOverflow ? glyphOverflow->left : 0;
     int rightGlyphEdge = glyphOverflow ? glyphOverflow->right : 0;
 
@@ skipping 334 matching lines @@
             } else {
                 LayoutUnit bottomOfLastRubyTextLine = rubyText->logicalTop() + (rubyText->lastRootBox() ? rubyText->lastRootBox()->lineBottom() : rubyText->logicalHeight());
                 if (bottomOfLastRubyTextLine <= curr->logicalHeight())
                     continue;
                 bottomOfLastRubyTextLine += curr->logicalTop();
                 result = std::max(result, bottomOfLastRubyTextLine - allowedPosition);
             }
         }
 
         if (curr->isInlineTextBox()) {
-            RenderStyle* style = curr->renderer().style(isFirstLineStyle());
+            const RenderStyle* style = curr->renderer().style(isFirstLineStyle());
             TextEmphasisPosition emphasisMarkPosition;
             if (style->textEmphasisMark() != TextEmphasisMarkNone && toInlineTextBox(curr)->getEmphasisMarkPosition(style, emphasisMarkPosition) && emphasisMarkPosition == TextEmphasisPositionOver) {
                 if (!style->isFlippedLinesWritingMode()) {
                     int topOfEmphasisMark = curr->logicalTop() - style->font().emphasisMarkHeight(style->textEmphasisMarkString());
                     result = std::max(result, allowedPosition - topOfEmphasisMark);
                 } else {
                     int bottomOfEmphasisMark = curr->logicalBottom() + style->font().emphasisMarkHeight(style->textEmphasisMarkString());
                     result = std::max(result, bottomOfEmphasisMark - allowedPosition);
                 }
             }
@@ skipping 27 matching lines @@
             } else {
                 LayoutUnit bottomOfLastRubyTextLine = rubyText->logicalTop() + (rubyText->lastRootBox() ? rubyText->lastRootBox()->lineBottom() : rubyText->logicalHeight());
                 if (bottomOfLastRubyTextLine <= curr->logicalHeight())
                     continue;
                 bottomOfLastRubyTextLine += curr->logicalTop();
                 result = std::max(result, bottomOfLastRubyTextLine - allowedPosition);
             }
         }
 
         if (curr->isInlineTextBox()) {
-            RenderStyle* style = curr->renderer().style(isFirstLineStyle());
+            const RenderStyle* style = curr->renderer().style(isFirstLineStyle());
             if (style->textEmphasisMark() != TextEmphasisMarkNone && style->textEmphasisPosition() == TextEmphasisPositionUnder) {
                 if (!style->isFlippedLinesWritingMode()) {
                     LayoutUnit bottomOfEmphasisMark = curr->logicalBottom() + style->font().emphasisMarkHeight(style->textEmphasisMarkString());
                     result = std::max(result, bottomOfEmphasisMark - allowedPosition);
                 } else {
                     LayoutUnit topOfEmphasisMark = curr->logicalTop() - style->font().emphasisMarkHeight(style->textEmphasisMarkString());
                     result = std::max(result, allowedPosition - topOfEmphasisMark);
                 }
             }
         }
@@ skipping 81 matching lines @@
         ASSERT(child->prevOnLine() == prev);
         prev = child;
     }
     ASSERT(prev == m_lastChild);
 #endif
 }
 
 #endif
 
 } // namespace blink