Support subpixel layout for borders.

third_party/WebKit/Source/core/layout/LayoutTableCell.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, 2007, 2008, 2009 Apple Inc.
  *               All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 397 matching lines @@
 LayoutRect LayoutTableCell::localVisualRect() const {
   // If the table grid is dirty, we cannot get reliable information about
   // adjoining cells, so we ignore outside borders. This should not be a problem
   // because it means that the table is going to recalculate the grid, relayout
   // and issue a paint invalidation of its current rect, which includes any
   // outside borders of this cell.
   if (!table()->collapseBorders() || table()->needsSectionRecalc())
     return LayoutBlockFlow::localVisualRect();
 
   bool rtl = !styleForCellFlow().isLeftToRightDirection();
-  int outlineOutset = style()->outlineOutsetExtent();
-  int left = std::max(borderHalfLeft(true), outlineOutset);
-  int right = std::max(borderHalfRight(true), outlineOutset);
-  int top = std::max(borderHalfTop(true), outlineOutset);
-  int bottom = std::max(borderHalfBottom(true), outlineOutset);
+  LayoutUnit outlineOutset(style()->outlineOutsetExtent());
+  LayoutUnit left(std::max(borderHalfLeft(true), outlineOutset));
+  LayoutUnit right(std::max(borderHalfRight(true), outlineOutset));
+  LayoutUnit top(std::max(borderHalfTop(true), outlineOutset));
+  LayoutUnit bottom(std::max(borderHalfBottom(true), outlineOutset));
   if ((left && !rtl) || (right && rtl)) {
     if (LayoutTableCell* before = table()->cellBefore(this)) {
       top = std::max(top, before->borderHalfTop(true));
       bottom = std::max(bottom, before->borderHalfBottom(true));
     }
   }
   if ((left && rtl) || (right && !rtl)) {
     if (LayoutTableCell* after = table()->cellAfter(this)) {
       top = std::max(top, after->borderHalfTop(true));
       bottom = std::max(bottom, after->borderHalfBottom(true));
@@ skipping 737 matching lines @@
             table->style()->borderAfter(),
             includeColor ? table->resolveColor(afterColorProperty) : Color(),
             BorderPrecedenceTable));
     if (!result.exists())
       return result;
   }
 
   return result;
 }
 
-int LayoutTableCell::borderLeft() const {
+LayoutUnit LayoutTableCell::borderLeft() const {
   return table()->collapseBorders() ? borderHalfLeft(false)
                                     : LayoutBlockFlow::borderLeft();
 }
 
-int LayoutTableCell::borderRight() const {
+LayoutUnit LayoutTableCell::borderRight() const {
   return table()->collapseBorders() ? borderHalfRight(false)
                                     : LayoutBlockFlow::borderRight();
 }
 
-int LayoutTableCell::borderTop() const {
+LayoutUnit LayoutTableCell::borderTop() const {
   return table()->collapseBorders() ? borderHalfTop(false)
                                     : LayoutBlockFlow::borderTop();
 }
 
-int LayoutTableCell::borderBottom() const {
+LayoutUnit LayoutTableCell::borderBottom() const {
   return table()->collapseBorders() ? borderHalfBottom(false)
                                     : LayoutBlockFlow::borderBottom();
 }
 
 // FIXME: https://bugs.webkit.org/show_bug.cgi?id=46191, make the collapsed
 // border drawing work with different block flow values instead of being
 // hard-coded to top-to-bottom.
-int LayoutTableCell::borderStart() const {
+LayoutUnit LayoutTableCell::borderStart() const {
   return table()->collapseBorders() ? borderHalfStart(false)
                                     : LayoutBlockFlow::borderStart();
 }
 
-int LayoutTableCell::borderEnd() const {
+LayoutUnit LayoutTableCell::borderEnd() const {
   return table()->collapseBorders() ? borderHalfEnd(false)
                                     : LayoutBlockFlow::borderEnd();
 }
 
-int LayoutTableCell::borderBefore() const {
+LayoutUnit LayoutTableCell::borderBefore() const {
   return table()->collapseBorders() ? borderHalfBefore(false)
                                     : LayoutBlockFlow::borderBefore();
 }
 
-int LayoutTableCell::borderAfter() const {
+LayoutUnit LayoutTableCell::borderAfter() const {
   return table()->collapseBorders() ? borderHalfAfter(false)
                                     : LayoutBlockFlow::borderAfter();
 }
 
-int LayoutTableCell::borderHalfLeft(bool outer) const {
+LayoutUnit LayoutTableCell::borderHalfLeft(bool outer) const {
   const ComputedStyle& styleForCellFlow = this->styleForCellFlow();
   if (styleForCellFlow.isHorizontalWritingMode())
     return styleForCellFlow.isLeftToRightDirection() ? borderHalfStart(outer)
                                                      : borderHalfEnd(outer);
   return styleForCellFlow.isFlippedBlocksWritingMode()
              ? borderHalfAfter(outer)
              : borderHalfBefore(outer);
 }
 
-int LayoutTableCell::borderHalfRight(bool outer) const {
+LayoutUnit LayoutTableCell::borderHalfRight(bool outer) const {
   const ComputedStyle& styleForCellFlow = this->styleForCellFlow();
   if (styleForCellFlow.isHorizontalWritingMode())
     return styleForCellFlow.isLeftToRightDirection() ? borderHalfEnd(outer)
                                                      : borderHalfStart(outer);
   return styleForCellFlow.isFlippedBlocksWritingMode() ? borderHalfBefore(outer)
                                                        : borderHalfAfter(outer);
 }
 
-int LayoutTableCell::borderHalfTop(bool outer) const {
+LayoutUnit LayoutTableCell::borderHalfTop(bool outer) const {
   const ComputedStyle& styleForCellFlow = this->styleForCellFlow();
   if (styleForCellFlow.isHorizontalWritingMode())
     return styleForCellFlow.isFlippedBlocksWritingMode()
                ? borderHalfAfter(outer)
                : borderHalfBefore(outer);
   return styleForCellFlow.isLeftToRightDirection() ? borderHalfStart(outer)
                                                    : borderHalfEnd(outer);
 }
 
-int LayoutTableCell::borderHalfBottom(bool outer) const {
+LayoutUnit LayoutTableCell::borderHalfBottom(bool outer) const {
   const ComputedStyle& styleForCellFlow = this->styleForCellFlow();
   if (styleForCellFlow.isHorizontalWritingMode())
     return styleForCellFlow.isFlippedBlocksWritingMode()
                ? borderHalfBefore(outer)
                : borderHalfAfter(outer);
   return styleForCellFlow.isLeftToRightDirection() ? borderHalfEnd(outer)
                                                    : borderHalfStart(outer);
 }
 
-int LayoutTableCell::borderHalfStart(bool outer) const {
+LayoutUnit LayoutTableCell::borderHalfStart(bool outer) const {
   CollapsedBorderValue border =
       computeCollapsedStartBorder(DoNotIncludeBorderColor);
-  if (border.exists())
-    return (border.width() +
-            ((styleForCellFlow().isLeftToRightDirection() ^ outer) ? 1 : 0)) /
-           2;  // Give the extra pixel to top and left.
-  return 0;
+  if (border.exists()) {
+    return LayoutUnit(
+        (border.width() +
+         ((styleForCellFlow().isLeftToRightDirection() ^ outer) ? 1 : 0)) /
+        2);  // Give the extra pixel to top and left.
+  }
+  return LayoutUnit();
 }
 
-int LayoutTableCell::borderHalfEnd(bool outer) const {
+LayoutUnit LayoutTableCell::borderHalfEnd(bool outer) const {
   CollapsedBorderValue border =
       computeCollapsedEndBorder(DoNotIncludeBorderColor);
-  if (border.exists())
-    return (border.width() +
-            ((styleForCellFlow().isLeftToRightDirection() ^ outer) ? 0 : 1)) /
-           2;
-  return 0;
+  if (border.exists()) {
+    return LayoutUnit(
+        (border.width() +
+         ((styleForCellFlow().isLeftToRightDirection() ^ outer) ? 0 : 1)) /
+        2);
+  }
+  return LayoutUnit();
 }
 
-int LayoutTableCell::borderHalfBefore(bool outer) const {
+LayoutUnit LayoutTableCell::borderHalfBefore(bool outer) const {
   CollapsedBorderValue border =
       computeCollapsedBeforeBorder(DoNotIncludeBorderColor);
-  if (border.exists())
-    return (border.width() +
-            ((styleForCellFlow().isFlippedBlocksWritingMode() ^ outer) ? 0
-                                                                       : 1)) /
-           2;  // Give the extra pixel to top and left.
-  return 0;
+  if (border.exists()) {
+    return LayoutUnit(
+        (border.width() +
+         ((styleForCellFlow().isFlippedBlocksWritingMode() ^ outer) ? 0 : 1)) /
+        2);  // Give the extra pixel to top and left.
+  }
+  return LayoutUnit();
 }
 
-int LayoutTableCell::borderHalfAfter(bool outer) const {
+LayoutUnit LayoutTableCell::borderHalfAfter(bool outer) const {
   CollapsedBorderValue border =
       computeCollapsedAfterBorder(DoNotIncludeBorderColor);
-  if (border.exists())
-    return (border.width() +
-            ((styleForCellFlow().isFlippedBlocksWritingMode() ^ outer) ? 1
-                                                                       : 0)) /
-           2;
-  return 0;
+  if (border.exists()) {
+    return LayoutUnit(
+        (border.width() +
+         ((styleForCellFlow().isFlippedBlocksWritingMode() ^ outer) ? 1 : 0)) /
+        2);
+  }
+  return LayoutUnit();
 }
 
 void LayoutTableCell::paint(const PaintInfo& paintInfo,
                             const LayoutPoint& paintOffset) const {
   TableCellPainter(*this).paint(paintInfo, paintOffset);
 }
 
 static void addBorderStyle(LayoutTable::CollapsedBorderValues& borderValues,
                            CollapsedBorderValue borderValue) {
   if (!borderValue.isVisible())
@@ skipping 180 matching lines @@
 }
 
 bool LayoutTableCell::hasLineIfEmpty() const {
   if (node() && hasEditableStyle(*node()))
     return true;
 
   return LayoutBlock::hasLineIfEmpty();
 }
 
 }  // namespace blink