Paint the whole of a table-part background image behind the cells in a table

third_party/WebKit/Source/core/paint/BackgroundImageGeometry.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/BackgroundImageGeometry.h"
 
 #include "core/frame/FrameView.h"
 #include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutBoxModelObject.h"
+#include "core/layout/LayoutTableCell.h"
+#include "core/layout/LayoutTableCol.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/compositing/CompositedLayerMapping.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/LayoutUnit.h"
 #include "platform/geometry/LayoutRect.h"
 
 namespace blink {
 
 namespace {
 
@@ skipping 186 matching lines @@
   m_destRect.move(0, std::max(roundedOffset, 0));
   setPhaseY(LayoutUnit(-std::min(roundedOffset, 0)));
   m_destRect.setHeight(m_tileSize.height() + std::min(roundedOffset, 0));
   setSpaceSize(LayoutSize(spaceSize().width(), LayoutUnit()));
 }
 
 void BackgroundImageGeometry::setRepeatX(const FillLayer& fillLayer,
                                          LayoutUnit unsnappedTileWidth,
                                          LayoutUnit snappedAvailableWidth,
                                          LayoutUnit unsnappedAvailableWidth,
-                                         LayoutUnit extraOffset) {
+                                         LayoutUnit extraOffset,
+                                         LayoutUnit offsetForCell) {
   // We would like to identify the phase as a fraction of the image size in the
   // absence of snapping, then re-apply it to the snapped values. This is to
   // handle large positions.
   if (unsnappedTileWidth) {
-    LayoutUnit computedXPosition = roundedMinimumValueForLength(
-        fillLayer.xPosition(), unsnappedAvailableWidth);
+    LayoutUnit computedXPosition =
+        roundedMinimumValueForLength(fillLayer.xPosition(),
+                                     unsnappedAvailableWidth) -
+        offsetForCell;
     if (fillLayer.backgroundXOrigin() == RightEdge) {
       float numberOfTilesInPosition =
           (snappedAvailableWidth - computedXPosition + extraOffset).toFloat() /
           unsnappedTileWidth.toFloat();
       float fractionalPositionWithinTile =
           numberOfTilesInPosition - truncf(numberOfTilesInPosition);
       setPhaseX(LayoutUnit(
           roundf(fractionalPositionWithinTile * tileSize().width())));
     } else {
       float numberOfTilesInPosition =
           (computedXPosition + extraOffset).toFloat() /
           unsnappedTileWidth.toFloat();
       float fractionalPositionWithinTile =
           1.0f - (numberOfTilesInPosition - truncf(numberOfTilesInPosition));
       setPhaseX(LayoutUnit(
           roundf(fractionalPositionWithinTile * tileSize().width())));
     }
   } else {
     setPhaseX(LayoutUnit());
   }
   setSpaceSize(LayoutSize(LayoutUnit(), spaceSize().height()));
 }
 
 void BackgroundImageGeometry::setRepeatY(const FillLayer& fillLayer,
                                          LayoutUnit unsnappedTileHeight,
                                          LayoutUnit snappedAvailableHeight,
                                          LayoutUnit unsnappedAvailableHeight,
-                                         LayoutUnit extraOffset) {
+                                         LayoutUnit extraOffset,
+                                         LayoutUnit offsetForCell) {
   // We would like to identify the phase as a fraction of the image size in the
   // absence of snapping, then re-apply it to the snapped values. This is to
   // handle large positions.
   if (unsnappedTileHeight) {
-    LayoutUnit computedYPosition = roundedMinimumValueForLength(
-        fillLayer.yPosition(), unsnappedAvailableHeight);
+    LayoutUnit computedYPosition =
+        roundedMinimumValueForLength(fillLayer.yPosition(),
+                                     unsnappedAvailableHeight) -
+        offsetForCell;
     if (fillLayer.backgroundYOrigin() == BottomEdge) {
       float numberOfTilesInPosition =
           (snappedAvailableHeight - computedYPosition + extraOffset).toFloat() /
           unsnappedTileHeight.toFloat();
       float fractionalPositionWithinTile =
           numberOfTilesInPosition - truncf(numberOfTilesInPosition);
       setPhaseY(LayoutUnit(
           roundf(fractionalPositionWithinTile * tileSize().height())));
     } else {
       float numberOfTilesInPosition =
@@ skipping 39 matching lines @@
 }
 
 void BackgroundImageGeometry::useFixedAttachment(
     const LayoutPoint& attachmentPoint) {
   LayoutPoint alignedPoint = attachmentPoint;
   m_phase.move(std::max(alignedPoint.x() - m_destRect.x(), LayoutUnit()),
                std::max(alignedPoint.y() - m_destRect.y(), LayoutUnit()));
   setPhase(LayoutPoint(roundedIntPoint(m_phase)));
 }
 
+enum ColumnGroupDirection { ColumnGroupStart, ColumnGroupEnd };
+
+static void expandToTableColumnGroup(const LayoutTableCell& cell,
+                                     const LayoutTableCol& columnGroup,
+                                     LayoutUnit& value,
+                                     ColumnGroupDirection columnDirection) {
+  auto siblingCell = columnDirection == ColumnGroupStart
+                         ? &LayoutTableCell::previousCell
+                         : &LayoutTableCell::nextCell;
+  for (const auto* sibling = (cell.*siblingCell)(); sibling;
+       sibling = (sibling->*siblingCell)()) {
+    if (cell.table()
+            ->colElementAtAbsoluteColumn(sibling->absoluteColumnIndex())
+            .innermostColOrColGroup()
+            ->enclosingColumnGroup() != columnGroup)
+      break;
+    value += sibling->size().width();
+  }
+}
+
+LayoutPoint BackgroundImageGeometry::getOffsetForCell(
+    const LayoutTableCell& cell,
+    const LayoutBox& positioningBox) {
+  LayoutSize borderSpacing = LayoutSize(cell.table()->hBorderSpacing(),
+                                        cell.table()->vBorderSpacing());
+  if (positioningBox.isTableSection())
+    return cell.location() - borderSpacing;
+  if (positioningBox.isTableRow()) {
+    return LayoutPoint(cell.location().x(), LayoutUnit()) -
+           LayoutSize(borderSpacing.width(), LayoutUnit());
+  }
+
+  LayoutRect sectionsRect(LayoutPoint(), cell.table()->size());
+  cell.table()->subtractCaptionRect(sectionsRect);
+  LayoutUnit heightOfCaptions =
+      cell.table()->size().height() - sectionsRect.height();
+  LayoutPoint offsetInBackground = LayoutPoint(
+      LayoutUnit(), (cell.section()->location().y() -
+                     cell.table()->borderBefore() - heightOfCaptions) +
+                        cell.location().y());
+
+  DCHECK(positioningBox.isLayoutTableCol());
+  if (toLayoutTableCol(positioningBox).isTableColumn()) {
+    return offsetInBackground -
+           LayoutSize(LayoutUnit(), borderSpacing.height());
+  }
+
+  DCHECK(toLayoutTableCol(positioningBox).isTableColumnGroup());
+  LayoutUnit offset = offsetInBackground.x();
+  expandToTableColumnGroup(cell, toLayoutTableCol(positioningBox), offset,
+                           ColumnGroupStart);
+  offsetInBackground.move(offset, LayoutUnit());
+  return offsetInBackground - LayoutSize(LayoutUnit(), borderSpacing.height());
+}
+
+LayoutSize BackgroundImageGeometry::getBackgroundObjectDimensions(
+    const LayoutTableCell& cell,
+    const LayoutBox& positioningBox) {
+  LayoutSize borderSpacing = LayoutSize(cell.table()->hBorderSpacing(),
+                                        cell.table()->vBorderSpacing());
+  if (positioningBox.isTableSection())
+    return positioningBox.size() - borderSpacing - borderSpacing;
+
+  if (positioningBox.isTableRow()) {
+    return positioningBox.size() -
+           LayoutSize(borderSpacing.width(), LayoutUnit()) -
+           LayoutSize(borderSpacing.width(), LayoutUnit());
+  }
+
+  DCHECK(positioningBox.isLayoutTableCol());
+  LayoutRect sectionsRect(LayoutPoint(), cell.table()->size());
+  cell.table()->subtractCaptionRect(sectionsRect);
+  LayoutUnit columnHeight = sectionsRect.height() -
+                            cell.table()->borderBefore() -
+                            borderSpacing.height() - borderSpacing.height();
+  if (toLayoutTableCol(positioningBox).isTableColumn())
+    return LayoutSize(cell.size().width(), columnHeight);
+
+  DCHECK(toLayoutTableCol(positioningBox).isTableColumnGroup());
+  LayoutUnit width = cell.size().width();
+  expandToTableColumnGroup(cell, toLayoutTableCol(positioningBox), width,
+                           ColumnGroupStart);
+  expandToTableColumnGroup(cell, toLayoutTableCol(positioningBox), width,
+                           ColumnGroupEnd);
+
+  return LayoutSize(width, columnHeight);
+}
+
 void BackgroundImageGeometry::calculate(
     const LayoutBoxModelObject& obj,
+    const LayoutObject* backgroundObject,
     const LayoutBoxModelObject* paintContainer,
     const GlobalPaintFlags globalPaintFlags,
     const FillLayer& fillLayer,
     const LayoutRect& paintRect) {
   LayoutUnit left;
   LayoutUnit top;
   LayoutSize positioningAreaSize;
   bool isLayoutView = obj.isLayoutView();
   const LayoutBox* rootBox = nullptr;
   if (isLayoutView) {
     // It is only possible reach here when root element has a box.
     Element* documentElement = obj.document().documentElement();
     DCHECK(documentElement);
     DCHECK(documentElement->layoutObject());
     DCHECK(documentElement->layoutObject()->isBox());
     rootBox = toLayoutBox(documentElement->layoutObject());
   }
+
+  bool cellUsingContainerBackground =
+      obj.isTableCell() && backgroundObject && !backgroundObject->isTableCell();
   const LayoutBoxModelObject& positioningBox =
-      isLayoutView ? static_cast<const LayoutBoxModelObject&>(*rootBox) : obj;
-
+      isLayoutView ? *rootBox
+                   : cellUsingContainerBackground
+                         ? toLayoutBoxModelObject(*backgroundObject)
+                         : obj;
+  LayoutPoint offsetInBackground =
+      cellUsingContainerBackground
+          ? getOffsetForCell(toLayoutTableCell(obj),
+                             toLayoutBox(positioningBox))
+          : LayoutPoint();
   // Determine the background positioning area and set destRect to the
   // background painting area.  destRect will be adjusted later if the
   // background is non-repeating.
   // FIXME: transforms spec says that fixed backgrounds behave like scroll
   // inside transforms.
   bool fixedAttachment = fillLayer.attachment() == FixedBackgroundAttachment;
 
   if (RuntimeEnabledFeatures::fastMobileScrollingEnabled()) {
     // As a side effect of an optimization to blit on scroll, we do not honor
     // the CSS property "background-attachment: fixed" because it may result in
@@ skipping 19 matching lines @@
         top += positioningBox.paddingTop();
         bottom += positioningBox.paddingBottom();
       }
     }
 
     if (isLayoutView) {
       // The background of the box generated by the root element covers the
       // entire canvas and will be painted by the view object, but the we should
       // still use the root element box for positioning.
       positioningAreaSize =
-          rootBox->size() - LayoutSize(left + right, top + bottom),
-      rootBox->location();
+          rootBox->size() - LayoutSize(left + right, top + bottom);
       // The input paint rect is specified in root element local coordinate
       // (i.e. a transform is applied on the context for painting), and is
       // expanded to cover the whole canvas.  Since left/top is relative to the
       // paint rect, we need to offset them back.
       left -= paintRect.x();
       top -= paintRect.y();
     } else {
       positioningAreaSize =
-          paintRect.size() - LayoutSize(left + right, top + bottom);
+          (cellUsingContainerBackground
+               ? getBackgroundObjectDimensions(toLayoutTableCell(obj),
+                                               toLayoutBox(positioningBox))
+               : paintRect.size()) -
+          LayoutSize(left + right, top + bottom);
     }
   } else {
     setHasNonLocalGeometry();
 
     LayoutRect viewportRect = obj.viewRect();
     if (fixedBackgroundPaintsInLocalCoordinates(obj, globalPaintFlags)) {
       viewportRect.setLocation(LayoutPoint());
     } else {
       if (FrameView* frameView = obj.view()->frameView())
         viewportRect.setLocation(IntPoint(frameView->scrollOffsetInt()));
@@ skipping 25 matching lines @@
   LayoutUnit unsnappedAvailableHeight =
       positioningAreaSize.height() - fillTileSize.height();
   positioningAreaSize =
       LayoutSize(snapSizeToPixel(positioningAreaSize.width(), m_destRect.x()),
                  snapSizeToPixel(positioningAreaSize.height(), m_destRect.y()));
   LayoutUnit availableWidth = positioningAreaSize.width() - tileSize().width();
   LayoutUnit availableHeight =
       positioningAreaSize.height() - tileSize().height();
 
   LayoutUnit computedXPosition =
-      roundedMinimumValueForLength(fillLayer.xPosition(), availableWidth);
+      roundedMinimumValueForLength(fillLayer.xPosition(), availableWidth) -
+      offsetInBackground.x();
   if (backgroundRepeatX == RoundFill &&
       positioningAreaSize.width() > LayoutUnit() &&
       fillTileSize.width() > LayoutUnit()) {
     int nrTiles = std::max(
         1, roundToInt(positioningAreaSize.width() / fillTileSize.width()));
     LayoutUnit roundedWidth = positioningAreaSize.width() / nrTiles;
 
     // Maintain aspect ratio if background-size: auto is set
     if (fillLayer.size().size.height().isAuto() &&
         backgroundRepeatY != RoundFill) {
       fillTileSize.setHeight(fillTileSize.height() * roundedWidth /
                              fillTileSize.width());
     }
     fillTileSize.setWidth(roundedWidth);
 
     setTileSize(applySubPixelHeuristicToImageSize(fillTileSize, m_destRect));
     setPhaseX(tileSize().width()
                   ? LayoutUnit(roundf(
                         tileSize().width() -
                         fmodf((computedXPosition + left), tileSize().width())))
                   : LayoutUnit());
     setSpaceSize(LayoutSize());
   }
 
   LayoutUnit computedYPosition =
-      roundedMinimumValueForLength(fillLayer.yPosition(), availableHeight);
+      roundedMinimumValueForLength(fillLayer.yPosition(), availableHeight) -
+      offsetInBackground.y();
   if (backgroundRepeatY == RoundFill &&
       positioningAreaSize.height() > LayoutUnit() &&
       fillTileSize.height() > LayoutUnit()) {
     int nrTiles = std::max(
         1, roundToInt(positioningAreaSize.height() / fillTileSize.height()));
     LayoutUnit roundedHeight = positioningAreaSize.height() / nrTiles;
     // Maintain aspect ratio if background-size: auto is set
     if (fillLayer.size().size.width().isAuto() &&
         backgroundRepeatX != RoundFill) {
       fillTileSize.setWidth(fillTileSize.width() * roundedHeight /
                             fillTileSize.height());
     }
     fillTileSize.setHeight(roundedHeight);
 
     setTileSize(applySubPixelHeuristicToImageSize(fillTileSize, m_destRect));
     setPhaseY(tileSize().height()
                   ? LayoutUnit(roundf(
                         tileSize().height() -
                         fmodf((computedYPosition + top), tileSize().height())))
                   : LayoutUnit());
     setSpaceSize(LayoutSize());
   }
 
   if (backgroundRepeatX == RepeatFill) {
     setRepeatX(fillLayer, fillTileSize.width(), availableWidth,
-               unsnappedAvailableWidth, left);
+               unsnappedAvailableWidth, left, offsetInBackground.x());
   } else if (backgroundRepeatX == SpaceFill &&
              tileSize().width() > LayoutUnit()) {
     LayoutUnit space = getSpaceBetweenImageTiles(positioningAreaSize.width(),
                                                  tileSize().width());
     if (space >= LayoutUnit())
       setSpaceX(space, availableWidth, left);
     else
       backgroundRepeatX = NoRepeatFill;
   }
   if (backgroundRepeatX == NoRepeatFill) {
     LayoutUnit xOffset = fillLayer.backgroundXOrigin() == RightEdge
                              ? availableWidth - computedXPosition
                              : computedXPosition;
     setNoRepeatX(left + xOffset);
+    if (offsetInBackground.x() > tileSize().width())
+      setDestRect(LayoutRect());
   }
 
   if (backgroundRepeatY == RepeatFill) {
     setRepeatY(fillLayer, fillTileSize.height(), availableHeight,
-               unsnappedAvailableHeight, top);
+               unsnappedAvailableHeight, top, offsetInBackground.y());
   } else if (backgroundRepeatY == SpaceFill &&
              tileSize().height() > LayoutUnit()) {
     LayoutUnit space = getSpaceBetweenImageTiles(positioningAreaSize.height(),
                                                  tileSize().height());
     if (space >= LayoutUnit())
       setSpaceY(space, availableHeight, top);
     else
       backgroundRepeatY = NoRepeatFill;
   }
   if (backgroundRepeatY == NoRepeatFill) {
     LayoutUnit yOffset = fillLayer.backgroundYOrigin() == BottomEdge
                              ? availableHeight - computedYPosition
                              : computedYPosition;
     setNoRepeatY(top + yOffset);
+    if (offsetInBackground.y() > tileSize().height())
+      setDestRect(LayoutRect());
   }
 
   if (fixedAttachment)
     useFixedAttachment(paintRect.location());
 
   // Clip the final output rect to the paint rect
   m_destRect.intersect(paintRect);
 
   // Snap as-yet unsnapped values.
   setDestRect(LayoutRect(pixelSnappedIntRect(m_destRect)));
 }
 
 }  // namespace blink