Paint collapsed borders of a table as one display item

third_party/WebKit/Source/core/paint/TableSectionPainter.cpp

 // Copyright 2014 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/paint/TableSectionPainter.h"
 
 #include "core/layout/LayoutTableCell.h"
 #include "core/layout/LayoutTableCol.h"
 #include "core/layout/LayoutTableRow.h"
 #include "core/paint/BoxClipper.h"
@@ skipping 123 matching lines @@
 // properly issue paint invalidations.
 static inline bool compareCellPositionsWithOverflowingCells(
     LayoutTableCell* elem1,
     LayoutTableCell* elem2) {
   if (elem1->rowIndex() != elem2->rowIndex())
     return elem1->rowIndex() < elem2->rowIndex();
 
   return elem1->absoluteColumnIndex() < elem2->absoluteColumnIndex();
 }
 
-void TableSectionPainter::paintCollapsedBorders(
+PaintResult TableSectionPainter::paintCollapsedBorders(
     const PaintInfo& paintInfo,
     const LayoutPoint& paintOffset,
     const CollapsedBorderValue& currentBorderValue) {
-  paintCollapsedSectionBorders(paintInfo, paintOffset, currentBorderValue);
+  PaintResult result =
+      paintCollapsedSectionBorders(paintInfo, paintOffset, currentBorderValue);
   LayoutTable* table = m_layoutTableSection.table();
-  if (table->header() == m_layoutTableSection)
+  if (table->header() == m_layoutTableSection) {
     paintRepeatingHeaderGroup(paintInfo, paintOffset, currentBorderValue,
                               PaintCollapsedBorders);
+  }
+  return result;
 }
 
-void TableSectionPainter::paintCollapsedSectionBorders(
+PaintResult TableSectionPainter::paintCollapsedSectionBorders(
     const PaintInfo& paintInfo,
     const LayoutPoint& paintOffset,
     const CollapsedBorderValue& currentBorderValue) {
   if (!m_layoutTableSection.numRows() ||
       !m_layoutTableSection.table()->effectiveColumns().size())
-    return;
+    return FullyPainted;
 
   LayoutPoint adjustedPaintOffset =
       paintOffset + m_layoutTableSection.location();
   BoxClipper boxClipper(m_layoutTableSection, paintInfo, adjustedPaintOffset,
                         ForceContentsClip);
 
   LayoutRect localVisualRect = LayoutRect(paintInfo.cullRect().m_rect);
   localVisualRect.moveBy(-adjustedPaintOffset);
 
   LayoutRect tableAlignedRect =
       m_layoutTableSection.logicalRectForWritingModeAndDirection(
           localVisualRect);
 
   CellSpan dirtiedRows = m_layoutTableSection.dirtiedRows(tableAlignedRect);
   CellSpan dirtiedColumns =
       m_layoutTableSection.dirtiedEffectiveColumns(tableAlignedRect);
 
   if (dirtiedColumns.start() >= dirtiedColumns.end())
-    return;
+    return MayBeClippedByPaintDirtyRect;
 
   // Collapsed borders are painted from the bottom right to the top left so that
   // precedence due to cell position is respected.
   for (unsigned r = dirtiedRows.end(); r > dirtiedRows.start(); r--) {
     unsigned row = r - 1;
     for (unsigned c = dirtiedColumns.end(); c > dirtiedColumns.start(); c--) {
       unsigned col = c - 1;
       const LayoutTableSection::CellStruct& current =
           m_layoutTableSection.cellAt(row, col);
       const LayoutTableCell* cell = current.primaryCell();
       if (!cell || (row > dirtiedRows.start() &&
                     m_layoutTableSection.primaryCellAt(row - 1, col) == cell) ||
           (col > dirtiedColumns.start() &&
            m_layoutTableSection.primaryCellAt(row, col - 1) == cell))
         continue;
       LayoutPoint cellPoint = m_layoutTableSection.flipForWritingModeForChild(
           cell, adjustedPaintOffset);
       TableCellPainter(*cell).paintCollapsedBorders(paintInfo, cellPoint,
                                                     currentBorderValue);
     }
   }
+
+  if (dirtiedRows == m_layoutTableSection.fullTableRowSpan() &&
+      dirtiedColumns == m_layoutTableSection.fullTableEffectiveColumnSpan())
+    return FullyPainted;
+  return MayBeClippedByPaintDirtyRect;
 }
 
 void TableSectionPainter::paintObject(const PaintInfo& paintInfo,
                                       const LayoutPoint& paintOffset) {
   LayoutRect localVisualRect = LayoutRect(paintInfo.cullRect().m_rect);
   localVisualRect.moveBy(-paintOffset);
 
   LayoutRect tableAlignedRect =
       m_layoutTableSection.logicalRectForWritingModeAndDirection(
           localVisualRect);
@@ skipping 179 matching lines @@
   LayoutRect bounds = BoxPainter(m_layoutTableSection)
                           .boundsForDrawingRecorder(paintInfo, paintOffset);
   LayoutObjectDrawingRecorder recorder(paintInfo.context, m_layoutTableSection,
                                        type, bounds);
   BoxPainter::paintBoxShadow(
       paintInfo, LayoutRect(paintOffset, m_layoutTableSection.size()),
       m_layoutTableSection.styleRef(), shadowStyle);
 }
 
 }  // namespace blink