Replace DCHECK with DCHECK_op and split some DCHECKs wherever necessary

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

 // Copyright 2017 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/Grid.h"
 
 #include "core/layout/LayoutGrid.h"
 
 namespace blink {
 
@@ skipping 13 matching lines @@
       m_grid[row].grow(numTracks(ForColumns));
   }
 
   if (maximumColumnSize > numTracks(ForColumns)) {
     for (size_t row = 0; row < numTracks(ForRows); ++row)
       m_grid[row].grow(maximumColumnSize);
   }
 }
 
 void Grid::insert(LayoutBox& child, const GridArea& area) {
-  DCHECK(area.rows.isTranslatedDefinite() &&
-         area.columns.isTranslatedDefinite());
+  DCHECK(area.rows.isTranslatedDefinite());
+  DCHECK(area.columns.isTranslatedDefinite());
   ensureGridSize(area.rows.endLine(), area.columns.endLine());
 
   for (const auto& row : area.rows) {
     for (const auto& column : area.columns)
       m_grid[row][column].push_back(&child);
   }
 
   setGridItemArea(child, area);
 }
 
@@ skipping 111 matching lines @@
                            size_t varyingTrackIndex)
     : m_grid(grid.m_grid),
       m_direction(direction),
       m_rowIndex((direction == ForColumns) ? varyingTrackIndex
                                            : fixedTrackIndex),
       m_columnIndex((direction == ForColumns) ? fixedTrackIndex
                                               : varyingTrackIndex),
       m_childIndex(0) {
   DCHECK(!m_grid.isEmpty());
   DCHECK(!m_grid[0].isEmpty());
-  DCHECK(m_rowIndex < m_grid.size());
-  DCHECK(m_columnIndex < m_grid[0].size());
+  DCHECK_LT(m_rowIndex, m_grid.size());
+  DCHECK_LT(m_columnIndex, m_grid[0].size());
 }
 
 LayoutBox* GridIterator::nextGridItem() {
   DCHECK(!m_grid.isEmpty());
   DCHECK(!m_grid[0].isEmpty());
 
   size_t& varyingTrackIndex =
       (m_direction == ForColumns) ? m_rowIndex : m_columnIndex;
   const size_t endOfVaryingTrackIndex =
       (m_direction == ForColumns) ? m_grid.size() : m_grid[0].size();
@@ skipping 26 matching lines @@
   }
 
   return true;
 }
 
 std::unique_ptr<GridArea> GridIterator::nextEmptyGridArea(
     size_t fixedTrackSpan,
     size_t varyingTrackSpan) {
   DCHECK(!m_grid.isEmpty());
   DCHECK(!m_grid[0].isEmpty());
-  DCHECK(fixedTrackSpan >= 1 && varyingTrackSpan >= 1);
+  DCHECK_GE(fixedTrackSpan, 1u);
+  DCHECK_GE(varyingTrackSpan, 1u);
 
   size_t rowSpan =
       (m_direction == ForColumns) ? varyingTrackSpan : fixedTrackSpan;
   size_t columnSpan =
       (m_direction == ForColumns) ? fixedTrackSpan : varyingTrackSpan;
 
   size_t& varyingTrackIndex =
       (m_direction == ForColumns) ? m_rowIndex : m_columnIndex;
   const size_t endOfVaryingTrackIndex =
       (m_direction == ForColumns) ? m_grid.size() : m_grid[0].size();
   for (; varyingTrackIndex < endOfVaryingTrackIndex; ++varyingTrackIndex) {
     if (checkEmptyCells(rowSpan, columnSpan)) {
       std::unique_ptr<GridArea> result = WTF::wrapUnique(
           new GridArea(GridSpan::translatedDefiniteGridSpan(
                            m_rowIndex, m_rowIndex + rowSpan),
                        GridSpan::translatedDefiniteGridSpan(
                            m_columnIndex, m_columnIndex + columnSpan)));
       // Advance the iterator to avoid an infinite loop where we would return
       // the same grid area over and over.
       ++varyingTrackIndex;
       return result;
     }
   }
   return nullptr;
 }
 
 }  // namespace blink