Optimize collapsed border painting

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/PaintInfo.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 
 namespace blink {
 
-inline const CollapsedBorderValue* TableCellPainter::cachedCollapsedLeftBorder(const ComputedStyle& styleForCellFlow) const
+static const CollapsedBorderValue& collapsedLeftBorder(const ComputedStyle& styleForCellFlow, const LayoutTableCell::CollapsedBorderValues& values)
 {
-    if (styleForCellFlow.isHorizontalWritingMode()) {
-        return styleForCellFlow.isLeftToRightDirection()
-            ? m_layoutTableCell.section()->cachedCollapsedBorder(&m_layoutTableCell, CBSStart)
-            : m_layoutTableCell.section()->cachedCollapsedBorder(&m_layoutTableCell, CBSEnd);
-    }
-    return styleForCellFlow.isFlippedBlocksWritingMode()
-        ? m_layoutTableCell.section()->cachedCollapsedBorder(&m_layoutTableCell, CBSAfter)
-        : m_layoutTableCell.section()->cachedCollapsedBorder(&m_layoutTableCell, CBSBefore);
+    if (styleForCellFlow.isHorizontalWritingMode())
+        return styleForCellFlow.isLeftToRightDirection() ? values.startBorder : values.endBorder;
+    return styleForCellFlow.isFlippedBlocksWritingMode() ? values.afterBorder : values.beforeBorder;
 }
 
-inline const CollapsedBorderValue* TableCellPainter::cachedCollapsedRightBorder(const ComputedStyle& styleForCellFlow) const
+static const CollapsedBorderValue& collapsedRightBorder(const ComputedStyle& styleForCellFlow, const LayoutTableCell::CollapsedBorderValues& values)
 {
-    if (styleForCellFlow.isHorizontalWritingMode()) {
-        return styleForCellFlow.isLeftToRightDirection()
-            ? m_layoutTableCell.section()->cachedCollapsedBorder(&m_layoutTableCell, CBSEnd)
-            : m_layoutTableCell.section()->cachedCollapsedBorder(&m_layoutTableCell, CBSStart);
-    }
-    return styleForCellFlow.isFlippedBlocksWritingMode()
-        ? m_layoutTableCell.section()->cachedCollapsedBorder(&m_layoutTableCell, CBSBefore)
-        : m_layoutTableCell.section()->cachedCollapsedBorder(&m_layoutTableCell, CBSAfter);
+    if (styleForCellFlow.isHorizontalWritingMode())
+        return styleForCellFlow.isLeftToRightDirection() ? values.endBorder : values.startBorder;
+    return styleForCellFlow.isFlippedBlocksWritingMode() ? values.beforeBorder : values.afterBorder;
 }
 
-inline const CollapsedBorderValue* TableCellPainter::cachedCollapsedTopBorder(const ComputedStyle& styleForCellFlow) const
+static const CollapsedBorderValue& collapsedTopBorder(const ComputedStyle& styleForCellFlow, const LayoutTableCell::CollapsedBorderValues& values)
 {
     if (styleForCellFlow.isHorizontalWritingMode())
-        return m_layoutTableCell.section()->cachedCollapsedBorder(&m_layoutTableCell, CBSBefore);
-    return styleForCellFlow.isLeftToRightDirection()
-        ? m_layoutTableCell.section()->cachedCollapsedBorder(&m_layoutTableCell, CBSStart)
-        : m_layoutTableCell.section()->cachedCollapsedBorder(&m_layoutTableCell, CBSEnd);
+        return values.beforeBorder;
+    return styleForCellFlow.isLeftToRightDirection() ? values.startBorder : values.endBorder;
 }
 
-inline const CollapsedBorderValue* TableCellPainter::cachedCollapsedBottomBorder(const ComputedStyle& styleForCellFlow) const
+static const CollapsedBorderValue& collapsedBottomBorder(const ComputedStyle& styleForCellFlow, const LayoutTableCell::CollapsedBorderValues& values)
 {
     if (styleForCellFlow.isHorizontalWritingMode())
-        return m_layoutTableCell.section()->cachedCollapsedBorder(&m_layoutTableCell, CBSAfter);
-    return styleForCellFlow.isLeftToRightDirection()
-        ? m_layoutTableCell.section()->cachedCollapsedBorder(&m_layoutTableCell, CBSEnd)
-        : m_layoutTableCell.section()->cachedCollapsedBorder(&m_layoutTableCell, CBSStart);
+        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;
 }
 
 void TableCellPainter::paintCollapsedBorders(const PaintInfo& paintInfo, const LayoutPoint& paintOffset, const CollapsedBorderValue& currentBorderValue)
 {
     if (m_layoutTableCell.style()->visibility() != VISIBLE)
         return;
 
+    const LayoutTableCell::CollapsedBorderValues* values = m_layoutTableCell.collapsedBorderValues();
+    if (!values)
+        return;
+
     const ComputedStyle& styleForCellFlow = m_layoutTableCell.styleForCellFlow();
-    const CollapsedBorderValue* leftBorderValue = cachedCollapsedLeftBorder(styleForCellFlow);
-    const CollapsedBorderValue* rightBorderValue = cachedCollapsedRightBorder(styleForCellFlow);
-    const CollapsedBorderValue* topBorderValue = cachedCollapsedTopBorder(styleForCellFlow);
-    const CollapsedBorderValue* bottomBorderValue = cachedCollapsedBottomBorder(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::TableCollapsedBorderBase;
-    int topWidth = 0;
-    int bottomWidth = 0;
-    int leftWidth = 0;
-    int rightWidth = 0;
-    if (topBorderValue) {
-        if (topBorderValue->shouldPaint(currentBorderValue))
-            displayItemType |= DisplayItem::TableCollapsedBorderTop;
-        topWidth = topBorderValue->width();
-    }
-    if (bottomBorderValue) {
-        if (bottomBorderValue->shouldPaint(currentBorderValue))
-            displayItemType |= DisplayItem::TableCollapsedBorderBottom;
-        bottomWidth = bottomBorderValue->width();
-    }
-    if (leftBorderValue) {
-        if (leftBorderValue->shouldPaint(currentBorderValue))
-            displayItemType |= DisplayItem::TableCollapsedBorderLeft;
-        leftWidth = leftBorderValue->width();
-    }
-    if (rightBorderValue) {
-        if (rightBorderValue->shouldPaint(currentBorderValue))
-            displayItemType |= DisplayItem::TableCollapsedBorderRight;
-        rightWidth = rightBorderValue->width();
-    }
+    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::TableCollapsedBorderBase)
         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 = paintBounds(paintOffset, AddOffsetFromParent);
     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);
 
     if (!paintInfo.cullRect().intersectsCullRect(borderRect))
         return;
 
     GraphicsContext& graphicsContext = paintInfo.context;
     if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(graphicsContext, m_layoutTableCell, static_cast<DisplayItem::Type>(displayItemType)))
         return;
 
     LayoutObjectDrawingRecorder recorder(graphicsContext, m_layoutTableCell, 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 (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);
+            topBorderValue.color().resolve(cellColor), collapsedBorderStyle(topBorderValue.style()), 0, 0, true);
     }
     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);
+            bottomBorderValue.color().resolve(cellColor), collapsedBorderStyle(bottomBorderValue.style()), 0, 0, true);
     }
     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);
+            leftBorderValue.color().resolve(cellColor), collapsedBorderStyle(leftBorderValue.style()), 0, 0, true);
     }
     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);
+            rightBorderValue.color().resolve(cellColor), collapsedBorderStyle(rightBorderValue.style()), 0, 0, true);
     }
 }
 
 void TableCellPainter::paintBackgroundsBehindCell(const PaintInfo& paintInfo, const LayoutPoint& paintOffset, const LayoutObject* backgroundObject, DisplayItem::Type type)
 {
     if (!backgroundObject)
         return;
 
     if (m_layoutTableCell.style()->visibility() != VISIBLE)
         return;
@@ skipping 83 matching lines @@
 LayoutRect TableCellPainter::paintBounds(const LayoutPoint& paintOffset, PaintBoundOffsetBehavior paintBoundOffsetBehavior)
 {
     LayoutPoint adjustedPaintOffset = paintOffset;
     if (paintBoundOffsetBehavior == AddOffsetFromParent)
         adjustedPaintOffset.moveBy(m_layoutTableCell.location());
     return LayoutRect(adjustedPaintOffset, LayoutSize(m_layoutTableCell.pixelSnappedSize()));
 }
 
 } // namespace blink