Make RenderObject::style() return a const object

Source/core/rendering/line/BreakingContextInlineHeaders.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All right reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated.
  *
  * 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.
@@ skipping 101 matching lines @@
     InlineBidiResolver& m_resolver;
 
     InlineIterator m_current;
     InlineIterator m_lineBreak;
     InlineIterator m_startOfIgnoredSpaces;
 
     RenderBlockFlow* m_block;
     RenderObject* m_lastObject;
     RenderObject* m_nextObject;
 
-    RenderStyle* m_currentStyle;
-    RenderStyle* m_blockStyle;
+    const RenderStyle* m_currentStyle;
+    const RenderStyle* m_blockStyle;
 
     LineInfo& m_lineInfo;
 
     RenderTextInfo& m_renderTextInfo;
 
     FloatingObject* m_lastFloatFromPreviousLine;
 
     LineWidth m_width;
 
     EWhiteSpace m_currWS;
@@ skipping 361 matching lines @@
 {
     for (size_t i = 0; i < wordMeasurements.size(); ++i) {
         if (wordMeasurements[i].width > 0)
             return wordMeasurements[i].width;
     }
     return 0;
 }
 
 inline float measureHyphenWidth(RenderText* renderer, const Font& font, TextDirection textDirection)
 {
-    RenderStyle* style = renderer->style();
+    const RenderStyle* style = renderer->style();
     return font.width(constructTextRun(renderer, font,
         style->hyphenString().string(), style, style->direction()));
 }
 
 ALWAYS_INLINE TextDirection textDirectionFromUnicode(WTF::Unicode::Direction direction)
 {
     return direction == WTF::Unicode::RightToLeft
         || direction == WTF::Unicode::RightToLeftArabic ? RTL : LTR;
 }
 
@@ skipping 30 matching lines @@
         RenderCombineText* combineRenderer = toRenderCombineText(m_current.object());
         combineRenderer->combineText();
         // The length of the renderer's text may have changed. Increment stale iterator positions
         if (iteratorIsBeyondEndOfRenderCombineText(m_lineBreak, combineRenderer)) {
             ASSERT(iteratorIsBeyondEndOfRenderCombineText(m_resolver.position(), combineRenderer));
             m_lineBreak.increment();
             m_resolver.position().increment(&m_resolver);
         }
     }
 
-    RenderStyle* style = renderText->style(m_lineInfo.isFirstLine());
+    const RenderStyle* style = renderText->style(m_lineInfo.isFirstLine());
     const Font& font = style->font();
     bool isFixedPitch = font.isFixedPitch();
 
     unsigned lastSpace = m_current.offset();
     float wordSpacing = m_currentStyle->wordSpacing();
     float lastSpaceWordSpacing = 0;
     float wordSpacingForWordMeasurement = 0;
 
     float wrapW = m_width.uncommittedWidth() + inlineLogicalWidth(m_current.object(), !m_appliedStartWidth, true);
     float charWidth = 0;
@@ skipping 325 matching lines @@
 
     if (!m_current.object()->isFloatingOrOutOfFlowPositioned()) {
         m_lastObject = m_current.object();
         if (m_lastObject->isReplaced() && m_autoWrap && (!m_lastObject->isImage() || m_allowImagesToBreak) && (!m_lastObject->isListMarker() || toRenderListMarker(m_lastObject)->isInside())) {
             m_width.commit();
             m_lineBreak.moveToStartOf(m_nextObject);
         }
     }
 }
 
-inline IndentTextOrNot requiresIndent(bool isFirstLine, bool isAfterHardLineBreak, RenderStyle* style)
+inline IndentTextOrNot requiresIndent(bool isFirstLine, bool isAfterHardLineBreak, const RenderStyle* style)
 {
     IndentTextOrNot shouldIndentText = DoNotIndentText;
     if (isFirstLine || (isAfterHardLineBreak && style->textIndentLine()) == TextIndentEachLine)
         shouldIndentText = IndentText;
 
     if (style->textIndentType() == TextIndentHanging)
         shouldIndentText = shouldIndentText == IndentText ? DoNotIndentText : IndentText;
 
     return shouldIndentText;
 }
 
 }
 
 #endif // BreakingContextInlineHeaders_h