Rename renderer() to layoutObject().

Source/core/dom/Node.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 274 matching lines @@
 #endif
 
 #if !ENABLE(OILPAN)
 #if DUMP_NODE_STATISTICS
     liveNodeSet().remove(this);
 #endif
 
     if (hasRareData())
         clearRareData();
 
-    RELEASE_ASSERT(!renderer());
+    RELEASE_ASSERT(!layoutObject());
 
     if (!isContainerNode())
         willBeDeletedFromDocument();
 
     if (m_previous)
         m_previous->setNextSibling(nullptr);
     if (m_next)
         m_next->setPreviousSibling(nullptr);
 
     if (m_treeScope)
         m_treeScope->guardDeref();
 
     if (getFlag(HasWeakReferencesFlag))
         WeakNodeMap::notifyNodeDestroyed(this);
 
     // clearEventTargetData() must be always done,
     // or eventTargetDataMap() may keep a raw pointer to a deleted object.
     ASSERT(!hasEventTargetData());
 #else
     // With Oilpan, the rare data finalizer also asserts for
     // this condition (we cannot directly access it here.)
-    RELEASE_ASSERT(hasRareData() || !renderer());
+    RELEASE_ASSERT(hasRareData() || !layoutObject());
 #endif
 
     InspectorCounters::decrementCounter(InspectorCounters::NodeCounter);
 }
 
 #if !ENABLE(OILPAN)
 // With Oilpan all of this is handled with weak processing of the document.
 void Node::willBeDeletedFromDocument()
 {
     if (hasEventTargetData())
@@ skipping 35 matching lines @@
     setFlag(HasRareDataFlag);
     return *rareData();
 }
 
 #if !ENABLE(OILPAN)
 void Node::clearRareData()
 {
     ASSERT(hasRareData());
     ASSERT(!transientMutationObserverRegistry() || transientMutationObserverRegistry()->isEmpty());
 
-    LayoutObject* renderer = m_data.m_rareData->renderer();
+    LayoutObject* renderer = m_data.m_rareData->layoutObject();

[Julien - ping for review, 2015/03/05 16:19:15]

s/renderer/layoutObject/

[Julien - ping for review, 2015/03/05 16:19:15]

s/renderer/layoutObject/

     if (isElementNode())
         delete static_cast<ElementRareData*>(m_data.m_rareData);
     else
         delete static_cast<NodeRareData*>(m_data.m_rareData);
     m_data.m_renderer = renderer;
     clearFlag(HasRareDataFlag);
 }
 #endif
 
 Node* Node::toNode()
@@ skipping 170 matching lines @@
 bool Node::hasEditableStyle(EditableLevel editableLevel, UserSelectAllTreatment treatment) const
 {
     if (isPseudoElement())
         return false;
 
     // Ideally we'd call ASSERT(!needsStyleRecalc()) here, but
     // ContainerNode::setFocus() calls setNeedsStyleRecalc(), so the assertion
     // would fire in the middle of Document::setFocusedNode().
 
     for (const Node* node = this; node; node = node->parentNode()) {
-        if ((node->isHTMLElement() || node->isDocumentNode()) && node->renderer()) {
+        if ((node->isHTMLElement() || node->isDocumentNode()) && node->layoutObject()) {
             // Elements with user-select: all style are considered atomic
             // therefore non editable.
             if (Position::nodeIsUserSelectAll(node) && treatment == UserSelectAllIsAlwaysNonEditable)
                 return false;
-            switch (node->renderer()->style()->userModify()) {
+            switch (node->layoutObject()->style()->userModify()) {
             case READ_ONLY:
                 return false;
             case READ_WRITE:
                 return true;
             case READ_WRITE_PLAINTEXT_ONLY:
                 return editableLevel != RichlyEditable;
             }
             ASSERT_NOT_REACHED();
             return false;
         }
@@ skipping 15 matching lines @@
     ASSERT(document().existingAXObjectCache());
 
     if (AXObjectCache* cache = document().existingAXObjectCache())
         return cache->rootAXEditableElement(this);
 
     return false;
 }
 
 LayoutBox* Node::layoutBox() const
 {
-    LayoutObject* renderer = this->renderer();
+    LayoutObject* renderer = this->layoutObject();

[Julien - ping for review, 2015/03/05 16:19:15]

Ditto.

     return renderer && renderer->isBox() ? toLayoutBox(renderer) : nullptr;
 }
 
 LayoutBoxModelObject* Node::layoutBoxModelObject() const
 {
-    LayoutObject* renderer = this->renderer();
+    LayoutObject* renderer = this->layoutObject();
     return renderer && renderer->isBoxModelObject() ? toLayoutBoxModelObject(renderer) : nullptr;

[Julien - ping for review, 2015/03/05 16:19:15]

Ditto.

 }
 
 LayoutRect Node::boundingBox() const
 {
-    if (renderer())
-        return LayoutRect(renderer()->absoluteBoundingBoxRect());
+    if (layoutObject())
+        return LayoutRect(layoutObject()->absoluteBoundingBoxRect());
     return LayoutRect();
 }
 
 bool Node::hasNonEmptyBoundingBox() const
 {
     // Before calling absoluteRects, check for the common case where the renderer
     // is non-empty, since this is a faster check and almost always returns true.
     LayoutBoxModelObject* box = layoutBoxModelObject();
     if (!box)
         return false;
     if (!box->borderBoundingBox().isEmpty())
         return true;
 
     Vector<IntRect> rects;
-    FloatPoint absPos = renderer()->localToAbsolute();
-    renderer()->absoluteRects(rects, flooredLayoutPoint(absPos));
+    FloatPoint absPos = layoutObject()->localToAbsolute();
+    layoutObject()->absoluteRects(rects, flooredLayoutPoint(absPos));
     size_t n = rects.size();
     for (size_t i = 0; i < n; ++i)
         if (!rects[i].isEmpty())
             return true;
 
     return false;
 }
 
 #ifndef NDEBUG
 inline static ShadowRoot* oldestShadowRootFor(const Node* node)
@@ skipping 269 matching lines @@
     // We only need to detach if the node has already been through attach().
     if (styleChangeType() < NeedsReattachStyleChange)
         detach(reattachContext);
     attach(reattachContext);
 }
 
 void Node::attach(const AttachContext&)
 {
     ASSERT(document().inStyleRecalc() || isDocumentNode());
     ASSERT(needsAttach());
-    ASSERT(!renderer() || (renderer()->style() && (renderer()->parent() || renderer()->isLayoutView())));
+    ASSERT(!layoutObject() || (layoutObject()->style() && (layoutObject()->parent() || layoutObject()->isLayoutView())));
 
     clearNeedsStyleRecalc();
 
     if (AXObjectCache* cache = document().axObjectCache())
         cache->updateCacheAfterNodeIsAttached(this);
 }
 
 #if ENABLE(ASSERT)
 static Node* detachingNode;
 
@@ skipping 10 matching lines @@
 
 #if ENABLE(ASSERT)
     // The detaching might trigger destruction of a popup menu window,
     // with ensuing detachment of its Nodes. In a separate document, so
     // don't assert for these, but do set detachingNode to the most recent
     // Node being detached.
     ASSERT(!detachingNode || detachingNode->document() != document());
     detachingNode = this;
 #endif
 
-    if (renderer())
-        renderer()->destroyAndCleanupAnonymousWrappers();
+    if (layoutObject())
+        layoutObject()->destroyAndCleanupAnonymousWrappers();
     setRenderer(nullptr);
 
     // Do not remove the element's hovered and active status
     // if performing a reattach.
     if (!context.performingReattach) {
         Document& doc = document();
         if (isUserActionElement()) {
             if (hovered())
                 doc.hoveredNodeDetached(this);
             if (inActiveChain())
@@ skipping 13 matching lines @@
 #if ENABLE(ASSERT)
     detachingNode = nullptr;
 #endif
 }
 
 void Node::reattachWhitespaceSiblingsIfNeeded(Text* start)
 {
     for (Node* sibling = start; sibling; sibling = sibling->nextSibling()) {
         if (sibling->isTextNode() && toText(sibling)->containsOnlyWhitespace()) {
             toText(sibling)->reattachIfNeeded();
-        } else if (sibling->renderer()) {
+        } else if (sibling->layoutObject()) {
             return;
         }
     }
 }
 
 // FIXME: This code is used by editing.  Seems like it could move over there and not pollute Node.
 Node* Node::previousNodeConsideringAtomicNodes() const
 {
     if (previousSibling()) {
         Node* n = previousSibling();
@@ skipping 56 matching lines @@
     return 0;
 }
 
 // FIXME: Shouldn't these functions be in the editing code?  Code that asks questions about HTML in the core DOM class
 // is obviously misplaced.
 bool Node::canStartSelection() const
 {
     if (hasEditableStyle())
         return true;
 
-    if (renderer()) {
-        LayoutStyle* style = renderer()->style();
+    if (layoutObject()) {
+        LayoutStyle* style = layoutObject()->style();
         // We allow selections to begin within an element that has -webkit-user-select: none set,
         // but if the element is draggable then dragging should take priority over selection.
         if (style->userDrag() == DRAG_ELEMENT && style->userSelect() == SELECT_NONE)
             return false;
     }
     return parentOrShadowHostNode() ? parentOrShadowHostNode()->canStartSelection() : true;
 }
 
 bool Node::canParticipateInComposedTree() const
 {
@@ skipping 1085 matching lines @@
         if (mouseEvent->button() == MiddleButton) {
             if (enclosingLinkEventParentOrSelf())
                 return;
 
             // Avoid that canBeScrolledAndHasScrollableArea changes render tree
             // structure.
             // FIXME: We should avoid synchronous layout if possible. We can
             // remove this synchronous layout if we avoid synchronous layout in
             // LayoutTextControlSingleLine::scrollHeight
             document().updateLayoutIgnorePendingStylesheets();
-            LayoutObject* renderer = this->renderer();
+            LayoutObject* renderer = this->layoutObject();
             while (renderer && (!renderer->isBox() || !toLayoutBox(renderer)->canBeScrolledAndHasScrollableArea()))
                 renderer = renderer->parent();
 
             if (renderer) {
                 if (LocalFrame* frame = document().frame())
                     frame->eventHandler().startPanScrolling(renderer);
             }
         }
 #endif
     } else if ((eventType == EventTypeNames::wheel || eventType == EventTypeNames::mousewheel) && event->hasInterface(EventNames::WheelEvent)) {
         WheelEvent* wheelEvent = toWheelEvent(event);
 
         // If we don't have a renderer, send the wheel event to the first node we find with a renderer.
         // This is needed for <option> and <optgroup> elements so that <select>s get a wheel scroll.
         Node* startNode = this;
-        while (startNode && !startNode->renderer())
+        while (startNode && !startNode->layoutObject())
             startNode = startNode->parentOrShadowHostNode();
 
-        if (startNode && startNode->renderer()) {
+        if (startNode && startNode->layoutObject()) {
             if (LocalFrame* frame = document().frame())
                 frame->eventHandler().defaultWheelEventHandler(startNode, wheelEvent);
         }
     } else if (event->type() == EventTypeNames::webkitEditableContentChanged) {
         dispatchInputEvent();
     }
 }
 
 void Node::willCallDefaultEventHandler(const Event&)
 {
@@ skipping 252 matching lines @@
         node->showTreeForThis();
 }
 
 void showNodePath(const blink::Node* node)
 {
     if (node)
         node->showNodePathForThis();
 }
 
 #endif