Revert 190605 "Make RenderObject::style() return a const object"

trunk/Source/core/layout/LayoutTextControlSingleLine.cpp

 /**
  * Copyright (C) 2006, 2007, 2010 Apple Inc. All rights reserved.
  *           (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
  *
  * 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 92 matching lines @@
 
     // We don't honor paddings and borders for textfields without decorations
     // and type=search if the text height is taller than the contentHeight()
     // because of compability.
 
     RenderBox* innerEditorRenderer = innerEditorElement()->renderBox();
     RenderBox* viewPortRenderer = editingViewPortElement() ? editingViewPortElement()->renderBox() : 0;
 
     // To ensure consistency between layouts, we need to reset any conditionally overriden height.
     if (innerEditorRenderer && !innerEditorRenderer->style()->logicalHeight().isAuto()) {
-        innerEditorRenderer->mutableStyleRef().setLogicalHeight(Length(Auto));
+        innerEditorRenderer->style()->setLogicalHeight(Length(Auto));
         layoutScope.setNeedsLayout(innerEditorRenderer);
         HTMLElement* placeholderElement = inputElement()->placeholderElement();
         if (RenderBox* placeholderBox = placeholderElement ? placeholderElement->renderBox() : 0)
             layoutScope.setNeedsLayout(placeholderBox);
     }
     if (viewPortRenderer && !viewPortRenderer->style()->logicalHeight().isAuto()) {
-        viewPortRenderer->mutableStyleRef().setLogicalHeight(Length(Auto));
+        viewPortRenderer->style()->setLogicalHeight(Length(Auto));
         layoutScope.setNeedsLayout(viewPortRenderer);
     }
 
     RenderBlockFlow::layoutBlock(false);
 
     Element* container = containerElement();
     RenderBox* containerRenderer = container ? container->renderBox() : 0;
 
     // Set the text block height
     LayoutUnit desiredLogicalHeight = textBlockLogicalHeight();
     LayoutUnit logicalHeightLimit = computeLogicalHeightLimit();
     if (innerEditorRenderer && innerEditorRenderer->logicalHeight() > logicalHeightLimit) {
         if (desiredLogicalHeight != innerEditorRenderer->logicalHeight())
             layoutScope.setNeedsLayout(this);
 
         m_desiredInnerEditorLogicalHeight = desiredLogicalHeight;
 
-        innerEditorRenderer->mutableStyleRef().setLogicalHeight(Length(desiredLogicalHeight, Fixed));
+        innerEditorRenderer->style()->setLogicalHeight(Length(desiredLogicalHeight, Fixed));
         layoutScope.setNeedsLayout(innerEditorRenderer);
         if (viewPortRenderer) {
-            viewPortRenderer->mutableStyleRef().setLogicalHeight(Length(desiredLogicalHeight, Fixed));
+            viewPortRenderer->style()->setLogicalHeight(Length(desiredLogicalHeight, Fixed));
             layoutScope.setNeedsLayout(viewPortRenderer);
         }
     }
     // The container might be taller because of decoration elements.
     if (containerRenderer) {
         containerRenderer->layoutIfNeeded();
         LayoutUnit containerLogicalHeight = containerRenderer->logicalHeight();
         if (containerLogicalHeight > logicalHeightLimit) {
-            containerRenderer->mutableStyleRef().setLogicalHeight(Length(logicalHeightLimit, Fixed));
+            containerRenderer->style()->setLogicalHeight(Length(logicalHeightLimit, Fixed));
             layoutScope.setNeedsLayout(this);
         } else if (containerRenderer->logicalHeight() < contentLogicalHeight()) {
-            containerRenderer->mutableStyleRef().setLogicalHeight(Length(contentLogicalHeight(), Fixed));
+            containerRenderer->style()->setLogicalHeight(Length(contentLogicalHeight(), Fixed));
             layoutScope.setNeedsLayout(this);
         } else {
-            containerRenderer->mutableStyleRef().setLogicalHeight(Length(containerLogicalHeight, Fixed));
+            containerRenderer->style()->setLogicalHeight(Length(containerLogicalHeight, Fixed));
         }
     }
 
     // If we need another layout pass, we have changed one of children's height so we need to relayout them.
     if (needsLayout())
         RenderBlockFlow::layoutBlock(true);
 
     // Center the child block in the block progression direction (vertical centering for horizontal text fields).
     if (!container && innerEditorRenderer && innerEditorRenderer->size().height() != contentLogicalHeight()) {
         LayoutUnit logicalHeightDiff = innerEditorRenderer->logicalHeight() - contentLogicalHeight();
         innerEditorRenderer->setLogicalTop(innerEditorRenderer->logicalTop() - (logicalHeightDiff / 2 + layoutMod(logicalHeightDiff, 2)));
     } else {
         centerContainerIfNeeded(containerRenderer);
     }
 
     HTMLElement* placeholderElement = inputElement()->placeholderElement();
     if (RenderBox* placeholderBox = placeholderElement ? placeholderElement->renderBox() : 0) {
         LayoutSize innerEditorSize;
 
         if (innerEditorRenderer)
             innerEditorSize = innerEditorRenderer->size();
-        placeholderBox->mutableStyleRef().setWidth(Length(innerEditorSize.width() - placeholderBox->borderAndPaddingWidth(), Fixed));
-        placeholderBox->mutableStyleRef().setHeight(Length(innerEditorSize.height() - placeholderBox->borderAndPaddingHeight(), Fixed));
+        placeholderBox->style()->setWidth(Length(innerEditorSize.width() - placeholderBox->borderAndPaddingWidth(), Fixed));
+        placeholderBox->style()->setHeight(Length(innerEditorSize.height() - placeholderBox->borderAndPaddingHeight(), Fixed));
         bool neededLayout = placeholderBox->needsLayout();
         placeholderBox->layoutIfNeeded();
         LayoutPoint textOffset;
         if (innerEditorRenderer)
             textOffset = innerEditorRenderer->location();
         if (editingViewPortElement() && editingViewPortElement()->renderBox())
             textOffset += toLayoutSize(editingViewPortElement()->renderBox()->location());
         if (containerRenderer)
             textOffset += toLayoutSize(containerRenderer->location());
         placeholderBox->setLocation(textOffset);
@@ skipping 30 matching lines @@
 
 void LayoutTextControlSingleLine::styleDidChange(StyleDifference diff, const LayoutStyle* oldStyle)
 {
     m_desiredInnerEditorLogicalHeight = -1;
     LayoutTextControl::styleDidChange(diff, oldStyle);
 
     // We may have set the width and the height in the old style in layout().
     // Reset them now to avoid getting a spurious layout hint.
     Element* viewPort = editingViewPortElement();
     if (LayoutObject* viewPortRenderer = viewPort ? viewPort->renderer() : 0) {
-        viewPortRenderer->mutableStyle()->setHeight(Length());
-        viewPortRenderer->mutableStyle()->setWidth(Length());
+        viewPortRenderer->style()->setHeight(Length());
+        viewPortRenderer->style()->setWidth(Length());
     }
     Element* container = containerElement();
     if (LayoutObject* containerRenderer = container ? container->renderer() : 0) {
-        containerRenderer->mutableStyle()->setHeight(Length());
-        containerRenderer->mutableStyle()->setWidth(Length());
+        containerRenderer->style()->setHeight(Length());
+        containerRenderer->style()->setWidth(Length());
     }
     LayoutObject* innerEditorRenderer = innerEditorElement()->renderer();
     if (innerEditorRenderer && diff.needsFullLayout())
         innerEditorRenderer->setNeedsLayoutAndFullPaintInvalidation();
     if (HTMLElement* placeholder = inputElement()->placeholderElement())
         placeholder->setInlineStyleProperty(CSSPropertyTextOverflow, textShouldBeTruncated() ? CSSValueEllipsis : CSSValueClip);
     setHasOverflowClip(false);
 }
 
 void LayoutTextControlSingleLine::capsLockStateMayHaveChanged()
@@ skipping 175 matching lines @@
     if (innerEditorElement())
         innerEditorElement()->setScrollTop(newTop);
 }
 
 HTMLInputElement* LayoutTextControlSingleLine::inputElement() const
 {
     return toHTMLInputElement(node());
 }
 
 }