Improve grammar in some comments.

third_party/WebKit/Source/core/layout/LayoutTableSection.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, 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 544 matching lines @@
             spanningRowsHeight.rowHeight[row] = calcRowHeightHavingOnlySpanningCells(actualRow, accumulatedPositionIncrease, rowIndex + rowSpan, extraHeightToPropagate, rowsCountWithOnlySpanningCells);
             accumulatedPositionIncrease += spanningRowsHeight.rowHeight[row];
         }
         m_rowPos[actualRow + 1] += accumulatedPositionIncrease;
     }
 
     spanningRowsHeight.totalRowsHeight += accumulatedPositionIncrease;
 }
 
 // Distribute rowSpan cell height in rows those comes in rowSpan cell based on the ratio of row's height if
-// 1. RowSpan cell height is greater then the total height of rows in rowSpan cell
+// 1. RowSpan cell height is greater than the total height of rows in rowSpan cell
 void LayoutTableSection::distributeRowSpanHeightToRows(SpanningLayoutTableCells& rowSpanCells)
 {
     ASSERT(rowSpanCells.size());
 
     // 'rowSpanCells' list is already sorted based on the cells rowIndex in ascending order
     // Arrange row spanning cell in the order in which we need to process first.
     std::sort(rowSpanCells.begin(), rowSpanCells.end(), compareRowSpanCellsInHeightDistributionOrder);
 
     unsigned extraHeightToPropagate = 0;
     unsigned lastRowIndex = 0;
@@ skipping 12 matching lines @@
     for (unsigned i = 0; i < rowSpanCells.size(); i++) {
         LayoutTableCell* cell = rowSpanCells[i];
 
         unsigned rowIndex = cell->rowIndex();
 
         unsigned rowSpan = cell->rowSpan();
 
         unsigned spanningCellEndIndex = rowIndex + rowSpan;
         unsigned lastSpanningCellEndIndex = lastRowIndex + lastRowSpan;
 
-        // Only heightest spanning cell will distribute it's extra height in row if more then one spanning cells
-        // present at same level.
+        // Only the highest spanning cell will distribute its extra height in a row if more than one spanning cell
+        // is present at the same level.
         if (rowIndex == lastRowIndex && rowSpan == lastRowSpan)
             continue;
 
         int originalBeforePosition = m_rowPos[spanningCellEndIndex];
 
         // When 2 spanning cells are ending at same row index then while extra height distribution of first spanning
         // cell updates position of the last row so getting the original position of the last row in second spanning
         // cell need to reduce the height changed by first spanning cell.
         if (spanningCellEndIndex == lastSpanningCellEndIndex)
             originalBeforePosition -= extraHeightToPropagate;
@@ skipping 71 matching lines @@
     }
 
     if (extraHeightToPropagate) {
         // Apply changed height by rowSpan cells to rows present at the end of the table
         for (unsigned row = lastRowIndex + lastRowSpan + 1; row <= m_grid.size(); row++)
             m_rowPos[row] += extraHeightToPropagate;
     }
 }
 
 // Find out the baseline of the cell
-// If the cell's baseline is more then the row's baseline then the cell's baseline become the row's baseline
-// and if the row's baseline goes out of the row's boundries then adjust row height accordingly.
+// If the cell's baseline is more than the row's baseline then the cell's baseline become the row's baseline
+// and if the row's baseline goes out of the row's boundaries then adjust row height accordingly.
 void LayoutTableSection::updateBaselineForCell(LayoutTableCell* cell, unsigned row, int& baselineDescent)
 {
     if (!cell->isBaselineAligned())
         return;
 
     // Ignoring the intrinsic padding as it depends on knowing the row's baseline, which won't be accurate
     // until the end of this function.
     int baselinePosition = cell->cellBaselinePosition() - cell->intrinsicPaddingBefore();
     if (baselinePosition > cell->borderBefore() + (cell->paddingBefore() - cell->intrinsicPaddingBefore())) {
         m_grid[row].baseline = std::max(m_grid[row].baseline, baselinePosition);
@@ skipping 1022 matching lines @@
     // Repeating table headers are painted once per fragmentation page/column. This does not go through the regular fragmentation machinery,
     // so we need special code to expand the invalidation rect to contain all positions of the header in all columns.
     // Note that this is in flow thread coordinates, not visual coordinates. The enclosing LayoutFlowThread will convert to visual coordinates.
     if (table()->header() == this && hasRepeatingHeaderGroup())
         rect.setHeight(table()->logicalHeight());
     return LayoutTableBoxComponent::mapToVisualRectInAncestorSpace(ancestor, rect, flags);
 }
 
 
 } // namespace blink