Move rendering/RenderObject to layout/LayoutObject.

Source/core/rendering/RenderView.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  *
  * 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.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 45 matching lines @@
     , m_selectionEnd(nullptr)
     , m_selectionStartPos(-1)
     , m_selectionEndPos(-1)
     , m_pageLogicalHeight(0)
     , m_pageLogicalHeightChanged(false)
     , m_layoutState(0)
     , m_renderQuoteHead(nullptr)
     , m_layoutCounterCount(0)
     , m_hitTestCount(0)
 {
-    // init RenderObject attributes
+    // init LayoutObject attributes
     setInline(false);
 
     m_minPreferredLogicalWidth = 0;
     m_maxPreferredLogicalWidth = 0;
 
     setPreferredLogicalWidthsDirty(MarkOnlyThis);
 
     setPositionState(AbsolutePosition); // to 0,0 :)
 }
 
@@ skipping 43 matching lines @@
 }
 
 LayoutUnit RenderView::availableLogicalHeight(AvailableLogicalHeightType heightType) const
 {
     // If we have columns, then the available logical height is reduced to the column height.
     if (hasColumns())
         return columnInfo()->columnHeight();
     return RenderBlockFlow::availableLogicalHeight(heightType);
 }
 
-bool RenderView::isChildAllowed(RenderObject* child, const RenderStyle&) const
+bool RenderView::isChildAllowed(LayoutObject* child, const RenderStyle&) const
 {
     return child->isBox();
 }
 
 void RenderView::layoutContent()
 {
     ASSERT(needsLayout());
 
     RenderBlockFlow::layout();
 
@@ skipping 17 matching lines @@
     // and discrete paint invalidation rects, so marking full paint invalidation here is more likely to cost less.
     // Otherwise, per-descendant paint invalidation is more likely to avoid unnecessary full paint invalidation.
 
     if (shouldUsePrintingLayout())
         return true;
 
     if (!style()->isHorizontalWritingMode() || size().width() != viewWidth())
         return true;
 
     if (size().height() != viewHeight()) {
-        if (RenderObject* backgroundRenderer = this->backgroundRenderer()) {
+        if (LayoutObject* backgroundRenderer = this->backgroundRenderer()) {
             // When background-attachment is 'fixed', we treat the viewport (instead of the 'root'
             // i.e. html or body) as the background positioning area, and we should full paint invalidation
             // viewport resize if the background image is not composited and needs full paint invalidation on
             // background positioning area resize.
             if (!m_compositor || !m_compositor->needsFixedRootBackgroundLayer(layer())) {
                 if (backgroundRenderer->style()->hasFixedBackgroundImage()
                     && mustInvalidateFillLayersPaintOnHeightChange(backgroundRenderer->style()->backgroundLayers()))
                     return true;
             }
         }
     }
 
     return false;
 }
 
 void RenderView::layout()
 {
     if (!document().paginated())
         setPageLogicalHeight(0);
 
     if (shouldUsePrintingLayout())
         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = logicalWidth();
 
     SubtreeLayoutScope layoutScope(*this);
 
     // Use calcWidth/Height to get the new width/height, since this will take the full page zoom factor into account.
     bool relayoutChildren = !shouldUsePrintingLayout() && (!m_frameView || size().width() != viewWidth() || size().height() != viewHeight());
     if (relayoutChildren) {
         layoutScope.setChildNeedsLayout(this);
-        for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
+        for (LayoutObject* child = firstChild(); child; child = child->nextSibling()) {
             if (child->isSVGRoot())
                 continue;
 
             if ((child->isBox() && toRenderBox(child)->hasRelativeLogicalHeight())
                     || child->style()->logicalHeight().isPercent()
                     || child->style()->logicalMinHeight().isPercent()
                     || child->style()->logicalMaxHeight().isPercent())
                 layoutScope.setChildNeedsLayout(child);
         }
 
@@ skipping 30 matching lines @@
     if ((mode & IsFixed) && m_frameView) {
         transformState.move(m_frameView->scrollOffsetForViewportConstrainedObjects());
         // IsFixed flag is only applicable within this RenderView.
         mode &= ~IsFixed;
     }
 
     if (paintInvalidationContainer == this)
         return;
 
     if (mode & TraverseDocumentBoundaries) {
-        if (RenderObject* parentDocRenderer = frame()->ownerRenderer()) {
+        if (LayoutObject* parentDocRenderer = frame()->ownerRenderer()) {
             transformState.move(-frame()->view()->scrollOffset());
             if (parentDocRenderer->isBox())
                 transformState.move(toRenderBox(parentDocRenderer)->contentBoxOffset());
             parentDocRenderer->mapLocalToContainer(paintInvalidationContainer, transformState, mode, wasFixed, paintInvalidationState);
             return;
         }
     }
 }
 
-const RenderObject* RenderView::pushMappingToContainer(const LayoutLayerModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
+const LayoutObject* RenderView::pushMappingToContainer(const LayoutLayerModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
 {
     LayoutSize offsetForFixedPosition;
     LayoutSize offset;
-    RenderObject* container = 0;
+    LayoutObject* container = 0;
 
     if (m_frameView)
         offsetForFixedPosition = LayoutSize(m_frameView->scrollOffsetForViewportConstrainedObjects());
 
     if (geometryMap.mapCoordinatesFlags() & TraverseDocumentBoundaries) {
         if (RenderPart* parentDocRenderer = frame()->ownerRenderer()) {
             offset = -LayoutSize(m_frameView->scrollOffset());
             offset += parentDocRenderer->contentBoxOffset();
             container = parentDocRenderer;
         }
@@ skipping 155 matching lines @@
     rects.append(pixelSnappedIntRect(accumulatedOffset, LayoutSize(layer()->size())));
 }
 
 void RenderView::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
 {
     if (wasFixed)
         *wasFixed = false;
     quads.append(FloatRect(FloatPoint(), layer()->size()));
 }
 
-static RenderObject* rendererAfterPosition(RenderObject* object, unsigned offset)
+static LayoutObject* rendererAfterPosition(LayoutObject* object, unsigned offset)
 {
     if (!object)
         return 0;
 
-    RenderObject* child = object->childAt(offset);
+    LayoutObject* child = object->childAt(offset);
     return child ? child : object->nextInPreOrderAfterChildren();
 }
 
-static LayoutRect selectionRectForRenderer(const RenderObject* object)
+static LayoutRect selectionRectForRenderer(const LayoutObject* object)
 {
     if (!object->isRooted())
         return LayoutRect();
 
     if (!object->canUpdateSelectionOnRootLineBoxes())
         return LayoutRect();
 
     return object->selectionRectForPaintInvalidation(object->containerForPaintInvalidation());
 }
 
 IntRect RenderView::selectionBounds()
 {
     // Now create a single bounding box rect that encloses the whole selection.
     LayoutRect selRect;
 
     typedef HashSet<const RenderBlock*> VisitedContainingBlockSet;
     VisitedContainingBlockSet visitedContainingBlocks;
 
     commitPendingSelection();
-    RenderObject* os = m_selectionStart;
-    RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
+    LayoutObject* os = m_selectionStart;
+    LayoutObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
     while (os && os != stop) {
         if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
             // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
             selRect.unite(selectionRectForRenderer(os));
             const RenderBlock* cb = os->containingBlock();
             while (cb && !cb->isRenderView()) {
                 selRect.unite(selectionRectForRenderer(cb));
                 VisitedContainingBlockSet::AddResult addResult = visitedContainingBlocks.add(cb);
                 if (!addResult.isNewEntry)
                     break;
                 cb = cb->containingBlock();
             }
         }
 
         os = os->nextInPreOrder();
     }
 
     return pixelSnappedIntRect(selRect);
 }
 
 void RenderView::invalidatePaintForSelection()
 {
     HashSet<RenderBlock*> processedBlocks;
 
-    RenderObject* end = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
-    for (RenderObject* o = m_selectionStart; o && o != end; o = o->nextInPreOrder()) {
+    LayoutObject* end = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
+    for (LayoutObject* o = m_selectionStart; o && o != end; o = o->nextInPreOrder()) {
         if (!o->canBeSelectionLeaf() && o != m_selectionStart && o != m_selectionEnd)
             continue;
         if (o->selectionState() == SelectionNone)
             continue;
 
         o->setShouldInvalidateSelection();
 
         // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
         for (RenderBlock* block = o->containingBlock(); block && !block->isRenderView(); block = block->containingBlock()) {
             if (!processedBlocks.add(block).isNewEntry)
                 break;
             block->setShouldInvalidateSelection();
         }
     }
 }
 
 // When exploring the RenderTree looking for the nodes involved in the Selection, sometimes it's
 // required to change the traversing direction because the "start" position is below the "end" one.
-static inline RenderObject* getNextOrPrevRenderObjectBasedOnDirection(const RenderObject* o, const RenderObject* stop, bool& continueExploring, bool& exploringBackwards)
+static inline LayoutObject* getNextOrPrevLayoutObjectBasedOnDirection(const LayoutObject* o, const LayoutObject* stop, bool& continueExploring, bool& exploringBackwards)
 {
-    RenderObject* next;
+    LayoutObject* next;
     if (exploringBackwards) {
         next = o->previousInPreOrder();
         continueExploring = next && !(next)->isRenderView();
     } else {
         next = o->nextInPreOrder();
         continueExploring = next && next != stop;
         exploringBackwards = !next && (next != stop);
         if (exploringBackwards) {
             next = stop->previousInPreOrder();
             continueExploring = next && !next->isRenderView();
         }
     }
 
     return next;
 }
 
-void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* end, int endPos, SelectionPaintInvalidationMode blockPaintInvalidationMode)
+void RenderView::setSelection(LayoutObject* start, int startPos, LayoutObject* end, int endPos, SelectionPaintInvalidationMode blockPaintInvalidationMode)
 {
     // This code makes no assumptions as to if the rendering tree is up to date or not
     // and will not try to update it. Currently clearSelection calls this
     // (intentionally) without updating the rendering tree as it doesn't care.
     // Other callers may want to force recalc style before calling this.
 
     // Make sure both our start and end objects are defined.
     // Check www.msnbc.com and try clicking around to find the case where this happened.
     if ((start && !end) || (end && !start))
         return;
 
     // Just return if the selection hasn't changed.
     if (m_selectionStart == start && m_selectionStartPos == startPos &&
         m_selectionEnd == end && m_selectionEndPos == endPos)
         return;
 
     // Record the old selected objects.  These will be used later
     // when we compare against the new selected objects.
     int oldStartPos = m_selectionStartPos;
     int oldEndPos = m_selectionEndPos;
 
     // Objects each have a single selection rect to examine.
-    typedef HashMap<RenderObject*, SelectionState> SelectedObjectMap;
+    typedef HashMap<LayoutObject*, SelectionState> SelectedObjectMap;
     SelectedObjectMap oldSelectedObjects;
     // FIXME: |newSelectedObjects| doesn't really need to store the SelectionState, it's just more convenient
     // to have it use the same data structure as |oldSelectedObjects|.
     SelectedObjectMap newSelectedObjects;
 
     // Blocks contain selected objects and fill gaps between them, either on the left, right, or in between lines and blocks.
     // In order to get the paint invalidation rect right, we have to examine left, middle, and right rects individually, since otherwise
     // the union of those rects might remain the same even when changes have occurred.
     typedef HashMap<RenderBlock*, SelectionState> SelectedBlockMap;
     SelectedBlockMap oldSelectedBlocks;
     // FIXME: |newSelectedBlocks| doesn't really need to store the SelectionState, it's just more convenient
     // to have it use the same data structure as |oldSelectedBlocks|.
     SelectedBlockMap newSelectedBlocks;
 
-    RenderObject* os = m_selectionStart;
-    RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
+    LayoutObject* os = m_selectionStart;
+    LayoutObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
     bool exploringBackwards = false;
     bool continueExploring = os && (os != stop);
     while (continueExploring) {
         if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
             // Blocks are responsible for painting line gaps and margin gaps.  They must be examined as well.
             oldSelectedObjects.set(os, os->selectionState());
             if (blockPaintInvalidationMode == PaintInvalidationNewXOROld) {
                 RenderBlock* cb = os->containingBlock();
                 while (cb && !cb->isRenderView()) {
                     SelectedBlockMap::AddResult result = oldSelectedBlocks.add(cb, cb->selectionState());
                     if (!result.isNewEntry)
                         break;
                     cb = cb->containingBlock();
                 }
             }
         }
 
-        os = getNextOrPrevRenderObjectBasedOnDirection(os, stop, continueExploring, exploringBackwards);
+        os = getNextOrPrevLayoutObjectBasedOnDirection(os, stop, continueExploring, exploringBackwards);
     }
 
     // Now clear the selection.
     SelectedObjectMap::iterator oldObjectsEnd = oldSelectedObjects.end();
     for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i)
         i->key->setSelectionStateIfNeeded(SelectionNone);
 
     // set selection start and end
     m_selectionStart = start;
     m_selectionStartPos = startPos;
     m_selectionEnd = end;
     m_selectionEndPos = endPos;
 
     // Update the selection status of all objects between m_selectionStart and m_selectionEnd
     if (start && start == end)
         start->setSelectionStateIfNeeded(SelectionBoth);
     else {
         if (start)
             start->setSelectionStateIfNeeded(SelectionStart);
         if (end)
             end->setSelectionStateIfNeeded(SelectionEnd);
     }
 
-    RenderObject* o = start;
+    LayoutObject* o = start;
     stop = rendererAfterPosition(end, endPos);
 
     while (o && o != stop) {
         if (o != start && o != end && o->canBeSelectionLeaf())
             o->setSelectionStateIfNeeded(SelectionInside);
         o = o->nextInPreOrder();
     }
 
     layer()->clearBlockSelectionGapsBounds();
 
     // Now that the selection state has been updated for the new objects, walk them again and
     // put them in the new objects list.
     o = start;
     exploringBackwards = false;
     continueExploring = o && (o != stop);
     while (continueExploring) {
         if ((o->canBeSelectionLeaf() || o == start || o == end) && o->selectionState() != SelectionNone) {
             newSelectedObjects.set(o, o->selectionState());
             RenderBlock* cb = o->containingBlock();
             while (cb && !cb->isRenderView()) {
                 SelectedBlockMap::AddResult result = newSelectedBlocks.add(cb, cb->selectionState());
                 if (!result.isNewEntry)
                     break;
                 cb = cb->containingBlock();
             }
         }
 
-        o = getNextOrPrevRenderObjectBasedOnDirection(o, stop, continueExploring, exploringBackwards);
+        o = getNextOrPrevLayoutObjectBasedOnDirection(o, stop, continueExploring, exploringBackwards);
     }
 
     if (!m_frameView)
         return;
 
     // Have any of the old selected objects changed compared to the new selection?
     for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i) {
-        RenderObject* obj = i->key;
+        LayoutObject* obj = i->key;
         SelectionState newSelectionState = obj->selectionState();
         SelectionState oldSelectionState = i->value;
         if (newSelectionState != oldSelectionState
             || (m_selectionStart == obj && oldStartPos != m_selectionStartPos)
             || (m_selectionEnd == obj && oldEndPos != m_selectionEndPos)) {
             obj->setShouldInvalidateSelection();
             newSelectedObjects.remove(obj);
         }
     }
 
@@ skipping 118 matching lines @@
         startPos = candidate;
     Position endPos = selection.end();
     candidate = endPos.upstream();
     if (candidate.isCandidate())
         endPos = candidate;
 
     // We can get into a state where the selection endpoints map to the same VisiblePosition when a selection is deleted
     // because we don't yet notify the FrameSelection of text removal.
     if (startPos.isNull() || endPos.isNull() || selection.visibleStart() == selection.visibleEnd())
         return;
-    RenderObject* startRenderer = startPos.anchorNode()->renderer();
-    RenderObject* endRenderer = endPos.anchorNode()->renderer();
+    LayoutObject* startRenderer = startPos.anchorNode()->renderer();
+    LayoutObject* endRenderer = endPos.anchorNode()->renderer();
     if (!startRenderer || !endRenderer)
         return;
     ASSERT(startRenderer->view() == this && endRenderer->view() == this);
     setSelection(startRenderer, startPos.deprecatedEditingOffset(), endRenderer, endPos.deprecatedEditingOffset());
 }
 
-RenderObject* RenderView::selectionStart()
+LayoutObject* RenderView::selectionStart()
 {
     commitPendingSelection();
     return m_selectionStart;
 }
 
-RenderObject* RenderView::selectionEnd()
+LayoutObject* RenderView::selectionEnd()
 {
     commitPendingSelection();
     return m_selectionEnd;
 }
 
 void RenderView::selectionStartEnd(int& startPos, int& endPos)
 {
     commitPendingSelection();
     startPos = m_selectionStartPos;
     endPos = m_selectionEndPos;
@@ skipping 17 matching lines @@
 
 IntRect RenderView::unscaledDocumentRect() const
 {
     LayoutRect overflowRect(layoutOverflowRect());
     flipForWritingMode(overflowRect);
     return pixelSnappedIntRect(overflowRect);
 }
 
 bool RenderView::rootBackgroundIsEntirelyFixed() const
 {
-    if (RenderObject* backgroundRenderer = this->backgroundRenderer())
+    if (LayoutObject* backgroundRenderer = this->backgroundRenderer())
         return backgroundRenderer->hasEntirelyFixedBackground();
     return false;
 }
 
-RenderObject* RenderView::backgroundRenderer() const
+LayoutObject* RenderView::backgroundRenderer() const
 {
     if (Element* documentElement = document().documentElement()) {
-        if (RenderObject* rootObject = documentElement->renderer())
+        if (LayoutObject* rootObject = documentElement->renderer())
             return rootObject->rendererForRootBackground();
     }
     return 0;
 }
 
 LayoutRect RenderView::backgroundRect(RenderBox* backgroundRenderer) const
 {
     if (!hasColumns())
         return unscaledDocumentRect();
 
@@ skipping 121 matching lines @@
 }
 
 void RenderView::invalidateDisplayItemClients(DisplayItemList* displayItemList) const
 {
     RenderBlockFlow::invalidateDisplayItemClients(displayItemList);
     if (m_frameView)
         displayItemList->invalidate(m_frameView->displayItemClient());
 }
 
 } // namespace blink