Make RenderObject::style() return a const object

Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc. All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 1616 matching lines @@
         reattachWhitespaceSiblingsIfNeeded(nextTextSibling);
 }
 
 StyleRecalcChange Element::recalcOwnStyle(StyleRecalcChange change)
 {
     ASSERT(document().inStyleRecalc());
     ASSERT(!parentOrShadowHostNode()->needsStyleRecalc());
     ASSERT(change >= Inherit || needsStyleRecalc());
     ASSERT(parentLayoutStyle());
 
-    RefPtr<LayoutStyle> oldStyle = layoutStyle();
+    RefPtr<LayoutStyle> oldStyle = mutableLayoutStyle();
     RefPtr<LayoutStyle> newStyle = styleForRenderer();
     StyleRecalcChange localChange = LayoutStyle::stylePropagationDiff(oldStyle.get(), newStyle.get());
 
     ASSERT(newStyle);
 
     if (localChange == Reattach) {
         AttachContext reattachContext;
         reattachContext.resolvedStyle = newStyle.get();
         bool rendererWillChange = needsAttach() || renderer();
         reattach(reattachContext);
@@ skipping 24 matching lines @@
 
     if (change > Inherit || localChange > Inherit)
         return max(localChange, change);
 
     if (localChange < Inherit && (oldStyle->hasPseudoElementStyle() || newStyle->hasPseudoElementStyle()))
         return UpdatePseudoElements;
 
     return localChange;
 }
 
-void Element::updateCallbackSelectors(LayoutStyle* oldStyle, LayoutStyle* newStyle)
+void Element::updateCallbackSelectors(const LayoutStyle* oldStyle, const LayoutStyle* newStyle)
 {
     Vector<String> emptyVector;
     const Vector<String>& oldCallbackSelectors = oldStyle ? oldStyle->callbackSelectors() : emptyVector;
     const Vector<String>& newCallbackSelectors = newStyle ? newStyle->callbackSelectors() : emptyVector;
     if (oldCallbackSelectors.isEmpty() && newCallbackSelectors.isEmpty())
         return;
     if (oldCallbackSelectors != newCallbackSelectors)
         CSSSelectorWatch::from(document()).updateSelectorMatches(oldCallbackSelectors, newCallbackSelectors);
 }
 
@@ skipping 130 matching lines @@
     case CDATA_SECTION_NODE:
         return true;
     default:
         break;
     }
     return false;
 }
 
 void Element::checkForEmptyStyleChange()
 {
-    LayoutStyle* style = layoutStyle();
+    const LayoutStyle* style = layoutStyle();
 
     if (!style && !styleAffectedByEmpty())
         return;
     if (styleChangeType() >= SubtreeStyleChange)
         return;
     if (!inActiveDocument())
         return;
     if (!document().styleResolver())
         return;
 
@@ skipping 671 matching lines @@
 
     if (!inActiveDocument()) {
         // FIXME: Try to do better than this. Ensure that styleForElement() works for elements that are not in the
         // document tree and figure out when to destroy the computed style for such elements.
         return nullptr;
     }
 
     // FIXME: Find and use the renderer from the pseudo element instead of the actual element so that the 'length'
     // properties, which are only known by the renderer because it did the layout, will be correct and so that the
     // values returned for the ":selection" pseudo-element will be correct.
-    LayoutStyle* elementStyle = layoutStyle();
+    LayoutStyle* elementStyle = mutableLayoutStyle();
     if (!elementStyle) {
         ElementRareData& rareData = ensureElementRareData();
         if (!rareData.computedStyle())
             rareData.setComputedStyle(document().styleForElementIgnoringPendingStylesheets(this));
         elementStyle = rareData.computedStyle();
     }
 
     if (!pseudoElementSpecifier)
         return elementStyle;
 
@@ skipping 62 matching lines @@
     ASSERT(!needsStyleRecalc());
     PseudoElement* element = pseudoElement(pseudoId);
 
     if (element && (change == UpdatePseudoElements || element->shouldCallRecalcStyle(change))) {
         if (pseudoId == FIRST_LETTER && updateFirstLetter(element))
             return;
 
         // Need to clear the cached style if the PseudoElement wants a recalc so it
         // computes a new style.
         if (element->needsStyleRecalc())
-            renderer()->style()->removeCachedPseudoStyle(pseudoId);
+            renderer()->mutableStyleRef().removeCachedPseudoStyle(pseudoId);
 
         // PseudoElement styles hang off their parent element's style so if we needed
         // a style recalc we should Force one on the pseudo.
         // FIXME: We should figure out the right text sibling to pass.
         element->recalcStyle(change == UpdatePseudoElements ? Force : change);
 
         // Wait until our parent is not displayed or pseudoElementRendererIsNeeded
         // is false, otherwise we could continuously create and destroy PseudoElements
         // when LayoutObject::isChildAllowed on our parent returns false for the
         // PseudoElement's renderer for each style recalc.
@@ skipping 751 matching lines @@
 {
 #if ENABLE(OILPAN)
     if (hasRareData())
         visitor->trace(elementRareData());
     visitor->trace(m_elementData);
 #endif
     ContainerNode::trace(visitor);
 }
 
 } // namespace blink