C++11: Replace 0 with nullptr where applicable in layout code.

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 34 matching lines @@
 #include "core/paint/BoxPainter.h"
 #include "core/paint/DeprecatedPaintLayer.h"
 #include "core/paint/TablePainter.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 LayoutTable::LayoutTable(Element* element)
     : LayoutBlock(element)
-    , m_head(0)
-    , m_foot(0)
-    , m_firstBody(0)
-    , m_currentBorder(0)
+    , m_head(nullptr)
+    , m_foot(nullptr)
+    , m_firstBody(nullptr)
+    , m_currentBorder(nullptr)
     , m_collapsedBordersValid(false)
     , m_hasColElements(false)
     , m_needsSectionRecalc(false)
     , m_columnLogicalWidthChanged(false)
     , m_columnLayoutObjectsValid(false)
     , m_hasCellColspanThatDeterminesTableWidth(false)
     , m_hSpacing(0)
     , m_vSpacing(0)
     , m_borderStart(0)
     , m_borderEnd(0)
@@ skipping 718 matching lines @@
     m_columnPos.grow(numEffCols() + 1);
 }
 
 LayoutTableCol* LayoutTable::firstColumn() const
 {
     for (LayoutObject* child = firstChild(); child; child = child->nextSibling()) {
         if (child->isLayoutTableCol())
             return toLayoutTableCol(child);
     }
 
-    return 0;
+    return nullptr;
 }
 
 void LayoutTable::updateColumnCache() const
 {
     ASSERT(m_hasColElements);
     ASSERT(m_columnLayoutObjects.isEmpty());
     ASSERT(!m_columnLayoutObjectsValid);
 
     for (LayoutTableCol* columnLayoutObject = firstColumn(); columnLayoutObject; columnLayoutObject = columnLayoutObject->nextColumn()) {
         if (columnLayoutObject->isTableColumnGroupWithColumnChildren())
@@ skipping 19 matching lines @@
         unsigned endCol = columnCount + span - 1;
         columnCount += span;
         if (columnCount > col) {
             if (startEdge)
                 *startEdge = startCol == col;
             if (endEdge)
                 *endEdge = endCol == col;
             return columnLayoutObject;
         }
     }
-    return 0;
+    return nullptr;
 }
 
 void LayoutTable::recalcSections() const
 {
     ASSERT(m_needsSectionRecalc);
 
-    m_head = 0;
-    m_foot = 0;
-    m_firstBody = 0;
+    m_head = nullptr;
+    m_foot = nullptr;
+    m_firstBody = nullptr;
     m_hasColElements = false;
     m_hasCellColspanThatDeterminesTableWidth = hasCellColspanThatDeterminesTableWidth();
 
     // We need to get valid pointers to caption, head, foot and first body again
     LayoutObject* nextSibling;
     for (LayoutObject* child = firstChild(); child; child = nextSibling) {
         nextSibling = child->nextSibling();
         switch (child->style()->display()) {
         case TABLE_COLUMN:
         case TABLE_COLUMN_GROUP:
@@ skipping 292 matching lines @@
     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;
+        return nullptr;
 
     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 (LayoutObject* child = lastChild(); child; child = child->previousSibling()) {
         if (child->isTableSection())
             return toLayoutTableSection(child);
     }
 
-    return 0;
+    return nullptr;
 }
 
 LayoutTableCell* LayoutTable::cellAbove(const LayoutTableCell* cell) const
 {
     recalcSectionsIfNeeded();
 
     // Find the section and row to look in
     unsigned r = cell->rowIndex();
-    LayoutTableSection* section = 0;
+    LayoutTableSection* section = nullptr;
     unsigned rAbove = 0;
     if (r > 0) {
         // cell is not in the first row, so use the above row in its own section
         section = cell->section();
         rAbove = r - 1;
     } else {
         section = sectionAbove(cell->section(), SkipEmptySections);
         if (section) {
             ASSERT(section->numRows());
             rAbove = section->numRows() - 1;
         }
     }
 
     // Look up the cell in the section's grid, which requires effective col index
     if (section) {
         unsigned effCol = colToEffCol(cell->col());
         LayoutTableSection::CellStruct& aboveCell = section->cellAt(rAbove, effCol);
         return aboveCell.primaryCell();
     }
-    return 0;
+    return nullptr;
 }
 
 LayoutTableCell* LayoutTable::cellBelow(const LayoutTableCell* cell) const
 {
     recalcSectionsIfNeeded();
 
     // Find the section and row to look in
     unsigned r = cell->rowIndex() + cell->rowSpan() - 1;
-    LayoutTableSection* section = 0;
+    LayoutTableSection* section = nullptr;
     unsigned rBelow = 0;
     if (r < cell->section()->numRows() - 1) {
         // The cell is not in the last row, so use the next row in the section.
         section = cell->section();
         rBelow = r + 1;
     } else {
         section = sectionBelow(cell->section(), SkipEmptySections);
         if (section)
             rBelow = 0;
     }
 
     // Look up the cell in the section's grid, which requires effective col index
     if (section) {
         unsigned effCol = colToEffCol(cell->col());
         LayoutTableSection::CellStruct& belowCell = section->cellAt(rBelow, effCol);
         return belowCell.primaryCell();
     }
-    return 0;
+    return nullptr;
 }
 
 LayoutTableCell* LayoutTable::cellBefore(const LayoutTableCell* cell) const
 {
     recalcSectionsIfNeeded();
 
     LayoutTableSection* section = cell->section();
     unsigned effCol = colToEffCol(cell->col());
     if (!effCol)
-        return 0;
+        return nullptr;
 
     // If we hit a colspan back up to a real cell.
     LayoutTableSection::CellStruct& prevCell = section->cellAt(cell->rowIndex(), effCol - 1);
     return prevCell.primaryCell();
 }
 
 LayoutTableCell* LayoutTable::cellAfter(const LayoutTableCell* cell) const
 {
     recalcSectionsIfNeeded();
 
     unsigned effCol = colToEffCol(cell->col() + cell->colSpan());
     if (effCol >= numEffCols())
-        return 0;
+        return nullptr;
     return cell->section()->primaryCellAt(cell->rowIndex(), effCol);
 }
 
 int LayoutTable::baselinePosition(FontBaseline baselineType, bool firstLine, LineDirectionMode direction, LinePositionMode linePositionMode) const
 {
     ASSERT(linePositionMode == PositionOnContainingLine);
     int baseline = firstLineBoxBaseline();
     if (baseline != -1) {
         if (isInline())
             return beforeMarginInLineDirection(direction) + baseline;
@@ skipping 83 matching lines @@
         if (!result.addNodeToListBasedTestResult(node(), locationInContainer, boundsRect))
             return true;
     }
 
     return false;
 }
 
 LayoutTable* LayoutTable::createAnonymousWithParent(const LayoutObject* parent)
 {
     RefPtr<ComputedStyle> newStyle = ComputedStyle::createAnonymousStyleWithDisplay(parent->styleRef(), TABLE);
-    LayoutTable* newTable = new LayoutTable(0);
+    LayoutTable* newTable = new LayoutTable(nullptr);
     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();
@@ skipping 38 matching lines @@
                         cell->invalidateDisplayItemClient(*cell);
                 }
             }
         }
     }
 
     LayoutBlock::invalidatePaintOfSubtreesIfNeeded(childPaintInvalidationState);
 }
 
 }