Make RenderObject::style() return a const object

Source/core/rendering/RenderText.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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
@@ skipping 182 matching lines @@
 {
     // There is no need to ever schedule paint invalidations from a style change of a text run, since
     // we already did this for the parent of the text run.
     // We do have to schedule layouts, though, since a style change can force us to
     // need to relayout.
     if (diff.needsFullLayout()) {
         setNeedsLayoutAndPrefWidthsRecalc();
         m_knownToHaveNoOverflowAndNoFallbackFonts = false;
     }
 
-    RenderStyle* newStyle = style();
+    const RenderStyle* newStyle = style();
     ETextTransform oldTransform = oldStyle ? oldStyle->textTransform() : TTNONE;
     ETextSecurity oldSecurity = oldStyle ? oldStyle->textSecurity() : TSNONE;
     if (oldTransform != newStyle->textTransform() || oldSecurity != newStyle->textSecurity())
         transformText();
 
     // This is an optimization that kicks off font load before layout.
     // In order to make it fast, we only check if the first character of the
     // text is included in the unicode ranges of the fonts.
     if (!text().containsOnlyWhitespace())
         newStyle->font().willUseFontData(text().characterStartingAt(0));
@@ skipping 447 matching lines @@
 
     float rootLeft = box->root().logicalLeft();
     float rootRight = box->root().logicalRight();
 
     // FIXME: should we use the width of the root inline box or the
     // width of the containing block for this?
     if (extraWidthToEndOfLine)
         *extraWidthToEndOfLine = (box->root().logicalWidth() + rootLeft) - (left + 1);
 
     RenderBlock* cb = containingBlock();
-    RenderStyle* cbStyle = cb->style();
+    const RenderStyle* cbStyle = cb->style();
 
     float leftEdge;
     float rightEdge;
     leftEdge = std::min<float>(0, rootLeft);
     rightEdge = std::max<float>(cb->logicalWidth().toFloat(), rootRight);
 
     bool rightAligned = false;
     switch (cbStyle->textAlign()) {
     case RIGHT:
     case WEBKIT_RIGHT:
@@ skipping 38 matching lines @@
             return combineText->combinedTextWidth(f);
     }
 
     if (f.isFixedPitch() && f.fontDescription().variant() == FontVariantNormal && m_isAllASCII && (!glyphOverflow || !glyphOverflow->computeBounds)) {
         bool missingGlyph = false;
         float monospaceCharacterWidth = f.spaceWidth();
         float w = 0;
         bool isSpace;
         ASSERT(m_text);
         StringImpl& text = *m_text.impl();
-        RenderStyle* renderStyle = style();
+        const RenderStyle* renderStyle = style();
         for (int i = start; i < start + len; i++) {
             char c = text[i];
             // If glyph is not present in primary font then we cannot calculate width based on primary
             // font property, we need to call "width" method of Font Object.
             if (!f.primaryFontHasGlyphForCharacter(text[i])) {
                 missingGlyph = true;
                 break;
             }
             if (c <= space) {
                 if (c == space || c == newlineCharacter) {
@@ skipping 145 matching lines @@
     GlyphOverflow glyphOverflow;
     computePreferredLogicalWidths(leadWidth, fallbackFonts, glyphOverflow);
 
     // We shouldn't change our mind once we "know".
     ASSERT(!m_knownToHaveNoOverflowAndNoFallbackFonts || (fallbackFonts.isEmpty() && glyphOverflow.isZero()));
     m_knownToHaveNoOverflowAndNoFallbackFonts = fallbackFonts.isEmpty() && glyphOverflow.isZero();
 }
 
 static inline float hyphenWidth(RenderText* renderer, const Font& font, TextDirection direction)
 {
-    RenderStyle* style = renderer->style();
+    const RenderStyle* style = renderer->style();
     return font.width(constructTextRun(renderer, font, style->hyphenString().string(), style, direction));
 }
 
 void RenderText::computePreferredLogicalWidths(float leadWidth, HashSet<const SimpleFontData*>& fallbackFonts, GlyphOverflow& glyphOverflow)
 {
     ASSERT(m_hasTab || preferredLogicalWidthsDirty() || !m_knownToHaveNoOverflowAndNoFallbackFonts);
 
     m_minWidth = 0;
     m_maxWidth = 0;
     m_firstLineMinWidth = 0;
     m_lastLineLineMinWidth = 0;
 
     if (isBR())
         return;
 
     float currMinWidth = 0;
     float currMaxWidth = 0;
     m_hasBreakableChar = false;
     m_hasBreak = false;
     m_hasTab = false;
     m_hasBreakableStart = false;
     m_hasBreakableEnd = false;
     m_hasEndWhiteSpace = false;
 
-    RenderStyle* styleToUse = style();
+    const RenderStyle* styleToUse = style();
     const Font& f = styleToUse->font(); // FIXME: This ignores first-line.
     float wordSpacing = styleToUse->wordSpacing();
     int len = textLength();
     LazyLineBreakIterator breakIterator(m_text, styleToUse->locale());
     bool needsWordSpacing = false;
     bool ignoringSpaces = false;
     bool isSpace = false;
     bool firstWord = true;
     bool firstLine = true;
     int nextBreakable = -1;
@@ skipping 950 matching lines @@
     }
     secureTextTimer->restartWithNewText(lastTypedCharacterOffset);
 }
 
 PassRefPtr<AbstractInlineTextBox> RenderText::firstAbstractInlineTextBox()
 {
     return AbstractInlineTextBox::getOrCreate(this, m_firstTextBox);
 }
 
 } // namespace blink