Support subpixel layout for borders.

third_party/WebKit/Source/core/layout/LayoutTable.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, 2010, 2013 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
@@ skipping 770 matching lines @@
   LayoutTableCell::sortBorderValues(m_collapsedBorders);
 }
 
 void LayoutTable::addOverflowFromChildren() {
   // Add overflow from borders.
   // Technically it's odd that we are incorporating the borders into layout
   // overflow, which is only supposed to be about overflow from our
   // descendant objects, but since tables don't support overflow:auto, this
   // works out fine.
   if (collapseBorders()) {
-    int rightBorderOverflow =
-        (size().width() + outerBorderRight() - borderRight()).toInt();
-    int leftBorderOverflow = borderLeft() - outerBorderLeft();
-    int bottomBorderOverflow =
-        (size().height() + outerBorderBottom() - borderBottom()).toInt();
-    int topBorderOverflow = borderTop() - outerBorderTop();
-    IntRect borderOverflowRect(leftBorderOverflow, topBorderOverflow,
-                               rightBorderOverflow - leftBorderOverflow,
-                               bottomBorderOverflow - topBorderOverflow);
+    LayoutUnit rightBorderOverflow =
+        size().width() + outerBorderRight() - borderRight();
+    LayoutUnit leftBorderOverflow = borderLeft() - outerBorderLeft();
+    LayoutUnit bottomBorderOverflow =
+        size().height() + outerBorderBottom() - borderBottom();
+    LayoutUnit topBorderOverflow = borderTop() - outerBorderTop();
+    IntRect borderOverflowRect(
+        leftBorderOverflow.toInt(), topBorderOverflow.toInt(),
+        (rightBorderOverflow - leftBorderOverflow).toInt(),
+        (bottomBorderOverflow - topBorderOverflow).toInt());
     if (borderOverflowRect != pixelSnappedBorderBoxRect()) {
       LayoutRect borderLayoutRect(borderOverflowRect);
       addLayoutOverflow(borderLayoutRect);
       addContentsVisualOverflow(borderLayoutRect);
     }
   }
 
   // Add overflow from our caption.
   for (unsigned i = 0; i < m_captions.size(); i++)
     addOverflowFromChild(m_captions[i]);
@@ skipping 308 matching lines @@
   m_effectiveColumnPositions.resize(maxCols + 1);
   m_noCellColspanAtLeast = calcNoCellColspanAtLeast();
 
   ASSERT(selfNeedsLayout());
 
   m_needsSectionRecalc = false;
 }
 
 int LayoutTable::calcBorderStart() const {
   if (!collapseBorders())
-    return LayoutBlock::borderStart();
+    return LayoutBlock::borderStart().toInt();
 
   // Determined by the first cell of the first row. See the CSS 2.1 spec,
   // section 17.6.2.
   if (!numEffectiveColumns())
     return 0;
 
   int borderWidth = 0;
 
   const BorderValue& tableStartBorder = style()->borderStart();
   if (tableStartBorder.style() == BorderStyleHidden)
     return 0;
   if (tableStartBorder.style() > BorderStyleHidden)
     borderWidth = tableStartBorder.width();
 
   // TODO(dgrogan): This logic doesn't properly account for the first column in
   // the first column-group case.
   if (LayoutTableCol* column =
           colElementAtAbsoluteColumn(0).innermostColOrColGroup()) {
     // FIXME: We don't account for direction on columns and column groups.
     const BorderValue& columnAdjoiningBorder = column->style()->borderStart();
     if (columnAdjoiningBorder.style() == BorderStyleHidden)
       return 0;
     if (columnAdjoiningBorder.style() > BorderStyleHidden)
-      borderWidth = std::max(borderWidth, columnAdjoiningBorder.width());
+      borderWidth = std::max<int>(borderWidth, columnAdjoiningBorder.width());
   }
 
   if (const LayoutTableSection* topNonEmptySection =
           this->topNonEmptySection()) {
     const BorderValue& sectionAdjoiningBorder =
         topNonEmptySection->borderAdjoiningTableStart();
     if (sectionAdjoiningBorder.style() == BorderStyleHidden)
       return 0;
 
     if (sectionAdjoiningBorder.style() > BorderStyleHidden)
-      borderWidth = std::max(borderWidth, sectionAdjoiningBorder.width());
+      borderWidth = std::max<int>(borderWidth, sectionAdjoiningBorder.width());
 
     if (const LayoutTableCell* adjoiningStartCell =
             topNonEmptySection->firstRowCellAdjoiningTableStart()) {
       // FIXME: Make this work with perpendicular and flipped cells.
       const BorderValue& startCellAdjoiningBorder =
           adjoiningStartCell->borderAdjoiningTableStart();
       if (startCellAdjoiningBorder.style() == BorderStyleHidden)
         return 0;
 
       const BorderValue& firstRowAdjoiningBorder =
           adjoiningStartCell->row()->borderAdjoiningTableStart();
       if (firstRowAdjoiningBorder.style() == BorderStyleHidden)
         return 0;
 
-      if (startCellAdjoiningBorder.style() > BorderStyleHidden)
-        borderWidth = std::max(borderWidth, startCellAdjoiningBorder.width());
-      if (firstRowAdjoiningBorder.style() > BorderStyleHidden)
-        borderWidth = std::max(borderWidth, firstRowAdjoiningBorder.width());
+      if (startCellAdjoiningBorder.style() > BorderStyleHidden) {
+        borderWidth =
+            std::max<int>(borderWidth, startCellAdjoiningBorder.width());
+      }
+      if (firstRowAdjoiningBorder.style() > BorderStyleHidden) {
+        borderWidth =
+            std::max<int>(borderWidth, firstRowAdjoiningBorder.width());
+      }
     }
   }
   return (borderWidth + (style()->isLeftToRightDirection() ? 0 : 1)) / 2;
 }
 
 int LayoutTable::calcBorderEnd() const {
   if (!collapseBorders())
-    return LayoutBlock::borderEnd();
+    return LayoutBlock::borderEnd().toInt();
 
   // Determined by the last cell of the first row. See the CSS 2.1 spec, section
   // 17.6.2.
   if (!numEffectiveColumns())
     return 0;
 
   int borderWidth = 0;
 
   const BorderValue& tableEndBorder = style()->borderEnd();
   if (tableEndBorder.style() == BorderStyleHidden)
     return 0;
   if (tableEndBorder.style() > BorderStyleHidden)
     borderWidth = tableEndBorder.width();
 
   unsigned endColumn = numEffectiveColumns() - 1;
 
   // TODO(dgrogan): This logic doesn't properly account for the last column in
   // the last column-group case.
   if (LayoutTableCol* column =
           colElementAtAbsoluteColumn(endColumn).innermostColOrColGroup()) {
     // FIXME: We don't account for direction on columns and column groups.
     const BorderValue& columnAdjoiningBorder = column->style()->borderEnd();
     if (columnAdjoiningBorder.style() == BorderStyleHidden)
       return 0;
     if (columnAdjoiningBorder.style() > BorderStyleHidden)
-      borderWidth = std::max(borderWidth, columnAdjoiningBorder.width());
+      borderWidth = std::max<int>(borderWidth, columnAdjoiningBorder.width());
   }
 
   if (const LayoutTableSection* topNonEmptySection =
           this->topNonEmptySection()) {
     const BorderValue& sectionAdjoiningBorder =
         topNonEmptySection->borderAdjoiningTableEnd();
     if (sectionAdjoiningBorder.style() == BorderStyleHidden)
       return 0;
 
     if (sectionAdjoiningBorder.style() > BorderStyleHidden)
-      borderWidth = std::max(borderWidth, sectionAdjoiningBorder.width());
+      borderWidth = std::max<int>(borderWidth, sectionAdjoiningBorder.width());
 
     if (const LayoutTableCell* adjoiningEndCell =
             topNonEmptySection->firstRowCellAdjoiningTableEnd()) {
       // FIXME: Make this work with perpendicular and flipped cells.
       const BorderValue& endCellAdjoiningBorder =
           adjoiningEndCell->borderAdjoiningTableEnd();
       if (endCellAdjoiningBorder.style() == BorderStyleHidden)
         return 0;
 
       const BorderValue& firstRowAdjoiningBorder =
           adjoiningEndCell->row()->borderAdjoiningTableEnd();
       if (firstRowAdjoiningBorder.style() == BorderStyleHidden)
         return 0;
 
-      if (endCellAdjoiningBorder.style() > BorderStyleHidden)
-        borderWidth = std::max(borderWidth, endCellAdjoiningBorder.width());
-      if (firstRowAdjoiningBorder.style() > BorderStyleHidden)
-        borderWidth = std::max(borderWidth, firstRowAdjoiningBorder.width());
+      if (endCellAdjoiningBorder.style() > BorderStyleHidden) {
+        borderWidth =
+            std::max<int>(borderWidth, endCellAdjoiningBorder.width());
+      }
+      if (firstRowAdjoiningBorder.style() > BorderStyleHidden) {
+        borderWidth =
+            std::max<int>(borderWidth, firstRowAdjoiningBorder.width());
+      }
     }
   }
   return (borderWidth + (style()->isLeftToRightDirection() ? 1 : 0)) / 2;
 }
 
 void LayoutTable::recalcBordersInRowDirection() {
   // FIXME: We need to compute the collapsed before / after borders in the same
   // fashion.
   m_borderStart = calcBorderStart();
   m_borderEnd = calcBorderEnd();
 }
 
-int LayoutTable::borderBefore() const {
+LayoutUnit LayoutTable::borderBefore() const {
   if (collapseBorders()) {
     recalcSectionsIfNeeded();
-    return outerBorderBefore();
+    return LayoutUnit(outerBorderBefore());
   }
   return LayoutBlock::borderBefore();
 }
 
-int LayoutTable::borderAfter() const {
+LayoutUnit LayoutTable::borderAfter() const {
   if (collapseBorders()) {
     recalcSectionsIfNeeded();
-    return outerBorderAfter();
+    return LayoutUnit(outerBorderAfter());
   }
   return LayoutBlock::borderAfter();
 }
 
 int LayoutTable::outerBorderBefore() const {
   if (!collapseBorders())
     return 0;
   int borderWidth = 0;
   if (LayoutTableSection* topSection = this->topSection()) {
     borderWidth = topSection->outerBorderBefore();
@@ skipping 407 matching lines @@
 }
 
 LayoutUnit LayoutTable::paddingRight() const {
   if (collapseBorders())
     return LayoutUnit();
 
   return LayoutBlock::paddingRight();
 }
 
 }  // namespace blink