Revert of Paint collapsed borders of a table as one display item

third_party/WebKit/Source/core/paint/TableCellPainter.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/TableCellPainter.h"
 
 #include "core/layout/LayoutTableCell.h"
 #include "core/paint/BlockPainter.h"
 #include "core/paint/BoxPainter.h"
 #include "core/paint/LayoutObjectDrawingRecorder.h"
 #include "core/paint/ObjectPainter.h"
 #include "core/paint/PaintInfo.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
 
 namespace blink {
 
 static const CollapsedBorderValue& collapsedLeftBorder(
     const ComputedStyle& styleForCellFlow,
     const LayoutTableCell::CollapsedBorderValues& values) {
   if (styleForCellFlow.isHorizontalWritingMode()) {
-    return styleForCellFlow.isLeftToRightDirection() ? values.startBorder
-                                                     : values.endBorder;
+    return styleForCellFlow.isLeftToRightDirection() ? values.startBorder()
+                                                     : values.endBorder();
   }
-  return styleForCellFlow.isFlippedBlocksWritingMode() ? values.afterBorder
-                                                       : values.beforeBorder;
+  return styleForCellFlow.isFlippedBlocksWritingMode() ? values.afterBorder()
+                                                       : values.beforeBorder();
 }
 
 static const CollapsedBorderValue& collapsedRightBorder(
     const ComputedStyle& styleForCellFlow,
     const LayoutTableCell::CollapsedBorderValues& values) {
   if (styleForCellFlow.isHorizontalWritingMode()) {
-    return styleForCellFlow.isLeftToRightDirection() ? values.endBorder
-                                                     : values.startBorder;
+    return styleForCellFlow.isLeftToRightDirection() ? values.endBorder()
+                                                     : values.startBorder();
   }
-  return styleForCellFlow.isFlippedBlocksWritingMode() ? values.beforeBorder
-                                                       : values.afterBorder;
+  return styleForCellFlow.isFlippedBlocksWritingMode() ? values.beforeBorder()
+                                                       : values.afterBorder();
 }
 
 static const CollapsedBorderValue& collapsedTopBorder(
     const ComputedStyle& styleForCellFlow,
     const LayoutTableCell::CollapsedBorderValues& values) {
   if (styleForCellFlow.isHorizontalWritingMode())
-    return values.beforeBorder;
-  return styleForCellFlow.isLeftToRightDirection() ? values.startBorder
-                                                   : values.endBorder;
+    return values.beforeBorder();
+  return styleForCellFlow.isLeftToRightDirection() ? values.startBorder()
+                                                   : values.endBorder();
 }
 
 static const CollapsedBorderValue& collapsedBottomBorder(
     const ComputedStyle& styleForCellFlow,
     const LayoutTableCell::CollapsedBorderValues& values) {
   if (styleForCellFlow.isHorizontalWritingMode())
-    return values.afterBorder;
-  return styleForCellFlow.isLeftToRightDirection() ? values.endBorder
-                                                   : values.startBorder;
+    return values.afterBorder();
+  return styleForCellFlow.isLeftToRightDirection() ? values.endBorder()
+                                                   : values.startBorder();
 }
 
 void TableCellPainter::paint(const PaintInfo& paintInfo,
                              const LayoutPoint& paintOffset) {
   BlockPainter(m_layoutTableCell).paint(paintInfo, paintOffset);
 }
 
 static EBorderStyle collapsedBorderStyle(EBorderStyle style) {
   if (style == BorderStyleOutset)
     return BorderStyleGroove;
   if (style == BorderStyleInset)
     return BorderStyleRidge;
   return style;
 }
 
+const DisplayItemClient& TableCellPainter::displayItemClientForBorders() const {
+  // TODO(wkorman): We may need to handle PaintInvalidationDelayedFull.
+  // http://crbug.com/657186
+  return m_layoutTableCell.usesTableAsAdditionalDisplayItemClient()
+             ? static_cast<const DisplayItemClient&>(
+                   *m_layoutTableCell.collapsedBorderValues())
+             : m_layoutTableCell;
+}
+
 void TableCellPainter::paintCollapsedBorders(
     const PaintInfo& paintInfo,
     const LayoutPoint& paintOffset,
     const CollapsedBorderValue& currentBorderValue) {
   if (m_layoutTableCell.style()->visibility() != EVisibility::Visible)
     return;
 
   LayoutPoint adjustedPaintOffset = paintOffset + m_layoutTableCell.location();
   if (!BlockPainter(m_layoutTableCell)
            .intersectsPaintRect(paintInfo, adjustedPaintOffset))
     return;
 
   const LayoutTableCell::CollapsedBorderValues* values =
       m_layoutTableCell.collapsedBorderValues();
   if (!values)
     return;
 
   const ComputedStyle& styleForCellFlow = m_layoutTableCell.styleForCellFlow();
   const CollapsedBorderValue& leftBorderValue =
       collapsedLeftBorder(styleForCellFlow, *values);
   const CollapsedBorderValue& rightBorderValue =
       collapsedRightBorder(styleForCellFlow, *values);
   const CollapsedBorderValue& topBorderValue =
       collapsedTopBorder(styleForCellFlow, *values);
   const CollapsedBorderValue& bottomBorderValue =
       collapsedBottomBorder(styleForCellFlow, *values);
 
+  int displayItemType = DisplayItem::kTableCollapsedBorderBase;
+  if (topBorderValue.shouldPaint(currentBorderValue))
+    displayItemType |= DisplayItem::TableCollapsedBorderTop;
+  if (bottomBorderValue.shouldPaint(currentBorderValue))
+    displayItemType |= DisplayItem::TableCollapsedBorderBottom;
+  if (leftBorderValue.shouldPaint(currentBorderValue))
+    displayItemType |= DisplayItem::TableCollapsedBorderLeft;
+  if (rightBorderValue.shouldPaint(currentBorderValue))
+    displayItemType |= DisplayItem::TableCollapsedBorderRight;
+  if (displayItemType == DisplayItem::kTableCollapsedBorderBase)
+    return;
+
   int topWidth = topBorderValue.width();
   int bottomWidth = bottomBorderValue.width();
   int leftWidth = leftBorderValue.width();
   int rightWidth = rightBorderValue.width();
 
   // Adjust our x/y/width/height so that we paint the collapsed borders at the
   // correct location.
   LayoutRect paintRect =
       paintRectNotIncludingVisualOverflow(adjustedPaintOffset);
   IntRect borderRect = pixelSnappedIntRect(
       paintRect.x() - leftWidth / 2, paintRect.y() - topWidth / 2,
       paintRect.width() + leftWidth / 2 + (rightWidth + 1) / 2,
       paintRect.height() + topWidth / 2 + (bottomWidth + 1) / 2);
 
   GraphicsContext& graphicsContext = paintInfo.context;
+  const DisplayItemClient& client = displayItemClientForBorders();
+  if (DrawingRecorder::useCachedDrawingIfPossible(
+          graphicsContext, client,
+          static_cast<DisplayItem::Type>(displayItemType)))
+    return;
+
+  DrawingRecorder recorder(graphicsContext, client,
+                           static_cast<DisplayItem::Type>(displayItemType),
+                           borderRect);
   Color cellColor = m_layoutTableCell.resolveColor(CSSPropertyColor);
 
   // We never paint diagonals at the joins.  We simply let the border with the
   // highest precedence paint on top of borders with lower precedence.
-  if (topBorderValue.shouldPaint(currentBorderValue)) {
+  if (displayItemType & DisplayItem::TableCollapsedBorderTop) {
     ObjectPainter::drawLineForBoxSide(
         graphicsContext, borderRect.x(), borderRect.y(), borderRect.maxX(),
         borderRect.y() + topWidth, BSTop,
         topBorderValue.color().resolve(cellColor),
         collapsedBorderStyle(topBorderValue.style()), 0, 0, true);
   }
-  if (bottomBorderValue.shouldPaint(currentBorderValue)) {
+  if (displayItemType & DisplayItem::TableCollapsedBorderBottom) {
     ObjectPainter::drawLineForBoxSide(
         graphicsContext, borderRect.x(), borderRect.maxY() - bottomWidth,
         borderRect.maxX(), borderRect.maxY(), BSBottom,
         bottomBorderValue.color().resolve(cellColor),
         collapsedBorderStyle(bottomBorderValue.style()), 0, 0, true);
   }
-  if (leftBorderValue.shouldPaint(currentBorderValue)) {
+  if (displayItemType & DisplayItem::TableCollapsedBorderLeft) {
     ObjectPainter::drawLineForBoxSide(
         graphicsContext, borderRect.x(), borderRect.y(),
         borderRect.x() + leftWidth, borderRect.maxY(), BSLeft,
         leftBorderValue.color().resolve(cellColor),
         collapsedBorderStyle(leftBorderValue.style()), 0, 0, true);
   }
-  if (rightBorderValue.shouldPaint(currentBorderValue)) {
+  if (displayItemType & DisplayItem::TableCollapsedBorderRight) {
     ObjectPainter::drawLineForBoxSide(
         graphicsContext, borderRect.maxX() - rightWidth, borderRect.y(),
         borderRect.maxX(), borderRect.maxY(), BSRight,
         rightBorderValue.color().resolve(cellColor),
         collapsedBorderStyle(rightBorderValue.style()), 0, 0, true);
   }
 }
 
 void TableCellPainter::paintContainerBackgroundBehindCell(
     const PaintInfo& paintInfo,
@@ skipping 119 matching lines @@
   BoxPainter(m_layoutTableCell).paintMaskImages(paintInfo, paintRect);
 }
 
 LayoutRect TableCellPainter::paintRectNotIncludingVisualOverflow(
     const LayoutPoint& paintOffset) {
   return LayoutRect(paintOffset,
                     LayoutSize(m_layoutTableCell.pixelSnappedSize()));
 }
 
 }  // namespace blink