Replace ASSERT with DCHECK in core/layout/ excluding subdirs

third_party/WebKit/Source/core/layout/ColumnBalancer.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/ColumnBalancer.h"
 
 #include "core/layout/LayoutMultiColumnFlowThread.h"
 #include "core/layout/LayoutMultiColumnSet.h"
 #include "core/layout/api/LineLayoutBlockFlow.h"
 
 namespace blink {
 
 ColumnBalancer::ColumnBalancer(const LayoutMultiColumnSet& columnSet,
                                LayoutUnit logicalTopInFlowThread,
                                LayoutUnit logicalBottomInFlowThread)
     : m_columnSet(columnSet),
       m_logicalTopInFlowThread(logicalTopInFlowThread),
       m_logicalBottomInFlowThread(logicalBottomInFlowThread) {
   DCHECK_GE(columnSet.usedColumnCount(), 1U);
 }
 
 void ColumnBalancer::traverse() {
   traverseSubtree(*columnSet().flowThread());
-  ASSERT(!flowThreadOffset());
+  DCHECK(!flowThreadOffset());
 }
 
 void ColumnBalancer::traverseSubtree(const LayoutBox& box) {
   if (box.childrenInline() && box.isLayoutBlockFlow()) {
     // Look for breaks between lines.
     traverseLines(toLayoutBlockFlow(box));
   }
 
   // Look for breaks between and inside block-level children. Even if this is a
   // block flow with inline children, there may be interesting floats to examine
@@ skipping 201 matching lines @@
 
 void InitialColumnHeightFinder::examineLine(const RootInlineBox& line) {
   LayoutUnit lineTop = line.lineTopWithLeading();
   LayoutUnit lineTopInFlowThread = flowThreadOffset() + lineTop;
   LayoutUnit minimumLogialHeight =
       columnLogicalHeightRequirementForLine(line.block().styleRef(), line);
   if (lineTopInFlowThread < LayoutUnit())
     minimumLogialHeight += lineTopInFlowThread;
   m_tallestUnbreakableLogicalHeight =
       std::max(m_tallestUnbreakableLogicalHeight, minimumLogialHeight);
-  ASSERT(
+  DCHECK(
       isFirstAfterBreak(lineTopInFlowThread) || !line.paginationStrut() ||
       !isLogicalTopWithinBounds(lineTopInFlowThread - line.paginationStrut()));
   if (isFirstAfterBreak(lineTopInFlowThread) &&
       m_lastBreakSeen != lineTopInFlowThread) {
     m_lastBreakSeen = lineTopInFlowThread;
     recordStrutBeforeOffset(lineTopInFlowThread, line.paginationStrut());
   }
 }
 
 void InitialColumnHeightFinder::recordStrutBeforeOffset(
     LayoutUnit offsetInFlowThread,
     LayoutUnit strut) {
   unsigned columnCount = columnSet().usedColumnCount();
-  ASSERT(m_shortestStruts.size() == columnCount);
+  DCHECK_EQ(m_shortestStruts.size(), columnCount);
   unsigned index = groupAtOffset(offsetInFlowThread)
                        .columnIndexAtOffset(offsetInFlowThread - strut,
                                             LayoutBox::AssociateWithFormerPage);
   if (index >= columnCount)
     return;
   m_shortestStruts[index] = std::min(m_shortestStruts[index], strut);
 }
 
 LayoutUnit InitialColumnHeightFinder::spaceUsedByStrutsAt(
     LayoutUnit offsetInFlowThread) const {
   unsigned stopBeforeColumn =
       groupAtOffset(offsetInFlowThread)
           .columnIndexAtOffset(offsetInFlowThread,
                                LayoutBox::AssociateWithLatterPage) +
       1;
   stopBeforeColumn = std::min(stopBeforeColumn, columnSet().usedColumnCount());
-  ASSERT(stopBeforeColumn <= m_shortestStruts.size());
+  DCHECK_LE(stopBeforeColumn, m_shortestStruts.size());
   LayoutUnit totalStrutSpace;
   for (unsigned i = 0; i < stopBeforeColumn; i++) {
     if (m_shortestStruts[i] != LayoutUnit::max())
       totalStrutSpace += m_shortestStruts[i];
   }
   return totalStrutSpace;
 }
 
 void InitialColumnHeightFinder::addContentRun(
     LayoutUnit endOffsetInFlowThread) {
@@ skipping 13 matching lines @@
       return;
   }
   m_contentRuns.push_back(ContentRun(endOffsetInFlowThread));
 }
 
 unsigned InitialColumnHeightFinder::contentRunIndexWithTallestColumns() const {
   unsigned indexWithLargestHeight = 0;
   LayoutUnit largestHeight;
   LayoutUnit previousOffset = logicalTopInFlowThread();
   size_t runCount = m_contentRuns.size();
-  ASSERT(runCount);
+  DCHECK(runCount);
   for (size_t i = firstContentRunIndexInLastRow(); i < runCount; i++) {
     const ContentRun& run = m_contentRuns[i];
     LayoutUnit height = run.columnLogicalHeight(previousOffset);
     if (largestHeight < height) {
       largestHeight = height;
       indexWithLargestHeight = i;
     }
     previousOffset = run.breakOffset();
   }
   return indexWithLargestHeight;
@@ skipping 144 matching lines @@
     // The previous break was before a breakable block. Here's the first line
     // after / inside that block. We want to record the distance from the top of
     // the column to the bottom of this box as space shortage.
     LayoutUnit logicalOffsetFromCurrentColumn =
         offsetFromColumnLogicalTop(lineTopInFlowThread);
     recordSpaceShortage(logicalOffsetFromCurrentColumn + lineHeight -
                         m_pendingStrut);
     m_pendingStrut = LayoutUnit::min();
     return;
   }
-  ASSERT(
+  DCHECK(
       isFirstAfterBreak(lineTopInFlowThread) || !line.paginationStrut() ||
       !isLogicalTopWithinBounds(lineTopInFlowThread - line.paginationStrut()));
   if (isFirstAfterBreak(lineTopInFlowThread))
     recordSpaceShortage(lineHeight - line.paginationStrut());
 
   // Even if the line box itself fits fine inside a column, some content may
   // overflow the line box bottom (due to restrictive line-height, for
   // instance). We should check if some portion of said overflow ends up in the
   // next column. That counts as space shortage.
   const MultiColumnFragmentainerGroup& group =
       groupAtOffset(lineTopInFlowThread);
   LayoutUnit lineBottomWithOverflow =
       lineTopInFlowThread + line.lineBottom() - lineTop;
   if (group.columnLogicalTopForOffset(lineTopInFlowThread) !=
       group.columnLogicalTopForOffset(lineBottomWithOverflow)) {
     LayoutUnit shortage =
         lineBottomWithOverflow -
         group.columnLogicalTopForOffset(lineBottomWithOverflow);
     recordSpaceShortage(shortage);
   }
 }
 
 }  // namespace blink