Preserve table rows unfragmented by default, per css-tables-3 6.1

Verified directly against the current W3C Editor's Draft
(drafts.csswg.org/css-tables-3/#breaking-rules): "user agents must attempt
to preserve the table rows unfragmented if the cells spanning the row do not
span any subsequent row, and their height is at least twice smaller than
both the fragmentainer height and width" - a required UA default, not
something an author opts into. The table's row-shift previously only fired
when the table itself had explicit break-inside:avoid, meaning an ordinary
multi-page table with no special markup rendered rows split across page
boundaries by default - not spec-compliant.

CssLayoutEngineTable.LayoutCells now attempts to preserve every row by
default, with the spec's two carve-outs implemented as "freely fragmentable"
exceptions: a row a cell only starts spanning into a later row (new
RowHasCellSpanningIntoSubsequentRow helper), or a row taller than half the
page's height or width. The table's own break-inside:avoid still forces the
attempt even for an otherwise-freely-fragmentable row, preserving existing
behavior for that explicit case.

Author: jhaygood86

Source/HtmlRenderer/Core/Dom/CssLayoutEngineTable.cs

@@ -736,19 +736,25 @@ private void LayoutCells(RGraphics g)
                     }
                 }
 
-                // break-inside: avoid (or the legacy page-break-inside) on the table: if this row
-                // straddles a page boundary and fits whole on one page, shift the whole row - not
-                // just one cell - down to the next page's content top. Rows aren't avoided from
-                // splitting by default (css-tables-3 6.1 permits a row to fragment, each cell
-                // independently, which is what happens here with no correction: a cell's own content
-                // already flows across the boundary via BlockFragmentation/InlineFragmentation) -
-                // only when the table author actually asked for it.
-                if (pageGridContainer != null && pageGridContainer.HasRealPageGrid && BreakValues.AvoidsBreak(_tableBox.BreakInside)
-                    && maxBottom > cury)
+                // css-tables-3 §6.1: "user agents must attempt to preserve the table rows unfragmented
+                // if the cells spanning the row do not span any subsequent row, and their height is at
+                // least twice smaller than both the fragmentainer height and width" - a UA-default
+                // requirement, not something an author has to opt into. If this row straddles a page
+                // boundary and isn't "freely fragmentable" by that rule, shift the whole row - not just
+                // one cell - down to the next page's content top. The table's own break-inside:avoid
+                // still forces the attempt even for an otherwise-freely-fragmentable row (an author's
+                // explicit, stronger request), matching this port's existing behavior for that case.
+                if (pageGridContainer != null && pageGridContainer.HasRealPageGrid && maxBottom > cury)
                 {
                     var topSlot = pageGridContainer.PageIndexOf(cury);
                     var bottomSlot = pageGridContainer.PageIndexOf(Math.Max(cury, maxBottom - 0.01));
-                    if (bottomSlot > topSlot && maxBottom - cury < pageGridContainer.PageSize.Height)
+                    var rowHeight = maxBottom - cury;
+                    var freelyFragmentable = RowHasCellSpanningIntoSubsequentRow(row, currentrow)
+                        || rowHeight >= pageGridContainer.PageSize.Height / 2
+                        || rowHeight >= pageGridContainer.PageSize.Width / 2;
+                    var shouldPreserve = !freelyFragmentable || BreakValues.AvoidsBreak(_tableBox.BreakInside);
+
+                    if (bottomSlot > topSlot && shouldPreserve && rowHeight < pageGridContainer.PageSize.Height)
                     {
                         var delta = pageGridContainer.PageTopOf(topSlot + 1) - cury;
                         foreach (CssBox cell in row.Boxes)
@@ -878,6 +884,31 @@ private static int GetRowSpan(CssBox b)
             return rowspan;
         }
 
+        /// <summary>
+        /// css-tables-3 §6.1's "the cells spanning the row do not span any subsequent row" test: true
+        /// if any cell in <paramref name="row"/> - real or the <see cref="CssSpacingBox"/> placeholder
+        /// standing in for one that started earlier - continues into a row after
+        /// <paramref name="currentrow"/>, meaning this row cannot be preserved unfragmented on its own
+        /// without also pulling along content that belongs to a row not yet reached.
+        /// </summary>
+        private static bool RowHasCellSpanningIntoSubsequentRow(CssBox row, int currentrow)
+        {
+            foreach (CssBox cell in row.Boxes)
+            {
+                if (cell is CssSpacingBox spacer)
+                {
+                    if (spacer.EndRow > currentrow)
+                        return true;
+                }
+                else if (GetRowSpan(cell) > 1)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
         /// <summary>
         /// Recursively measures words inside the box
         /// </summary>

Source/Test/HtmlRenderer.IntegrationTest/TableRowDefaultAtomicityTest.cs

@@ -0,0 +1,135 @@
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Reflection;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using TheArtOfDev.HtmlRenderer.Core;
+using TheArtOfDev.HtmlRenderer.Core.Dom;
+using TheArtOfDev.HtmlRenderer.WinForms;
+
+namespace TheArtOfDev.HtmlRenderer.IntegrationTest;
+
+/// <summary>
+/// Verifies a real, spec-confirmed default-behavior gap found while auditing this port's fragmentation
+/// engine against PeachPDF a third time, then checking the actual W3C text directly
+/// (<see href="https://drafts.csswg.org/css-tables-3/#breaking-rules">css-tables-3 §6.1</see>, current
+/// Editor's Draft): "When fragmenting a table, user agents <b>must</b> attempt to preserve the table rows
+/// unfragmented if the cells spanning the row do not span any subsequent row, and their height is at
+/// least twice smaller than both the fragmentainer height and width. Other rows are said <i>freely
+/// fragmentable</i>." This is phrased as a required UA default, not something an author opts into -
+/// <c>CssLayoutEngineTable.LayoutCells</c> previously only preserved a row when the TABLE had explicit
+/// <c>break-inside:avoid</c>, meaning an ordinary multi-page table with no special markup at all rendered
+/// rows split across page boundaries by default, which the spec does not permit as the default.
+/// </summary>
+[TestClass]
+[DoNotParallelize]
+public sealed class TableRowDefaultAtomicityTest
+{
+    private static HtmlContainerInt GetInternal(HtmlContainer wrapper)
+    {
+        var prop = typeof(HtmlContainer).GetProperty("HtmlContainerInt", BindingFlags.NonPublic | BindingFlags.Instance)!;
+        return (HtmlContainerInt)prop.GetValue(wrapper)!;
+    }
+
+    private static IEnumerable<CssBox> Walk(CssBox box)
+    {
+        yield return box;
+        foreach (var b in box.Boxes)
+            foreach (var d in Walk(b))
+                yield return d;
+    }
+
+    [TestMethod]
+    public async Task OrdinaryRowWithNoBreakInsideAvoid_IsStillPreservedUnfragmented_ByDefault()
+    {
+        var checkedAnyStraddleCandidate = false;
+
+        for (var fillerCount = 1; fillerCount < 60; fillerCount++)
+        {
+            using var wrapper = new HtmlContainer();
+            var filler = string.Concat(Enumerable.Repeat("<p style='margin:0;'>filler line</p>", fillerCount));
+            // Deliberately no break-inside:avoid anywhere - this is the plain, no-special-markup case
+            // css-tables-3 §6.1 says every conformant UA must handle this way by default.
+            await wrapper.SetHtml(
+                $"""
+                <html><body>
+                    {filler}
+                    <table style="border-collapse:collapse;">
+                        <tr><td>RowOneCell</td></tr>
+                        <tr><td>TargetRowCellText with several words giving it real, non-trivial height</td></tr>
+                    </table>
+                </body></html>
+                """);
+
+            var container = GetInternal(wrapper);
+            container.PageSize = new TheArtOfDev.HtmlRenderer.Adapters.Entities.RSize(300, 300);
+            container.MarginTop = 0;
+            wrapper.MaxSize = new SizeF(300, 0);
+
+            using var bitmap = new Bitmap(300, 20000);
+            using var g = Graphics.FromImage(bitmap);
+            wrapper.PerformLayout(g);
+
+            var tds = Walk(container.Root).Where(b => b.HtmlTag?.Name == "td").ToList();
+            if (tds.Count < 2)
+                continue;
+            var targetCell = tds[1];
+
+            var topSlot = container.PageIndexOf(targetCell.Location.Y);
+            var bottomSlot = container.PageIndexOf(System.Math.Max(targetCell.Location.Y, targetCell.ActualBottom - 0.01));
+
+            checkedAnyStraddleCandidate = true;
+            Assert.AreEqual(topSlot, bottomSlot,
+                $"at fillerCount={fillerCount}, the second row straddles page slots {topSlot}->{bottomSlot} with no break-inside:avoid anywhere - css-tables-3 6.1 requires it stay whole by default");
+        }
+
+        Assert.IsTrue(checkedAnyStraddleCandidate, "no filler count in range produced a target cell - test is not meaningful as written");
+    }
+
+    [TestMethod]
+    public async Task RowSpanningIntoASubsequentRow_RemainsFreelyFragmentable()
+    {
+        // css-tables-3 6.1's own carve-out: a row a rowspan cell only STARTS in (spanning further rows)
+        // is explicitly excluded from the "preserve unfragmented" default - confirming the new default
+        // atomicity doesn't overreach into content the spec says must stay freely fragmentable.
+        var foundAStraddle = false;
+
+        for (var fillerCount = 1; fillerCount < 30; fillerCount++)
+        {
+            using var wrapper = new HtmlContainer();
+            var filler = string.Concat(Enumerable.Repeat("<p style='margin:0;'>filler line</p>", fillerCount));
+            await wrapper.SetHtml(
+                $"""
+                <html><body>
+                    {filler}
+                    <table style="border-collapse:collapse;">
+                        <tr><td rowspan="2">SpanCell</td><td>Row1Cell2 with enough words to make this row meaningfully tall for the straddle test to matter</td></tr>
+                        <tr><td>Row2Cell</td></tr>
+                    </table>
+                </body></html>
+                """);
+
+            var container = GetInternal(wrapper);
+            container.PageSize = new TheArtOfDev.HtmlRenderer.Adapters.Entities.RSize(300, 300);
+            container.MarginTop = 0;
+            wrapper.MaxSize = new SizeF(300, 0);
+
+            using var bitmap = new Bitmap(300, 20000);
+            using var g = Graphics.FromImage(bitmap);
+            wrapper.PerformLayout(g);
+
+            var row1Cell2 = Walk(container.Root)
+                .FirstOrDefault(b => b.Words.Any(w => w.Text.Contains("Row1Cell2")))
+                ?.ParentBox;
+            if (row1Cell2 == null)
+                continue;
+
+            var topSlot = container.PageIndexOf(row1Cell2.Location.Y);
+            var bottomSlot = container.PageIndexOf(System.Math.Max(row1Cell2.Location.Y, row1Cell2.ActualBottom - 0.01));
+            if (topSlot != bottomSlot)
+                foundAStraddle = true;
+        }
+
+        Assert.IsTrue(foundAStraddle, "expected at least one filler count where the rowspan-starting row straddles a page boundary - if none do, this test isn't exercising the carve-out");
+    }
+}