Add m-esr52 at 52.6.0

1 files changed, 1060 insertions, 0 deletions

diff --git a/layout/tables/BasicTableLayoutStrategy.cpp b/layout/tables/BasicTableLayoutStrategy.cpp
new file mode 100644
index 000000000..65835e68e
--- /dev/null
+++ b/layout/tables/BasicTableLayoutStrategy.cpp
@@ -0,0 +1,1060 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+// vim:cindent:ts=4:et:sw=4:
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * Web-compatible algorithms that determine column and table widths,
+ * used for CSS2's 'table-layout: auto'.
+ */
+
+#include "BasicTableLayoutStrategy.h"
+
+#include <algorithm>
+
+#include "nsTableFrame.h"
+#include "nsTableColFrame.h"
+#include "nsTableCellFrame.h"
+#include "nsLayoutUtils.h"
+#include "nsGkAtoms.h"
+#include "SpanningCellSorter.h"
+#include "nsIContent.h"
+
+using namespace mozilla;
+using namespace mozilla::layout;
+
+namespace css = mozilla::css;
+
+#undef  DEBUG_TABLE_STRATEGY 
+
+BasicTableLayoutStrategy::BasicTableLayoutStrategy(nsTableFrame *aTableFrame)
+  : nsITableLayoutStrategy(nsITableLayoutStrategy::Auto)
+  , mTableFrame(aTableFrame)
+{
+    MarkIntrinsicISizesDirty();
+}
+
+/* virtual */
+BasicTableLayoutStrategy::~BasicTableLayoutStrategy()
+{
+}
+
+/* virtual */ nscoord
+BasicTableLayoutStrategy::GetMinISize(nsRenderingContext* aRenderingContext)
+{
+    DISPLAY_MIN_WIDTH(mTableFrame, mMinISize);
+    if (mMinISize == NS_INTRINSIC_WIDTH_UNKNOWN) {
+        ComputeIntrinsicISizes(aRenderingContext);
+    }
+    return mMinISize;
+}
+
+/* virtual */ nscoord
+BasicTableLayoutStrategy::GetPrefISize(nsRenderingContext* aRenderingContext,
+                                       bool aComputingSize)
+{
+    DISPLAY_PREF_WIDTH(mTableFrame, mPrefISize);
+    NS_ASSERTION((mPrefISize == NS_INTRINSIC_WIDTH_UNKNOWN) ==
+                 (mPrefISizePctExpand == NS_INTRINSIC_WIDTH_UNKNOWN),
+                 "dirtyness out of sync");
+    if (mPrefISize == NS_INTRINSIC_WIDTH_UNKNOWN) {
+        ComputeIntrinsicISizes(aRenderingContext);
+    }
+    return aComputingSize ? mPrefISizePctExpand : mPrefISize;
+}
+
+struct CellISizeInfo {
+    CellISizeInfo(nscoord aMinCoord, nscoord aPrefCoord,
+                  float aPrefPercent, bool aHasSpecifiedISize)
+        : hasSpecifiedISize(aHasSpecifiedISize)
+        , minCoord(aMinCoord)
+        , prefCoord(aPrefCoord)
+        , prefPercent(aPrefPercent)
+    {
+    }
+
+    bool hasSpecifiedISize;
+    nscoord minCoord;
+    nscoord prefCoord;
+    float prefPercent;
+};
+
+// Used for both column and cell calculations.  The parts needed only
+// for cells are skipped when aIsCell is false.
+static CellISizeInfo
+GetISizeInfo(nsRenderingContext *aRenderingContext,
+             nsIFrame *aFrame, WritingMode aWM, bool aIsCell)
+{
+    nscoord minCoord, prefCoord;
+    const nsStylePosition *stylePos = aFrame->StylePosition();
+    bool isQuirks = aFrame->PresContext()->CompatibilityMode() ==
+                    eCompatibility_NavQuirks;
+    nscoord boxSizingToBorderEdge = 0;
+    if (aIsCell) {
+        // If aFrame is a container for font size inflation, then shrink
+        // wrapping inside of it should not apply font size inflation.
+        AutoMaybeDisableFontInflation an(aFrame);
+
+        minCoord = aFrame->GetMinISize(aRenderingContext);
+        prefCoord = aFrame->GetPrefISize(aRenderingContext);
+        // Until almost the end of this function, minCoord and prefCoord
+        // represent the box-sizing based isize values (which mean they
+        // should include inline padding and border width when
+        // box-sizing is set to border-box).
+        // Note that this function returns border-box isize, we add the
+        // outer edges near the end of this function.
+
+        // XXX Should we ignore percentage padding?
+        nsIFrame::IntrinsicISizeOffsetData offsets =
+            aFrame->IntrinsicISizeOffsets();
+
+        // In quirks mode, table cell isize should be content-box,
+        // but bsize should be border box.
+        // Because of this historic anomaly, we do not use quirk.css.
+        // (We can't specify one value of box-sizing for isize and another
+        // for bsize).
+        // For this reason, we also do not use box-sizing for just one of
+        // them, as this may be confusing.
+        if (isQuirks || stylePos->mBoxSizing == StyleBoxSizing::Content) {
+            boxSizingToBorderEdge = offsets.hPadding + offsets.hBorder;
+        }
+        else {
+            // StyleBoxSizing::Border and standards-mode
+            minCoord += offsets.hPadding + offsets.hBorder;
+            prefCoord += offsets.hPadding + offsets.hBorder;
+        }
+    } else {
+        minCoord = 0;
+        prefCoord = 0;
+    }
+    float prefPercent = 0.0f;
+    bool hasSpecifiedISize = false;
+
+    const nsStyleCoord& iSize = stylePos->ISize(aWM);
+    nsStyleUnit unit = iSize.GetUnit();
+    // NOTE: We're ignoring calc() units with percentages here, for lack of a
+    // sensible idea for what to do with them.  This means calc() with
+    // percentages is basically handled like 'auto' for table cells and
+    // columns.
+    if (iSize.ConvertsToLength()) {
+        hasSpecifiedISize = true;
+        // Note: since ComputeISizeValue was designed to return content-box
+        // isize, it will (in some cases) subtract the box-sizing edges.
+        // We prevent this unwanted behavior by calling it with
+        // aContentEdgeToBoxSizing and aBoxSizingToMarginEdge set to 0.
+        nscoord c = aFrame->ComputeISizeValue(aRenderingContext, 0, 0, 0, iSize);
+        // Quirk: A cell with "nowrap" set and a coord value for the
+        // isize which is bigger than the intrinsic minimum isize uses
+        // that coord value as the minimum isize.
+        // This is kept up-to-date with dynamic changes to nowrap by code in
+        // nsTableCellFrame::AttributeChanged
+        if (aIsCell && c > minCoord && isQuirks &&
+            aFrame->GetContent()->HasAttr(kNameSpaceID_None,
+                                          nsGkAtoms::nowrap)) {
+            minCoord = c;
+        }
+        prefCoord = std::max(c, minCoord);
+    } else if (unit == eStyleUnit_Percent) {
+        prefPercent = iSize.GetPercentValue();
+    } else if (unit == eStyleUnit_Enumerated && aIsCell) {
+        switch (iSize.GetIntValue()) {
+            case NS_STYLE_WIDTH_MAX_CONTENT:
+                // 'inline-size' only affects pref isize, not min
+                // isize, so don't change anything
+                break;
+            case NS_STYLE_WIDTH_MIN_CONTENT:
+                prefCoord = minCoord;
+                break;
+            case NS_STYLE_WIDTH_FIT_CONTENT:
+            case NS_STYLE_WIDTH_AVAILABLE:
+                // act just like 'inline-size: auto'
+                break;
+            default:
+                NS_NOTREACHED("unexpected enumerated value");
+        }
+    }
+
+    nsStyleCoord maxISize(stylePos->MaxISize(aWM));
+    if (maxISize.GetUnit() == eStyleUnit_Enumerated) {
+        if (!aIsCell || maxISize.GetIntValue() == NS_STYLE_WIDTH_AVAILABLE) {
+            maxISize.SetNoneValue();
+        } else if (maxISize.GetIntValue() == NS_STYLE_WIDTH_FIT_CONTENT) {
+            // for 'max-inline-size', '-moz-fit-content' is like
+            // '-moz-max-content'
+            maxISize.SetIntValue(NS_STYLE_WIDTH_MAX_CONTENT,
+                                 eStyleUnit_Enumerated);
+        }
+    }
+    unit = maxISize.GetUnit();
+    // XXX To really implement 'max-inline-size' well, we'd need to store
+    // it separately on the columns.
+    if (maxISize.ConvertsToLength() || unit == eStyleUnit_Enumerated) {
+        nscoord c = aFrame->ComputeISizeValue(aRenderingContext,
+                                              0, 0, 0, maxISize);
+        minCoord = std::min(c, minCoord);
+        prefCoord = std::min(c, prefCoord);
+    } else if (unit == eStyleUnit_Percent) {
+        float p = stylePos->MaxISize(aWM).GetPercentValue();
+        if (p < prefPercent) {
+            prefPercent = p;
+        }
+    }
+    // treat calc() with percentages on max-inline-size just like 'none'.
+
+    nsStyleCoord minISize(stylePos->MinISize(aWM));
+    if (minISize.GetUnit() == eStyleUnit_Enumerated) {
+        if (!aIsCell || minISize.GetIntValue() == NS_STYLE_WIDTH_AVAILABLE) {
+            minISize.SetCoordValue(0);
+        } else if (minISize.GetIntValue() == NS_STYLE_WIDTH_FIT_CONTENT) {
+            // for 'min-inline-size', '-moz-fit-content' is like
+            // '-moz-min-content'
+            minISize.SetIntValue(NS_STYLE_WIDTH_MIN_CONTENT,
+                                 eStyleUnit_Enumerated);
+        }
+    }
+    unit = minISize.GetUnit();
+    if (minISize.ConvertsToLength() || unit == eStyleUnit_Enumerated) {
+        nscoord c = aFrame->ComputeISizeValue(aRenderingContext,
+                                              0, 0, 0, minISize);
+        minCoord = std::max(c, minCoord);
+        prefCoord = std::max(c, prefCoord);
+    } else if (unit == eStyleUnit_Percent) {
+        float p = stylePos->MinISize(aWM).GetPercentValue();
+        if (p > prefPercent) {
+            prefPercent = p;
+        }
+    }
+    // treat calc() with percentages on min-inline-size just like '0'.
+
+    // XXX Should col frame have border/padding considered?
+    if (aIsCell) {
+        minCoord += boxSizingToBorderEdge;
+        prefCoord = NSCoordSaturatingAdd(prefCoord, boxSizingToBorderEdge);
+    }
+
+    return CellISizeInfo(minCoord, prefCoord, prefPercent, hasSpecifiedISize);
+}
+
+static inline CellISizeInfo
+GetCellISizeInfo(nsRenderingContext *aRenderingContext,
+                 nsTableCellFrame *aCellFrame, WritingMode aWM)
+{
+    return GetISizeInfo(aRenderingContext, aCellFrame, aWM, true);
+}
+
+static inline CellISizeInfo
+GetColISizeInfo(nsRenderingContext *aRenderingContext,
+                nsIFrame *aFrame, WritingMode aWM)
+{
+    return GetISizeInfo(aRenderingContext, aFrame, aWM, false);
+}
+
+
+/**
+ * The algorithm in this function, in addition to meeting the
+ * requirements of Web-compatibility, is also invariant under reordering
+ * of the rows within a table (something that most, but not all, other
+ * browsers are).
+ */
+void
+BasicTableLayoutStrategy::ComputeColumnIntrinsicISizes(nsRenderingContext* aRenderingContext)
+{
+    nsTableFrame *tableFrame = mTableFrame;
+    nsTableCellMap *cellMap = tableFrame->GetCellMap();
+    WritingMode wm = tableFrame->GetWritingMode();
+
+    mozilla::AutoStackArena arena;
+    SpanningCellSorter spanningCells;
+
+    // Loop over the columns to consider the columns and cells *without*
+    // a colspan.
+    int32_t col, col_end;
+    for (col = 0, col_end = cellMap->GetColCount(); col < col_end; ++col) {
+        nsTableColFrame *colFrame = tableFrame->GetColFrame(col);
+        if (!colFrame) {
+            NS_ERROR("column frames out of sync with cell map");
+            continue;
+        }
+        colFrame->ResetIntrinsics();
+        colFrame->ResetSpanIntrinsics();
+
+        // Consider the isizes on the column.
+        CellISizeInfo colInfo = GetColISizeInfo(aRenderingContext,
+                                                colFrame, wm);
+        colFrame->AddCoords(colInfo.minCoord, colInfo.prefCoord,
+                            colInfo.hasSpecifiedISize);
+        colFrame->AddPrefPercent(colInfo.prefPercent);
+
+        // Consider the isizes on the column-group.  Note that we follow
+        // what the HTML spec says here, and make the isize apply to
+        // each column in the group, not the group as a whole.
+
+        // If column has isize, column-group doesn't override isize.
+        if (colInfo.minCoord == 0 && colInfo.prefCoord == 0 &&
+            colInfo.prefPercent == 0.0f) {
+            NS_ASSERTION(colFrame->GetParent()->GetType() ==
+                             nsGkAtoms::tableColGroupFrame,
+                         "expected a column-group");
+            colInfo = GetColISizeInfo(aRenderingContext,
+                                      colFrame->GetParent(), wm);
+            colFrame->AddCoords(colInfo.minCoord, colInfo.prefCoord,
+                                colInfo.hasSpecifiedISize);
+            colFrame->AddPrefPercent(colInfo.prefPercent);
+        }
+
+        // Consider the contents of and the isizes on the cells without
+        // colspans.
+        nsCellMapColumnIterator columnIter(cellMap, col);
+        int32_t row, colSpan;
+        nsTableCellFrame* cellFrame;
+        while ((cellFrame = columnIter.GetNextFrame(&row, &colSpan))) {
+            if (colSpan > 1) {
+                spanningCells.AddCell(colSpan, row, col);
+                continue;
+            }
+
+            CellISizeInfo info = GetCellISizeInfo(aRenderingContext,
+                                                  cellFrame, wm);
+
+            colFrame->AddCoords(info.minCoord, info.prefCoord,
+                                info.hasSpecifiedISize);
+            colFrame->AddPrefPercent(info.prefPercent);
+        }
+#ifdef DEBUG_dbaron_off
+        printf("table %p col %d nonspan: min=%d pref=%d spec=%d pct=%f\n",
+               mTableFrame, col, colFrame->GetMinCoord(),
+               colFrame->GetPrefCoord(), colFrame->GetHasSpecifiedCoord(),
+               colFrame->GetPrefPercent());
+#endif
+    }
+#ifdef DEBUG_TABLE_STRATEGY
+    printf("ComputeColumnIntrinsicISizes single\n");
+    mTableFrame->Dump(false, true, false);
+#endif
+
+    // Consider the cells with a colspan that we saved in the loop above
+    // into the spanning cell sorter.  We consider these cells by seeing
+    // if they require adding to the isizes resulting only from cells
+    // with a smaller colspan, and therefore we must process them sorted
+    // in increasing order by colspan.  For each colspan group, we
+    // accumulate new values to accumulate in the column frame's Span*
+    // members.
+    //
+    // Considering things only relative to the isizes resulting from
+    // cells with smaller colspans (rather than incrementally including
+    // the results from spanning cells, or doing spanning and
+    // non-spanning cells in a single pass) means that layout remains
+    // row-order-invariant and (except for percentage isizes that add to
+    // more than 100%) column-order invariant.
+    //
+    // Starting with smaller colspans makes it more likely that we
+    // satisfy all the constraints given and don't distribute space to
+    // columns where we don't need it.
+    SpanningCellSorter::Item *item;
+    int32_t colSpan;
+    while ((item = spanningCells.GetNext(&colSpan))) {
+        NS_ASSERTION(colSpan > 1,
+                     "cell should not have been put in spanning cell sorter");
+        do {
+            int32_t row = item->row;
+            col = item->col;
+            CellData *cellData = cellMap->GetDataAt(row, col);
+            NS_ASSERTION(cellData && cellData->IsOrig(),
+                         "bogus result from spanning cell sorter");
+
+            nsTableCellFrame *cellFrame = cellData->GetCellFrame();
+            NS_ASSERTION(cellFrame, "bogus result from spanning cell sorter");
+
+            CellISizeInfo info =
+                GetCellISizeInfo(aRenderingContext, cellFrame, wm);
+
+            if (info.prefPercent > 0.0f) {
+                DistributePctISizeToColumns(info.prefPercent,
+                                            col, colSpan);
+            }
+            DistributeISizeToColumns(info.minCoord, col, colSpan, 
+                                     BTLS_MIN_ISIZE, info.hasSpecifiedISize);
+            DistributeISizeToColumns(info.prefCoord, col, colSpan, 
+                                     BTLS_PREF_ISIZE, info.hasSpecifiedISize);
+        } while ((item = item->next));
+
+        // Combine the results of the span analysis into the main results,
+        // for each increment of colspan.
+
+        for (col = 0, col_end = cellMap->GetColCount(); col < col_end; ++col) {
+            nsTableColFrame *colFrame = tableFrame->GetColFrame(col);
+            if (!colFrame) {
+                NS_ERROR("column frames out of sync with cell map");
+                continue;
+            }
+
+            colFrame->AccumulateSpanIntrinsics();
+            colFrame->ResetSpanIntrinsics();
+
+#ifdef DEBUG_dbaron_off
+            printf("table %p col %d span %d: min=%d pref=%d spec=%d pct=%f\n",
+                   mTableFrame, col, colSpan, colFrame->GetMinCoord(),
+                   colFrame->GetPrefCoord(), colFrame->GetHasSpecifiedCoord(),
+                   colFrame->GetPrefPercent());
+#endif
+        }
+    }
+
+    // Prevent percentages from adding to more than 100% by (to be
+    // compatible with other browsers) treating any percentages that would
+    // increase the total percentage to more than 100% as the number that
+    // would increase it to only 100% (which is 0% if we've already hit
+    // 100%).  This means layout depends on the order of columns.
+    float pct_used = 0.0f;
+    for (col = 0, col_end = cellMap->GetColCount(); col < col_end; ++col) {
+        nsTableColFrame *colFrame = tableFrame->GetColFrame(col);
+        if (!colFrame) {
+            NS_ERROR("column frames out of sync with cell map");
+            continue;
+        }
+
+        colFrame->AdjustPrefPercent(&pct_used);
+    }
+
+#ifdef DEBUG_TABLE_STRATEGY
+    printf("ComputeColumnIntrinsicISizes spanning\n");
+    mTableFrame->Dump(false, true, false);
+#endif
+}
+
+void
+BasicTableLayoutStrategy::ComputeIntrinsicISizes(nsRenderingContext* aRenderingContext)
+{
+    ComputeColumnIntrinsicISizes(aRenderingContext);
+
+    nsTableCellMap *cellMap = mTableFrame->GetCellMap();
+    nscoord min = 0, pref = 0, max_small_pct_pref = 0, nonpct_pref_total = 0;
+    float pct_total = 0.0f; // always from 0.0f - 1.0f
+    int32_t colCount = cellMap->GetColCount();
+    // add a total of (colcount + 1) lots of cellSpacingX for columns where a
+    // cell originates
+    nscoord add = mTableFrame->GetColSpacing(colCount);
+
+    for (int32_t col = 0; col < colCount; ++col) {
+        nsTableColFrame *colFrame = mTableFrame->GetColFrame(col);
+        if (!colFrame) {
+            NS_ERROR("column frames out of sync with cell map");
+            continue;
+        }
+        if (mTableFrame->ColumnHasCellSpacingBefore(col)) {
+            add += mTableFrame->GetColSpacing(col - 1);
+        }
+        min += colFrame->GetMinCoord();
+        pref = NSCoordSaturatingAdd(pref, colFrame->GetPrefCoord());
+
+        // Percentages are of the table, so we have to reverse them for
+        // intrinsic isizes.
+        float p = colFrame->GetPrefPercent();
+        if (p > 0.0f) {
+            nscoord colPref = colFrame->GetPrefCoord();
+            nscoord new_small_pct_expand = 
+                (colPref == nscoord_MAX ?
+                 nscoord_MAX : nscoord(float(colPref) / p));
+            if (new_small_pct_expand > max_small_pct_pref) {
+                max_small_pct_pref = new_small_pct_expand;
+            }
+            pct_total += p;
+        } else {
+            nonpct_pref_total = NSCoordSaturatingAdd(nonpct_pref_total, 
+                                                     colFrame->GetPrefCoord());
+        }
+    }
+
+    nscoord pref_pct_expand = pref;
+
+    // Account for small percentages expanding the preferred isize of
+    // *other* columns.
+    if (max_small_pct_pref > pref_pct_expand) {
+        pref_pct_expand = max_small_pct_pref;
+    }
+
+    // Account for large percentages expanding the preferred isize of
+    // themselves.  There's no need to iterate over the columns multiple
+    // times, since when there is such a need, the small percentage
+    // effect is bigger anyway.  (I think!)
+    NS_ASSERTION(0.0f <= pct_total && pct_total <= 1.0f,
+                 "column percentage inline-sizes not adjusted down to 100%");
+    if (pct_total == 1.0f) {
+        if (nonpct_pref_total > 0) {
+            pref_pct_expand = nscoord_MAX;
+            // XXX Or should I use some smaller value?  (Test this using
+            // nested tables!)
+        }
+    } else {
+        nscoord large_pct_pref =
+            (nonpct_pref_total == nscoord_MAX ?
+             nscoord_MAX :
+             nscoord(float(nonpct_pref_total) / (1.0f - pct_total)));
+        if (large_pct_pref > pref_pct_expand)
+            pref_pct_expand = large_pct_pref;
+    }
+
+    // border-spacing isn't part of the basis for percentages
+    if (colCount > 0) {
+        min += add;
+        pref = NSCoordSaturatingAdd(pref, add);
+        pref_pct_expand = NSCoordSaturatingAdd(pref_pct_expand, add);
+    }
+
+    mMinISize = min;
+    mPrefISize = pref;
+    mPrefISizePctExpand = pref_pct_expand;
+}
+
+/* virtual */ void
+BasicTableLayoutStrategy::MarkIntrinsicISizesDirty()
+{
+    mMinISize = NS_INTRINSIC_WIDTH_UNKNOWN;
+    mPrefISize = NS_INTRINSIC_WIDTH_UNKNOWN;
+    mPrefISizePctExpand = NS_INTRINSIC_WIDTH_UNKNOWN;
+    mLastCalcISize = nscoord_MIN;
+}
+
+/* virtual */ void
+BasicTableLayoutStrategy::ComputeColumnISizes(const ReflowInput& aReflowInput)
+{
+    nscoord iSize = aReflowInput.ComputedISize();
+
+    if (mLastCalcISize == iSize) {
+        return;
+    }
+    mLastCalcISize = iSize;
+
+    NS_ASSERTION((mMinISize == NS_INTRINSIC_WIDTH_UNKNOWN) ==
+                 (mPrefISize == NS_INTRINSIC_WIDTH_UNKNOWN),
+                 "dirtyness out of sync");
+    NS_ASSERTION((mMinISize == NS_INTRINSIC_WIDTH_UNKNOWN) ==
+                 (mPrefISizePctExpand == NS_INTRINSIC_WIDTH_UNKNOWN),
+                 "dirtyness out of sync");
+    // XXX Is this needed?
+    if (mMinISize == NS_INTRINSIC_WIDTH_UNKNOWN) {
+        ComputeIntrinsicISizes(aReflowInput.mRenderingContext);
+    }
+
+    nsTableCellMap *cellMap = mTableFrame->GetCellMap();
+    int32_t colCount = cellMap->GetColCount();
+    if (colCount <= 0)
+        return; // nothing to do
+
+    DistributeISizeToColumns(iSize, 0, colCount, BTLS_FINAL_ISIZE, false);
+
+#ifdef DEBUG_TABLE_STRATEGY
+    printf("ComputeColumnISizes final\n");
+    mTableFrame->Dump(false, true, false);
+#endif
+}
+
+void
+BasicTableLayoutStrategy::DistributePctISizeToColumns(float aSpanPrefPct,
+                                                      int32_t aFirstCol,
+                                                      int32_t aColCount)
+{
+    // First loop to determine:
+    int32_t nonPctColCount = 0; // number of spanned columns without % isize
+    nscoord nonPctTotalPrefISize = 0; // total pref isize of those columns
+    // and to reduce aSpanPrefPct by columns that already have % isize
+
+    int32_t scol, scol_end;
+    nsTableCellMap *cellMap = mTableFrame->GetCellMap();
+    for (scol = aFirstCol, scol_end = aFirstCol + aColCount;
+         scol < scol_end; ++scol) {
+        nsTableColFrame *scolFrame = mTableFrame->GetColFrame(scol);
+        if (!scolFrame) {
+            NS_ERROR("column frames out of sync with cell map");
+            continue;
+        }
+        float scolPct = scolFrame->GetPrefPercent();
+        if (scolPct == 0.0f) {
+            nonPctTotalPrefISize += scolFrame->GetPrefCoord();
+            if (cellMap->GetNumCellsOriginatingInCol(scol) > 0) {
+                ++nonPctColCount;
+            }
+        } else {
+            aSpanPrefPct -= scolPct;
+        }
+    }
+
+    if (aSpanPrefPct <= 0.0f || nonPctColCount == 0) {
+        // There's no %-isize on the colspan left over to distribute,
+        // or there are no columns to which we could distribute %-isize
+        return;
+    }
+
+    // Second loop, to distribute what remains of aSpanPrefPct
+    // between the non-percent-isize spanned columns
+    const bool spanHasNonPctPref = nonPctTotalPrefISize > 0; // Loop invariant
+    for (scol = aFirstCol, scol_end = aFirstCol + aColCount;
+         scol < scol_end; ++scol) {
+        nsTableColFrame *scolFrame = mTableFrame->GetColFrame(scol);
+        if (!scolFrame) {
+            NS_ERROR("column frames out of sync with cell map");
+            continue;
+        }
+
+        if (scolFrame->GetPrefPercent() == 0.0f) {
+            NS_ASSERTION((!spanHasNonPctPref ||
+                          nonPctTotalPrefISize != 0) &&
+                         nonPctColCount != 0,
+                         "should not be zero if we haven't allocated "
+                         "all pref percent");
+
+            float allocatedPct; // % isize to be given to this column
+            if (spanHasNonPctPref) {
+                // Group so we're multiplying by 1.0f when we need
+                // to use up aSpanPrefPct.
+                allocatedPct = aSpanPrefPct *
+                    (float(scolFrame->GetPrefCoord()) /
+                     float(nonPctTotalPrefISize));
+            } else if (cellMap->GetNumCellsOriginatingInCol(scol) > 0) {
+                // distribute equally when all pref isizes are 0
+                allocatedPct = aSpanPrefPct / float(nonPctColCount);
+            } else {
+                allocatedPct = 0.0f;
+            }
+            // Allocate the percent
+            scolFrame->AddSpanPrefPercent(allocatedPct);
+
+            // To avoid accumulating rounding error from division,
+            // subtract this column's values from the totals.
+            aSpanPrefPct -= allocatedPct;
+            nonPctTotalPrefISize -= scolFrame->GetPrefCoord();
+            if (cellMap->GetNumCellsOriginatingInCol(scol) > 0) {
+                --nonPctColCount;
+            }
+
+            if (!aSpanPrefPct) {
+                // No more span-percent-isize to distribute --> we're done.
+                NS_ASSERTION(spanHasNonPctPref ? 
+                             nonPctTotalPrefISize == 0 :
+                             nonPctColCount == 0,
+                             "No more pct inline-size to distribute, "
+                             "but there are still cols that need some.");
+                return;
+            }
+        }
+    }
+}
+
+void
+BasicTableLayoutStrategy::DistributeISizeToColumns(nscoord aISize,
+                                                   int32_t aFirstCol,
+                                                   int32_t aColCount,
+                                                   BtlsISizeType aISizeType,
+                                                   bool aSpanHasSpecifiedISize)
+{
+    NS_ASSERTION(aISizeType != BTLS_FINAL_ISIZE ||
+                 (aFirstCol == 0 && 
+                  aColCount == mTableFrame->GetCellMap()->GetColCount()),
+            "Computing final column isizes, but didn't get full column range");
+
+    nscoord subtract = 0;
+    // aISize initially includes border-spacing for the boundaries in between
+    // each of the columns. We start at aFirstCol + 1 because the first
+    // in-between boundary would be at the left edge of column aFirstCol + 1
+    for (int32_t col = aFirstCol + 1; col < aFirstCol + aColCount; ++col) {
+        if (mTableFrame->ColumnHasCellSpacingBefore(col)) {
+            // border-spacing isn't part of the basis for percentages.
+            subtract += mTableFrame->GetColSpacing(col - 1);
+        }
+    }
+    if (aISizeType == BTLS_FINAL_ISIZE) {
+        // If we're computing final col-isize, then aISize initially includes
+        // border spacing on the table's far istart + far iend edge, too.  Need
+        // to subtract those out, too.
+        subtract += (mTableFrame->GetColSpacing(-1) +
+                     mTableFrame->GetColSpacing(aColCount));
+    }
+    aISize = NSCoordSaturatingSubtract(aISize, subtract, nscoord_MAX);
+
+    /*
+     * The goal of this function is to distribute |aISize| between the
+     * columns by making an appropriate AddSpanCoords or SetFinalISize
+     * call for each column.  (We call AddSpanCoords if we're 
+     * distributing a column-spanning cell's minimum or preferred isize
+     * to its spanned columns.  We call SetFinalISize if we're 
+     * distributing a table's final isize to its columns.)
+     *
+     * The idea is to either assign one of the following sets of isizes
+     * or a weighted average of two adjacent sets of isizes.  It is not
+     * possible to assign values smaller than the smallest set of
+     * isizes.  However, see below for handling the case of assigning
+     * values larger than the largest set of isizes.  From smallest to
+     * largest, these are:
+     *
+     * 1. [guess_min] Assign all columns their min isize.
+     *
+     * 2. [guess_min_pct] Assign all columns with percentage isizes
+     * their percentage isize, and all other columns their min isize.
+     *
+     * 3. [guess_min_spec] Assign all columns with percentage isizes
+     * their percentage isize, all columns with specified coordinate
+     * isizes their pref isize (since it doesn't matter whether it's the
+     * largest contributor to the pref isize that was the specified
+     * contributor), and all other columns their min isize.
+     *
+     * 4. [guess_pref] Assign all columns with percentage isizes their
+     * specified isize, and all other columns their pref isize.
+     *
+     * If |aISize| is *larger* than what we would assign in (4), then we
+     * expand the columns:
+     *
+     *   a. if any columns without a specified coordinate isize or
+     *   percent isize have nonzero pref isize, in proportion to pref
+     *   isize [total_flex_pref]
+     *
+     *   b. otherwise, if any columns without a specified coordinate
+     *   isize or percent isize, but with cells originating in them,
+     *   have zero pref isize, equally between these
+     *   [numNonSpecZeroISizeCols]
+     *
+     *   c. otherwise, if any columns without percent isize have nonzero
+     *   pref isize, in proportion to pref isize [total_fixed_pref]
+     *
+     *   d. otherwise, if any columns have nonzero percentage isizes, in
+     *   proportion to the percentage isizes [total_pct]
+     *
+     *   e. otherwise, equally.
+     */
+
+    // Loop #1 over the columns, to figure out the four values above so
+    // we know which case we're dealing with.
+
+    nscoord guess_min = 0,
+            guess_min_pct = 0,
+            guess_min_spec = 0,
+            guess_pref = 0,
+            total_flex_pref = 0,
+            total_fixed_pref = 0;
+    float total_pct = 0.0f; // 0.0f to 1.0f
+    int32_t numInfiniteISizeCols = 0;
+    int32_t numNonSpecZeroISizeCols = 0;
+
+    int32_t col;
+    nsTableCellMap *cellMap = mTableFrame->GetCellMap();
+    for (col = aFirstCol; col < aFirstCol + aColCount; ++col) {
+        nsTableColFrame *colFrame = mTableFrame->GetColFrame(col);
+        if (!colFrame) {
+            NS_ERROR("column frames out of sync with cell map");
+            continue;
+        }
+        nscoord min_iSize = colFrame->GetMinCoord();
+        guess_min += min_iSize;
+        if (colFrame->GetPrefPercent() != 0.0f) {
+            float pct = colFrame->GetPrefPercent();
+            total_pct += pct;
+            nscoord val = nscoord(float(aISize) * pct);
+            if (val < min_iSize) {
+                val = min_iSize;
+            }
+            guess_min_pct += val;
+            guess_pref = NSCoordSaturatingAdd(guess_pref, val);
+        } else {
+            nscoord pref_iSize = colFrame->GetPrefCoord();
+            if (pref_iSize == nscoord_MAX) {
+                ++numInfiniteISizeCols;
+            }
+            guess_pref = NSCoordSaturatingAdd(guess_pref, pref_iSize);
+            guess_min_pct += min_iSize;
+            if (colFrame->GetHasSpecifiedCoord()) {
+                // we'll add on the rest of guess_min_spec outside the
+                // loop
+                nscoord delta = NSCoordSaturatingSubtract(pref_iSize, 
+                                                          min_iSize, 0);
+                guess_min_spec = NSCoordSaturatingAdd(guess_min_spec, delta);
+                total_fixed_pref = NSCoordSaturatingAdd(total_fixed_pref, 
+                                                        pref_iSize);
+            } else if (pref_iSize == 0) {
+                if (cellMap->GetNumCellsOriginatingInCol(col) > 0) {
+                    ++numNonSpecZeroISizeCols;
+                }
+            } else {
+                total_flex_pref = NSCoordSaturatingAdd(total_flex_pref,
+                                                       pref_iSize);
+            }
+        }
+    }
+    guess_min_spec = NSCoordSaturatingAdd(guess_min_spec, guess_min_pct);
+
+    // Determine what we're flexing:
+    enum Loop2Type {
+        FLEX_PCT_SMALL, // between (1) and (2) above
+        FLEX_FIXED_SMALL, // between (2) and (3) above
+        FLEX_FLEX_SMALL, // between (3) and (4) above
+        FLEX_FLEX_LARGE, // greater than (4) above, case (a)
+        FLEX_FLEX_LARGE_ZERO, // greater than (4) above, case (b)
+        FLEX_FIXED_LARGE, // greater than (4) above, case (c)
+        FLEX_PCT_LARGE, // greater than (4) above, case (d)
+        FLEX_ALL_LARGE // greater than (4) above, case (e)
+    };
+
+    Loop2Type l2t;
+    // These are constants (over columns) for each case's math.  We use
+    // a pair of nscoords rather than a float so that we can subtract
+    // each column's allocation so we avoid accumulating rounding error.
+    nscoord space; // the amount of extra isize to allocate
+    union {
+        nscoord c;
+        float f;
+    } basis; // the sum of the statistic over columns to divide it
+    if (aISize < guess_pref) {
+        if (aISizeType != BTLS_FINAL_ISIZE && aISize <= guess_min) {
+            // Return early -- we don't have any extra space to distribute.
+            return;
+        }
+        NS_ASSERTION(!(aISizeType == BTLS_FINAL_ISIZE && aISize < guess_min),
+                     "Table inline-size is less than the "
+                     "sum of its columns' min inline-sizes");
+        if (aISize < guess_min_pct) {
+            l2t = FLEX_PCT_SMALL;
+            space = aISize - guess_min;
+            basis.c = guess_min_pct - guess_min;
+        } else if (aISize < guess_min_spec) {
+            l2t = FLEX_FIXED_SMALL;
+            space = aISize - guess_min_pct;
+            basis.c = NSCoordSaturatingSubtract(guess_min_spec, guess_min_pct,
+                                                nscoord_MAX);
+        } else {
+            l2t = FLEX_FLEX_SMALL;
+            space = aISize - guess_min_spec;
+            basis.c = NSCoordSaturatingSubtract(guess_pref, guess_min_spec,
+                                                nscoord_MAX);
+        }
+    } else {
+        space = NSCoordSaturatingSubtract(aISize, guess_pref, nscoord_MAX);
+        if (total_flex_pref > 0) {
+            l2t = FLEX_FLEX_LARGE;
+            basis.c = total_flex_pref;
+        } else if (numNonSpecZeroISizeCols > 0) {
+            l2t = FLEX_FLEX_LARGE_ZERO;
+            basis.c = numNonSpecZeroISizeCols;
+        } else if (total_fixed_pref > 0) {
+            l2t = FLEX_FIXED_LARGE;
+            basis.c = total_fixed_pref;
+        } else if (total_pct > 0.0f) {
+            l2t = FLEX_PCT_LARGE;
+            basis.f = total_pct;
+        } else {
+            l2t = FLEX_ALL_LARGE;
+            basis.c = aColCount;
+        }
+    }
+
+#ifdef DEBUG_dbaron_off
+    printf("ComputeColumnISizes: %d columns in isize %d,\n"
+           "  guesses=[%d,%d,%d,%d], totals=[%d,%d,%f],\n"
+           "  l2t=%d, space=%d, basis.c=%d\n",
+           aColCount, aISize,
+           guess_min, guess_min_pct, guess_min_spec, guess_pref,
+           total_flex_pref, total_fixed_pref, total_pct,
+           l2t, space, basis.c);
+#endif
+
+    for (col = aFirstCol; col < aFirstCol + aColCount; ++col) {
+        nsTableColFrame *colFrame = mTableFrame->GetColFrame(col);
+        if (!colFrame) {
+            NS_ERROR("column frames out of sync with cell map");
+            continue;
+        }
+        nscoord col_iSize;
+
+        float pct = colFrame->GetPrefPercent();
+        if (pct != 0.0f) {
+            col_iSize = nscoord(float(aISize) * pct);
+            nscoord col_min = colFrame->GetMinCoord();
+            if (col_iSize < col_min) {
+                col_iSize = col_min;
+            }
+        } else {
+            col_iSize = colFrame->GetPrefCoord();
+        }
+
+        nscoord col_iSize_before_adjust = col_iSize;
+
+        switch (l2t) {
+            case FLEX_PCT_SMALL:
+                col_iSize = col_iSize_before_adjust = colFrame->GetMinCoord();
+                if (pct != 0.0f) {
+                    nscoord pct_minus_min =
+                        nscoord(float(aISize) * pct) - col_iSize;
+                    if (pct_minus_min > 0) {
+                        float c = float(space) / float(basis.c);
+                        basis.c -= pct_minus_min;
+                        col_iSize += NSToCoordRound(float(pct_minus_min) * c);
+                    }
+                }
+                break;
+            case FLEX_FIXED_SMALL:
+                if (pct == 0.0f) {
+                    NS_ASSERTION(col_iSize == colFrame->GetPrefCoord(),
+                                 "wrong inline-size assigned");
+                    if (colFrame->GetHasSpecifiedCoord()) {
+                        nscoord col_min = colFrame->GetMinCoord();
+                        nscoord pref_minus_min = col_iSize - col_min;
+                        col_iSize = col_iSize_before_adjust = col_min;
+                        if (pref_minus_min != 0) {
+                            float c = float(space) / float(basis.c);
+                            basis.c -= pref_minus_min;
+                            col_iSize += NSToCoordRound(
+                                float(pref_minus_min) * c);
+                        }
+                    } else
+                        col_iSize = col_iSize_before_adjust =
+                            colFrame->GetMinCoord();
+                }
+                break;
+            case FLEX_FLEX_SMALL:
+                if (pct == 0.0f &&
+                    !colFrame->GetHasSpecifiedCoord()) {
+                    NS_ASSERTION(col_iSize == colFrame->GetPrefCoord(),
+                                 "wrong inline-size assigned");
+                    nscoord col_min = colFrame->GetMinCoord();
+                    nscoord pref_minus_min = 
+                        NSCoordSaturatingSubtract(col_iSize, col_min, 0);
+                    col_iSize = col_iSize_before_adjust = col_min;
+                    if (pref_minus_min != 0) {
+                        float c = float(space) / float(basis.c);
+                        // If we have infinite-isize cols, then the standard
+                        // adjustment to col_iSize using 'c' won't work,
+                        // because basis.c and pref_minus_min are both
+                        // nscoord_MAX and will cancel each other out in the
+                        // col_iSize adjustment (making us assign all the
+                        // space to the first inf-isize col).  To correct for
+                        // this, we'll also divide by numInfiniteISizeCols to
+                        // spread the space equally among the inf-isize cols.
+                        if (numInfiniteISizeCols) {
+                            if (colFrame->GetPrefCoord() == nscoord_MAX) {
+                                c = c / float(numInfiniteISizeCols);
+                                --numInfiniteISizeCols;
+                            } else {
+                                c = 0.0f;
+                            }
+                        }
+                        basis.c = NSCoordSaturatingSubtract(basis.c, 
+                                                            pref_minus_min,
+                                                            nscoord_MAX);
+                        col_iSize += NSToCoordRound(
+                            float(pref_minus_min) * c);
+                    }
+                }
+                break;
+            case FLEX_FLEX_LARGE:
+                if (pct == 0.0f &&
+                    !colFrame->GetHasSpecifiedCoord()) {
+                    NS_ASSERTION(col_iSize == colFrame->GetPrefCoord(),
+                                 "wrong inline-size assigned");
+                    if (col_iSize != 0) {
+                        if (space == nscoord_MAX) {
+                            basis.c -= col_iSize;
+                            col_iSize = nscoord_MAX;
+                        } else {
+                            float c = float(space) / float(basis.c);
+                            basis.c -= col_iSize;
+                            col_iSize += NSToCoordRound(float(col_iSize) * c);
+                        }
+                    }
+                }
+                break;
+            case FLEX_FLEX_LARGE_ZERO:
+                if (pct == 0.0f &&
+                    !colFrame->GetHasSpecifiedCoord() &&
+                    cellMap->GetNumCellsOriginatingInCol(col) > 0) {
+
+                    NS_ASSERTION(col_iSize == 0 &&
+                                 colFrame->GetPrefCoord() == 0,
+                                 "Since we're in FLEX_FLEX_LARGE_ZERO case, "
+                                 "all auto-inline-size cols should have zero "
+                                 "pref inline-size.");
+                    float c = float(space) / float(basis.c);
+                    col_iSize += NSToCoordRound(c);
+                    --basis.c;
+                }
+                break;
+            case FLEX_FIXED_LARGE:
+                if (pct == 0.0f) {
+                    NS_ASSERTION(col_iSize == colFrame->GetPrefCoord(),
+                                 "wrong inline-size assigned");
+                    NS_ASSERTION(colFrame->GetHasSpecifiedCoord() ||
+                                 colFrame->GetPrefCoord() == 0,
+                                 "wrong case");
+                    if (col_iSize != 0) {
+                        float c = float(space) / float(basis.c);
+                        basis.c -= col_iSize;
+                        col_iSize += NSToCoordRound(float(col_iSize) * c);
+                    }
+                }
+                break;
+            case FLEX_PCT_LARGE:
+                NS_ASSERTION(pct != 0.0f || colFrame->GetPrefCoord() == 0,
+                             "wrong case");
+                if (pct != 0.0f) {
+                    float c = float(space) / basis.f;
+                    col_iSize += NSToCoordRound(pct * c);
+                    basis.f -= pct;
+                }
+                break;
+            case FLEX_ALL_LARGE:
+                {
+                    float c = float(space) / float(basis.c);
+                    col_iSize += NSToCoordRound(c);
+                    --basis.c;
+                }
+                break;
+        }
+
+        // Only subtract from space if it's a real number.
+        if (space != nscoord_MAX) {
+            NS_ASSERTION(col_iSize != nscoord_MAX,
+                 "How is col_iSize nscoord_MAX if space isn't?");
+            NS_ASSERTION(col_iSize_before_adjust != nscoord_MAX,
+                 "How is col_iSize_before_adjust nscoord_MAX if space isn't?");
+            space -= col_iSize - col_iSize_before_adjust;
+        }
+
+        NS_ASSERTION(col_iSize >= colFrame->GetMinCoord(),
+                     "assigned inline-size smaller than min");
+        
+        // Apply the new isize
+        switch (aISizeType) {
+            case BTLS_MIN_ISIZE:
+                {
+                    // Note: AddSpanCoords requires both a min and pref isize.
+                    // For the pref isize, we'll just pass in our computed
+                    // min isize, because the real pref isize will be at least
+                    // as big
+                    colFrame->AddSpanCoords(col_iSize, col_iSize, 
+                                            aSpanHasSpecifiedISize);
+                }
+                break;
+            case BTLS_PREF_ISIZE:
+                {
+                    // Note: AddSpanCoords requires both a min and pref isize.
+                    // For the min isize, we'll just pass in 0, because
+                    // the real min isize will be at least 0
+                    colFrame->AddSpanCoords(0, col_iSize, 
+                                            aSpanHasSpecifiedISize);
+                }
+                break;
+            case BTLS_FINAL_ISIZE:
+                {
+                    nscoord old_final = colFrame->GetFinalISize();
+                    colFrame->SetFinalISize(col_iSize);
+                    
+                    if (old_final != col_iSize) {
+                        mTableFrame->DidResizeColumns();
+                    }
+                }
+                break;                
+        }
+    }
+    NS_ASSERTION((space == 0 || space == nscoord_MAX) &&
+                 ((l2t == FLEX_PCT_LARGE)
+                    ? (-0.001f < basis.f && basis.f < 0.001f)
+                    : (basis.c == 0 || basis.c == nscoord_MAX)),
+                 "didn't subtract all that we added");
+}