Move rendering/RenderObject to layout/LayoutObject.

Source/core/layout/LayoutTable.cpp

 /*
  * Copyright (C) 1997 Martin Jones (mjones@kde.org)
  *           (C) 1997 Torben Weis (weis@kde.org)
  *           (C) 1998 Waldo Bastian (bastian@kde.org)
  *           (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 85 matching lines @@
             m_tableLayout = adoptPtr(new LayoutTableAlgorithmFixed(this));
         else
             m_tableLayout = adoptPtr(new LayoutTableAlgorithmAuto(this));
     }
 
     // If border was changed, invalidate collapsed borders cache.
     if (!needsLayout() && oldStyle && oldStyle->border() != style()->border())
         invalidateCollapsedBorders();
 }
 
-static inline void resetSectionPointerIfNotBefore(LayoutTableSection*& ptr, RenderObject* before)
+static inline void resetSectionPointerIfNotBefore(LayoutTableSection*& ptr, LayoutObject* before)
 {
     if (!before || !ptr)
         return;
-    RenderObject* o = before->previousSibling();
+    LayoutObject* o = before->previousSibling();
     while (o && o != ptr)
         o = o->previousSibling();
     if (!o)
         ptr = 0;
 }
 
-static inline bool needsTableSection(RenderObject* object)
+static inline bool needsTableSection(LayoutObject* object)
 {
     // Return true if 'object' can't exist in an anonymous table without being
     // wrapped in a table section box.
     EDisplay display = object->style()->display();
     return display != TABLE_CAPTION && display != TABLE_COLUMN_GROUP && display != TABLE_COLUMN;
 }
 
-void LayoutTable::addChild(RenderObject* child, RenderObject* beforeChild)
+void LayoutTable::addChild(LayoutObject* child, LayoutObject* beforeChild)
 {
     bool wrapInAnonymousSection = !child->isOutOfFlowPositioned();
 
     if (child->isTableCaption()) {
         wrapInAnonymousSection = false;
     } else if (child->isLayoutTableCol()) {
         m_hasColElements = true;
         wrapInAnonymousSection = false;
     } else if (child->isTableSection()) {
         switch (child->style()->display()) {
@@ skipping 39 matching lines @@
         RenderBox::addChild(child, beforeChild);
         return;
     }
 
     if (!beforeChild && lastChild() && lastChild()->isTableSection() && lastChild()->isAnonymous() && !lastChild()->isBeforeContent()) {
         lastChild()->addChild(child);
         return;
     }
 
     if (beforeChild && !beforeChild->isAnonymous() && beforeChild->parent() == this) {
-        RenderObject* section = beforeChild->previousSibling();
+        LayoutObject* section = beforeChild->previousSibling();
         if (section && section->isTableSection() && section->isAnonymous()) {
             section->addChild(child);
             return;
         }
     }
 
-    RenderObject* lastBox = beforeChild;
+    LayoutObject* lastBox = beforeChild;
     while (lastBox && lastBox->parent()->isAnonymous() && !lastBox->isTableSection() && needsTableSection(lastBox))
         lastBox = lastBox->parent();
     if (lastBox && lastBox->isAnonymous() && !isAfterContent(lastBox)) {
         if (beforeChild == lastBox)
             beforeChild = lastBox->slowFirstChild();
         lastBox->addChild(child, beforeChild);
         return;
     }
 
     if (beforeChild && !beforeChild->isTableSection() && needsTableSection(beforeChild))
         beforeChild = 0;
 
     LayoutTableSection* section = LayoutTableSection::createAnonymousWithParentRenderer(this);
     addChild(section, beforeChild);
     section->addChild(child);
 }
 
-void LayoutTable::addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild)
+void LayoutTable::addChildIgnoringContinuation(LayoutObject* newChild, LayoutObject* beforeChild)
 {
     // We need to bypass the RenderBlock implementation and instead do a normal addChild() (or we
     // won't get there at all), so that any missing anonymous table part renderers are
     // inserted. Otherwise we might end up with an insane render tree with inlines or blocks as
     // direct children of a table, which will break assumptions made all over the code, which may
     // lead to crashers and security issues.
     addChild(newChild, beforeChild);
 }
 
 void LayoutTable::addCaption(const LayoutTableCaption* caption)
@@ skipping 231 matching lines @@
         // if ( oldWidth != width() || columns.size() + 1 != columnPos.size() )
         m_tableLayout->layout();
 
         LayoutUnit totalSectionLogicalHeight = 0;
         LayoutUnit oldTableLogicalTop = 0;
         for (unsigned i = 0; i < m_captions.size(); i++)
             oldTableLogicalTop += m_captions[i]->logicalHeight() + m_captions[i]->marginBefore() + m_captions[i]->marginAfter();
 
         bool collapsing = collapseBorders();
 
-        for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
+        for (LayoutObject* child = firstChild(); child; child = child->nextSibling()) {
             if (child->isTableSection()) {
                 LayoutTableSection* section = toLayoutTableSection(child);
                 if (m_columnLogicalWidthChanged)
                     layouter.setChildNeedsLayout(section);
                 section->layoutIfNeeded();
                 totalSectionLogicalHeight += section->calcRowLogicalHeight();
                 if (collapsing)
                     section->recalcOuterBorder();
                 ASSERT(!section->needsLayout());
             } else if (child->isLayoutTableCol()) {
@@ skipping 109 matching lines @@
     clearNeedsLayout();
 }
 
 // Collect all the unique border values that we want to paint in a sorted list.
 void LayoutTable::recalcCollapsedBorders()
 {
     if (m_collapsedBordersValid)
         return;
     m_collapsedBordersValid = true;
     m_collapsedBorders.clear();
-    for (RenderObject* section = firstChild(); section; section = section->nextSibling()) {
+    for (LayoutObject* section = firstChild(); section; section = section->nextSibling()) {
         if (!section->isTableSection())
             continue;
         for (LayoutTableRow* row = toLayoutTableSection(section)->firstRow(); row; row = row->nextRow()) {
             for (LayoutTableCell* cell = row->firstCell(); cell; cell = cell->nextCell()) {
                 ASSERT(cell->table() == this);
                 cell->collectBorderValues(m_collapsedBorders);
             }
         }
     }
     LayoutTableCell::sortBorderValues(m_collapsedBorders);
@@ skipping 114 matching lines @@
 
 void LayoutTable::splitColumn(unsigned position, unsigned firstSpan)
 {
     // We split the column at "position", taking "firstSpan" cells from the span.
     ASSERT(m_columns[position].span > firstSpan);
     m_columns.insert(position, ColumnStruct(firstSpan));
     m_columns[position + 1].span -= firstSpan;
 
     // Propagate the change in our columns representation to the sections that don't need
     // cell recalc. If they do, they will be synced up directly with m_columns later.
-    for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
+    for (LayoutObject* child = firstChild(); child; child = child->nextSibling()) {
         if (!child->isTableSection())
             continue;
 
         LayoutTableSection* section = toLayoutTableSection(child);
         if (section->needsCellRecalc())
             continue;
 
         section->splitColumn(position, firstSpan);
     }
 
     m_columnPos.grow(numEffCols() + 1);
 }
 
 void LayoutTable::appendColumn(unsigned span)
 {
     unsigned newColumnIndex = m_columns.size();
     m_columns.append(ColumnStruct(span));
 
     // Unless the table has cell(s) with colspan that exceed the number of columns afforded
     // by the other rows in the table we can use the fast path when mapping columns to effective columns.
     m_hasCellColspanThatDeterminesTableWidth = m_hasCellColspanThatDeterminesTableWidth || span > 1;
 
     // Propagate the change in our columns representation to the sections that don't need
     // cell recalc. If they do, they will be synced up directly with m_columns later.
-    for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
+    for (LayoutObject* child = firstChild(); child; child = child->nextSibling()) {
         if (!child->isTableSection())
             continue;
 
         LayoutTableSection* section = toLayoutTableSection(child);
         if (section->needsCellRecalc())
             continue;
 
         section->appendColumn(newColumnIndex);
     }
 
     m_columnPos.grow(numEffCols() + 1);
 }
 
 LayoutTableCol* LayoutTable::firstColumn() const
 {
-    for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
+    for (LayoutObject* child = firstChild(); child; child = child->nextSibling()) {
         if (child->isLayoutTableCol())
             return toLayoutTableCol(child);
     }
 
     return 0;
 }
 
 void LayoutTable::updateColumnCache() const
 {
     ASSERT(m_hasColElements);
@@ skipping 38 matching lines @@
 {
     ASSERT(m_needsSectionRecalc);
 
     m_head = 0;
     m_foot = 0;
     m_firstBody = 0;
     m_hasColElements = false;
     m_hasCellColspanThatDeterminesTableWidth = hasCellColspanThatDeterminesTableWidth();
 
     // We need to get valid pointers to caption, head, foot and first body again
-    RenderObject* nextSibling;
-    for (RenderObject* child = firstChild(); child; child = nextSibling) {
+    LayoutObject* nextSibling;
+    for (LayoutObject* child = firstChild(); child; child = nextSibling) {
         nextSibling = child->nextSibling();
         switch (child->style()->display()) {
         case TABLE_COLUMN:
         case TABLE_COLUMN_GROUP:
             m_hasColElements = true;
             break;
         case TABLE_HEADER_GROUP:
             if (child->isTableSection()) {
                 LayoutTableSection* section = toLayoutTableSection(child);
                 if (!m_head)
@@ skipping 21 matching lines @@
                 section->recalcCellsIfNeeded();
             }
             break;
         default:
             break;
         }
     }
 
     // repair column count (addChild can grow it too much, because it always adds elements to the last row of a section)
     unsigned maxCols = 0;
-    for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
+    for (LayoutObject* child = firstChild(); child; child = child->nextSibling()) {
         if (child->isTableSection()) {
             LayoutTableSection* section = toLayoutTableSection(child);
             unsigned sectionCols = section->numColumns();
             if (sectionCols > maxCols)
                 maxCols = sectionCols;
         }
     }
 
     m_columns.resize(maxCols);
     m_columnPos.resize(maxCols + 1);
@@ skipping 228 matching lines @@
     return borderWidth;
 }
 
 LayoutTableSection* LayoutTable::sectionAbove(const LayoutTableSection* section, SkipEmptySectionsValue skipEmptySections) const
 {
     recalcSectionsIfNeeded();
 
     if (section == m_head)
         return 0;
 
-    RenderObject* prevSection = section == m_foot ? lastChild() : section->previousSibling();
+    LayoutObject* prevSection = section == m_foot ? lastChild() : section->previousSibling();
     while (prevSection) {
         if (prevSection->isTableSection() && prevSection != m_head && prevSection != m_foot && (skipEmptySections == DoNotSkipEmptySections || toLayoutTableSection(prevSection)->numRows()))
             break;
         prevSection = prevSection->previousSibling();
     }
     if (!prevSection && m_head && (skipEmptySections == DoNotSkipEmptySections || m_head->numRows()))
         prevSection = m_head;
     return toLayoutTableSection(prevSection);
 }
 
 LayoutTableSection* LayoutTable::sectionBelow(const LayoutTableSection* section, SkipEmptySectionsValue skipEmptySections) const
 {
     recalcSectionsIfNeeded();
 
     if (section == m_foot)
         return 0;
 
-    RenderObject* nextSection = section == m_head ? firstChild() : section->nextSibling();
+    LayoutObject* nextSection = section == m_head ? firstChild() : section->nextSibling();
     while (nextSection) {
         if (nextSection->isTableSection() && nextSection != m_head && nextSection != m_foot && (skipEmptySections  == DoNotSkipEmptySections || toLayoutTableSection(nextSection)->numRows()))
             break;
         nextSection = nextSection->nextSibling();
     }
     if (!nextSection && m_foot && (skipEmptySections == DoNotSkipEmptySections || m_foot->numRows()))
         nextSection = m_foot;
     return toLayoutTableSection(nextSection);
 }
 
 LayoutTableSection* LayoutTable::bottomSection() const
 {
     recalcSectionsIfNeeded();
 
     if (m_foot)
         return m_foot;
 
-    for (RenderObject* child = lastChild(); child; child = child->previousSibling()) {
+    for (LayoutObject* child = lastChild(); child; child = child->previousSibling()) {
         if (child->isTableSection())
             return toLayoutTableSection(child);
     }
 
     return 0;
 }
 
 LayoutTableCell* LayoutTable::cellAbove(const LayoutTableCell* cell) const
 {
     recalcSectionsIfNeeded();
@@ skipping 138 matching lines @@
 
     return rect;
 }
 
 bool LayoutTable::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction action)
 {
     LayoutPoint adjustedLocation = accumulatedOffset + location();
 
     // Check kids first.
     if (!hasOverflowClip() || locationInContainer.intersects(overflowClipRect(adjustedLocation))) {
-        for (RenderObject* child = lastChild(); child; child = child->previousSibling()) {
+        for (LayoutObject* child = lastChild(); child; child = child->previousSibling()) {
             if (child->isBox() && !toRenderBox(child)->hasSelfPaintingLayer() && (child->isTableSection() || child->isTableCaption())) {
                 LayoutPoint childPoint = flipForWritingModeForChild(toRenderBox(child), adjustedLocation);
                 if (child->nodeAtPoint(request, result, locationInContainer, childPoint, action)) {
                     updateHitTestResult(result, toLayoutPoint(locationInContainer.point() - childPoint));
                     return true;
                 }
             }
         }
     }
 
     // Check our bounds next.
     LayoutRect boundsRect(adjustedLocation, size());
     if (visibleToHitTestRequest(request) && (action == HitTestBlockBackground || action == HitTestChildBlockBackground) && locationInContainer.intersects(boundsRect)) {
         updateHitTestResult(result, flipForWritingMode(locationInContainer.point() - toLayoutSize(adjustedLocation)));
         if (!result.addNodeToRectBasedTestResult(node(), request, locationInContainer, boundsRect))
             return true;
     }
 
     return false;
 }
 
-LayoutTable* LayoutTable::createAnonymousWithParentRenderer(const RenderObject* parent)
+LayoutTable* LayoutTable::createAnonymousWithParentRenderer(const LayoutObject* parent)
 {
     RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(parent->style(), TABLE);
     LayoutTable* newTable = new LayoutTable(0);
     newTable->setDocumentForAnonymous(&parent->document());
     newTable->setStyle(newStyle.release());
     return newTable;
 }
 
 const BorderValue& LayoutTable::tableStartBorderAdjoiningCell(const LayoutTableCell* cell) const
 {
     ASSERT(cell->isFirstOrLastCellInRow());
     if (hasSameDirectionAs(cell->row()))
         return style()->borderStart();
 
     return style()->borderEnd();
 }
 
 const BorderValue& LayoutTable::tableEndBorderAdjoiningCell(const LayoutTableCell* cell) const
 {
     ASSERT(cell->isFirstOrLastCellInRow());
     if (hasSameDirectionAs(cell->row()))
         return style()->borderEnd();
 
     return style()->borderStart();
 }
 
 }