Bug 1173958: whitespace and bracing changes to make FixedTableLayoutStrategy conform to local style, r=jfkthame
authorSimon Montagu <smontagu@smontagu.org>
Fri, 26 Jun 2015 09:03:12 -0700
changeset 281287 958046997215f27d946707195cf783e291eab4e0
parent 281286 047c419b040d1417af17f155d146466cac5395a1
child 281288 d94a96e41f50372c99bad41bd51873c6fdb804a0
push id4932
push userjlund@mozilla.com
push dateMon, 10 Aug 2015 18:23:06 +0000
treeherdermozilla-beta@6dd5a4f5f745 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjfkthame
bugs1173958
milestone41.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1173958: whitespace and bracing changes to make FixedTableLayoutStrategy conform to local style, r=jfkthame
layout/tables/FixedTableLayoutStrategy.cpp
layout/tables/FixedTableLayoutStrategy.h
--- a/layout/tables/FixedTableLayoutStrategy.cpp
+++ b/layout/tables/FixedTableLayoutStrategy.cpp
@@ -1,10 +1,10 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-// vim:cindent:ts=4:et:sw=4:
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+// vim:cindent:ts=2:et:sw=2:
 /* 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/. */
 
 /*
  * Algorithms that determine column and table inline sizes used for
  * CSS2's 'table-layout: fixed'.
  */
@@ -14,422 +14,420 @@
 #include "nsTableColFrame.h"
 #include "nsTableCellFrame.h"
 #include <algorithm>
 
 FixedTableLayoutStrategy::FixedTableLayoutStrategy(nsTableFrame *aTableFrame)
   : nsITableLayoutStrategy(nsITableLayoutStrategy::Fixed)
   , mTableFrame(aTableFrame)
 {
-    MarkIntrinsicISizesDirty();
+  MarkIntrinsicISizesDirty();
 }
 
 /* virtual */
 FixedTableLayoutStrategy::~FixedTableLayoutStrategy()
 {
 }
 
 /* virtual */ nscoord
 FixedTableLayoutStrategy::GetMinISize(nsRenderingContext* aRenderingContext)
 {
-    DISPLAY_MIN_WIDTH(mTableFrame, mMinISize);
-    if (mMinISize != NS_INTRINSIC_WIDTH_UNKNOWN) {
-        return mMinISize;
-    }
+  DISPLAY_MIN_WIDTH(mTableFrame, mMinISize);
+  if (mMinISize != NS_INTRINSIC_WIDTH_UNKNOWN) {
+    return mMinISize;
+  }
 
-    // It's theoretically possible to do something much better here that
-    // depends only on the columns and the first row (where we look at
-    // intrinsic inline sizes inside the first row and then reverse the
-    // algorithm to find the narrowest inline size that would hold all
-    // of those intrinsic inline sizes), but it wouldn't be compatible
-    // with other browsers, or with the use of GetMinISize by
-    // nsTableFrame::ComputeSize to determine the inline size of a fixed
-    // layout table, since CSS2.1 says:
-    //   The width of the table is then the greater of the value of the
-    //   'width' property for the table element and the sum of the
-    //   column widths (plus cell spacing or borders).
+  // It's theoretically possible to do something much better here that
+  // depends only on the columns and the first row (where we look at
+  // intrinsic inline sizes inside the first row and then reverse the
+  // algorithm to find the narrowest inline size that would hold all of
+  // those intrinsic inline sizes), but it wouldn't be compatible with
+  // other browsers, or with the use of GetMinISize by
+  // nsTableFrame::ComputeSize to determine the inline size of a fixed
+  // layout table, since CSS2.1 says:
+  //   The width of the table is then the greater of the value of the
+  //   'width' property for the table element and the sum of the column
+  //   widths (plus cell spacing or borders).
 
-    // XXX Should we really ignore 'min-width' and 'max-width'?
-    // XXX Should we really ignore widths on column groups?
+  // XXX Should we really ignore 'min-width' and 'max-width'?
+  // XXX Should we really ignore widths on column groups?
+
+  nsTableCellMap *cellMap = mTableFrame->GetCellMap();
+  int32_t colCount = cellMap->GetColCount();
+
+  nscoord result = 0;
+
+  if (colCount > 0) {
+    result += mTableFrame->GetColSpacing(-1, colCount);
+  }
 
-    nsTableCellMap *cellMap = mTableFrame->GetCellMap();
-    int32_t colCount = cellMap->GetColCount();
-
-    nscoord result = 0;
-
-    if (colCount > 0) {
-        result += mTableFrame->GetColSpacing(-1, colCount);
+  WritingMode wm = mTableFrame->GetWritingMode();
+  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;
     }
+    nscoord spacing = mTableFrame->GetColSpacing(col);
+    const nsStyleCoord *styleISize = &colFrame->StylePosition()->ISize(wm);
+    if (styleISize->ConvertsToLength()) {
+      result += nsLayoutUtils::ComputeISizeValue(aRenderingContext,
+                                                 colFrame, 0, 0, 0,
+                                                 *styleISize);
+    } else if (styleISize->GetUnit() == eStyleUnit_Percent) {
+      // do nothing
+    } else {
+      NS_ASSERTION(styleISize->GetUnit() == eStyleUnit_Auto ||
+                   styleISize->GetUnit() == eStyleUnit_Enumerated ||
+                   (styleISize->IsCalcUnit() && styleISize->CalcHasPercent()),
+                   "bad inline size");
 
-    WritingMode wm = mTableFrame->GetWritingMode();
-    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;
-        }
-        nscoord spacing = mTableFrame->GetColSpacing(col);
-        const nsStyleCoord *styleISize = &colFrame->StylePosition()->ISize(wm);
-        if (styleISize->ConvertsToLength()) {
-            result += nsLayoutUtils::ComputeISizeValue(aRenderingContext,
-                        colFrame, 0, 0, 0, *styleISize);
+      // The 'table-layout: fixed' algorithm considers only cells in the
+      // first row.
+      bool originates;
+      int32_t colSpan;
+      nsTableCellFrame *cellFrame = cellMap->GetCellInfoAt(0, col, &originates,
+                                                           &colSpan);
+      if (cellFrame) {
+        styleISize = &cellFrame->StylePosition()->ISize(wm);
+        if (styleISize->ConvertsToLength() ||
+            (styleISize->GetUnit() == eStyleUnit_Enumerated &&
+             (styleISize->GetIntValue() == NS_STYLE_WIDTH_MAX_CONTENT ||
+              styleISize->GetIntValue() == NS_STYLE_WIDTH_MIN_CONTENT))) {
+          nscoord cellISize =
+            nsLayoutUtils::IntrinsicForContainer(aRenderingContext, cellFrame,
+                                                 nsLayoutUtils::MIN_ISIZE);
+          if (colSpan > 1) {
+            // If a column-spanning cell is in the first row, split up
+            // the space evenly.  (XXX This isn't quite right if some of
+            // the columns it's in have specified inline sizes.  Should
+            // we care?)
+            cellISize = ((cellISize + spacing) / colSpan) - spacing;
+          }
+          result += cellISize;
         } else if (styleISize->GetUnit() == eStyleUnit_Percent) {
-            // do nothing
-        } else {
-            NS_ASSERTION(styleISize->GetUnit() == eStyleUnit_Auto ||
-                         styleISize->GetUnit() == eStyleUnit_Enumerated ||
-                         (styleISize->IsCalcUnit() && styleISize->CalcHasPercent()),
-                         "bad inline size");
+          if (colSpan > 1) {
+            // XXX Can this force columns to negative inline sizes?
+            result -= spacing * (colSpan - 1);
+          }
+        }
+        // else, for 'auto', '-moz-available', '-moz-fit-content',
+        // and 'calc()' with percentages, do nothing
+      }
+    }
+  }
 
-            // The 'table-layout: fixed' algorithm considers only cells
-            // in the first row.
-            bool originates;
-            int32_t colSpan;
-            nsTableCellFrame *cellFrame =
-                cellMap->GetCellInfoAt(0, col, &originates, &colSpan);
-            if (cellFrame) {
-                styleISize = &cellFrame->StylePosition()->ISize(wm);
-                if (styleISize->ConvertsToLength() ||
-                    (styleISize->GetUnit() == eStyleUnit_Enumerated &&
-                     (styleISize->GetIntValue() == NS_STYLE_WIDTH_MAX_CONTENT ||
-                      styleISize->GetIntValue() ==
-                      NS_STYLE_WIDTH_MIN_CONTENT))) {
-                    nscoord cellISize = nsLayoutUtils::IntrinsicForContainer(
-                        aRenderingContext, cellFrame, nsLayoutUtils::MIN_ISIZE);
-                    if (colSpan > 1) {
-                        // If a column-spanning cell is in the first
-                        // row, split up the space evenly.  (XXX This
-                        // isn't quite right if some of the columns it's
-                        // in have specified inline sizes.  Should we
-                        // care?)
-                        cellISize = ((cellISize + spacing) / colSpan) - spacing;
-                    }
-                    result += cellISize;
-                } else if (styleISize->GetUnit() == eStyleUnit_Percent) {
-                    if (colSpan > 1) {
-                        // XXX Can this force columns to negative
-                        // inline sizes?
-                        result -= spacing * (colSpan - 1);
-                    }
-                }
-                // else, for 'auto', '-moz-available', '-moz-fit-content',
-                // and 'calc()' with percentages, do nothing
-            }
-        }
-    }
-
-    return (mMinISize = result);
+  return (mMinISize = result);
 }
 
 /* virtual */ nscoord
 FixedTableLayoutStrategy::GetPrefISize(nsRenderingContext* aRenderingContext,
                                        bool aComputingSize)
 {
-    // It's theoretically possible to do something much better here that
-    // depends only on the columns and the first row (where we look at
-    // intrinsic inline sizes inside the first row and then reverse the
-    // algorithm to find the narrowest inline size that would hold all
-    // of those intrinsic inline sizes), but it wouldn't be compatible
-    // with other browsers.
-    nscoord result = nscoord_MAX;
-    DISPLAY_PREF_WIDTH(mTableFrame, result);
-    return result;
+  // It's theoretically possible to do something much better here that
+  // depends only on the columns and the first row (where we look at
+  // intrinsic inline sizes inside the first row and then reverse the
+  // algorithm to find the narrowest inline size that would hold all of
+  // those intrinsic inline sizes), but it wouldn't be compatible with
+  // other browsers.
+  nscoord result = nscoord_MAX;
+  DISPLAY_PREF_WIDTH(mTableFrame, result);
+  return result;
 }
 
 /* virtual */ void
 FixedTableLayoutStrategy::MarkIntrinsicISizesDirty()
 {
-    mMinISize = NS_INTRINSIC_WIDTH_UNKNOWN;
-    mLastCalcISize = nscoord_MIN;
+  mMinISize = NS_INTRINSIC_WIDTH_UNKNOWN;
+  mLastCalcISize = nscoord_MIN;
 }
 
 static inline nscoord
 AllocateUnassigned(nscoord aUnassignedSpace, float aShare)
 {
-    if (aShare == 1.0f) {
-        // This happens when the numbers we're dividing to get aShare
-        // are equal.  We want to return unassignedSpace exactly, even
-        // if it can't be precisely round-tripped through float.
-        return aUnassignedSpace;
-    }
-    return NSToCoordRound(float(aUnassignedSpace) * aShare);
+  if (aShare == 1.0f) {
+    // This happens when the numbers we're dividing to get aShare are
+    // equal.  We want to return unassignedSpace exactly, even if it
+    // can't be precisely round-tripped through float.
+    return aUnassignedSpace;
+  }
+  return NSToCoordRound(float(aUnassignedSpace) * aShare);
 }
 
 /* virtual */ void
 FixedTableLayoutStrategy::ComputeColumnISizes(const nsHTMLReflowState& aReflowState)
 {
-    nscoord tableISize = aReflowState.ComputedISize();
+  nscoord tableISize = aReflowState.ComputedISize();
+
+  if (mLastCalcISize == tableISize) {
+    return;
+  }
+  mLastCalcISize = tableISize;
+
+  nsTableCellMap *cellMap = mTableFrame->GetCellMap();
+  int32_t colCount = cellMap->GetColCount();
+
+  if (colCount == 0) {
+    // No Columns - nothing to compute
+    return;
+  }
+
+  // border-spacing isn't part of the basis for percentages.
+  tableISize -= mTableFrame->GetColSpacing(-1, colCount);
 
-    if (mLastCalcISize == tableISize) {
-        return;
-    }
-    mLastCalcISize = tableISize;
+  // store the old column inline sizes. We might call SetFinalISize
+  // multiple times on the columns, due to this we can't compare at the
+  // last call that the inline size has changed with respect to the last
+  // call to ComputeColumnISizes. In order to overcome this we store the
+  // old values in this array. A single call to SetFinalISize would make
+  // it possible to call GetFinalISize before and to compare when
+  // setting the final inline size.
+  nsTArray<nscoord> oldColISizes;
+
+  // XXX This ignores the 'min-width' and 'max-width' properties
+  // throughout.  Then again, that's what the CSS spec says to do.
+
+  // XXX Should we really ignore widths on column groups?
+
+  uint32_t unassignedCount = 0;
+  nscoord unassignedSpace = tableISize;
+  const nscoord unassignedMarker = nscoord_MIN;
+
+  // We use the PrefPercent on the columns to store the percentages
+  // used to compute column inline sizes in case we need to shrink or
+  // expand the columns.
+  float pctTotal = 0.0f;
+
+  // Accumulate the total specified (non-percent) on the columns for
+  // distributing excess inline size to the columns.
+  nscoord specTotal = 0;
 
-    nsTableCellMap *cellMap = mTableFrame->GetCellMap();
-    int32_t colCount = cellMap->GetColCount();
+  WritingMode wm = mTableFrame->GetWritingMode();
+  for (int32_t col = 0; col < colCount; ++col) {
+    nsTableColFrame *colFrame = mTableFrame->GetColFrame(col);
+    if (!colFrame) {
+      oldColISizes.AppendElement(0);
+      NS_ERROR("column frames out of sync with cell map");
+      continue;
+    }
+    oldColISizes.AppendElement(colFrame->GetFinalISize());
+    colFrame->ResetPrefPercent();
+    const nsStyleCoord *styleISize = &colFrame->StylePosition()->ISize(wm);
+    nscoord colISize;
+    if (styleISize->ConvertsToLength()) {
+      colISize = nsLayoutUtils::ComputeISizeValue(aReflowState.rendContext,
+                                                  colFrame, 0, 0, 0,
+                                                  *styleISize);
+      specTotal += colISize;
+    } else if (styleISize->GetUnit() == eStyleUnit_Percent) {
+      float pct = styleISize->GetPercentValue();
+      colISize = NSToCoordFloor(pct * float(tableISize));
+      colFrame->AddPrefPercent(pct);
+      pctTotal += pct;
+    } else {
+      NS_ASSERTION(styleISize->GetUnit() == eStyleUnit_Auto ||
+                   styleISize->GetUnit() == eStyleUnit_Enumerated ||
+                   (styleISize->IsCalcUnit() && styleISize->CalcHasPercent()),
+                   "bad inline size");
 
-    if (colCount == 0) {
-        // No Columns - nothing to compute
-        return;
+      // The 'table-layout: fixed' algorithm considers only cells in the
+      // first row.
+      bool originates;
+      int32_t colSpan;
+      nsTableCellFrame *cellFrame = cellMap->GetCellInfoAt(0, col, &originates,
+                                                           &colSpan);
+      if (cellFrame) {
+        styleISize = &cellFrame->StylePosition()->ISize(wm);
+        if (styleISize->ConvertsToLength() ||
+            (styleISize->GetUnit() == eStyleUnit_Enumerated &&
+             (styleISize->GetIntValue() == NS_STYLE_WIDTH_MAX_CONTENT ||
+              styleISize->GetIntValue() == NS_STYLE_WIDTH_MIN_CONTENT))) {
+          // XXX This should use real percentage padding
+          // Note that the difference between MIN_ISIZE and PREF_ISIZE
+          // shouldn't matter for any of these values of styleISize; use
+          // MIN_ISIZE for symmetry with GetMinISize above, just in case
+          // there is a difference.
+          colISize =
+            nsLayoutUtils::IntrinsicForContainer(aReflowState.rendContext,
+                                                 cellFrame,
+                                                 nsLayoutUtils::MIN_ISIZE);
+        } else if (styleISize->GetUnit() == eStyleUnit_Percent) {
+          // XXX This should use real percentage padding
+          nsIFrame::IntrinsicISizeOffsetData offsets =
+            cellFrame->IntrinsicISizeOffsets();
+          float pct = styleISize->GetPercentValue();
+          colISize = NSToCoordFloor(pct * float(tableISize));
+
+          nscoord boxSizingAdjust = 0;
+          switch (cellFrame->StylePosition()->mBoxSizing) {
+            case NS_STYLE_BOX_SIZING_CONTENT:
+              boxSizingAdjust += offsets.hPadding;
+              // Fall through
+            case NS_STYLE_BOX_SIZING_PADDING:
+              boxSizingAdjust += offsets.hBorder;
+              // Fall through
+            case NS_STYLE_BOX_SIZING_BORDER:
+              // Don't add anything
+              break;
+          }
+          colISize += boxSizingAdjust;
+
+          pct /= float(colSpan);
+          colFrame->AddPrefPercent(pct);
+          pctTotal += pct;
+        } else {
+          // 'auto', '-moz-available', '-moz-fit-content', and 'calc()'
+          // with percentages
+          colISize = unassignedMarker;
+        }
+        if (colISize != unassignedMarker) {
+          if (colSpan > 1) {
+            // If a column-spanning cell is in the first row, split up
+            // the space evenly.  (XXX This isn't quite right if some of
+            // the columns it's in have specified iSizes.  Should we
+            // care?)
+            nscoord spacing = mTableFrame->GetColSpacing(col);
+            colISize = ((colISize + spacing) / colSpan) - spacing;
+            if (colISize < 0) {
+              colISize = 0;
+            }
+          }
+          if (styleISize->GetUnit() != eStyleUnit_Percent) {
+            specTotal += colISize;
+          }
+        }
+      } else {
+        colISize = unassignedMarker;
+      }
     }
 
-    // border-spacing isn't part of the basis for percentages.
-    tableISize -= mTableFrame->GetColSpacing(-1, colCount);
+    colFrame->SetFinalISize(colISize);
 
-    // store the old column inline sizes. We might call SetFinalISize
-    // multiple times on the columns, due to this we can't compare at
-    // the last call that the inline size has changed with respect to
-    // the last call to ComputeColumnISizes. In order to overcome this
-    // we store the old values in this array. A single call to
-    // SetFinalISize would make it possible to call GetFinalISize before
-    // and to compare when setting the final inline size.
-    nsTArray<nscoord> oldColISizes;
-
-    // XXX This ignores the 'min-width' and 'max-width' properties
-    // throughout.  Then again, that's what the CSS spec says to do.
+    if (colISize == unassignedMarker) {
+      ++unassignedCount;
+    } else {
+      unassignedSpace -= colISize;
+    }
+  }
 
-    // XXX Should we really ignore widths on column groups?
-
-    uint32_t unassignedCount = 0;
-    nscoord unassignedSpace = tableISize;
-    const nscoord unassignedMarker = nscoord_MIN;
-
-    // We use the PrefPercent on the columns to store the percentages
-    // used to compute column inline sizes in case we need to shrink
-    // or expand the columns.
-    float pctTotal = 0.0f;
-
-    // Accumulate the total specified (non-percent) on the columns for
-    // distributing excess inline size to the columns.
-    nscoord specTotal = 0;
-
-    WritingMode wm = mTableFrame->GetWritingMode();
-    for (int32_t col = 0; col < colCount; ++col) {
+  if (unassignedSpace < 0) {
+    if (pctTotal > 0) {
+      // If the columns took up too much space, reduce those that had
+      // percentage inline sizes.  The spec doesn't say to do this, but
+      // we've always done it in the past, and so does WinIE6.
+      nscoord pctUsed = NSToCoordFloor(pctTotal * float(tableISize));
+      nscoord reduce = std::min(pctUsed, -unassignedSpace);
+      float reduceRatio = float(reduce) / pctTotal;
+      for (int32_t col = 0; col < colCount; ++col) {
         nsTableColFrame *colFrame = mTableFrame->GetColFrame(col);
         if (!colFrame) {
-            oldColISizes.AppendElement(0);
-            NS_ERROR("column frames out of sync with cell map");
-            continue;
+          NS_ERROR("column frames out of sync with cell map");
+          continue;
         }
-        oldColISizes.AppendElement(colFrame->GetFinalISize());
-        colFrame->ResetPrefPercent();
-        const nsStyleCoord *styleISize = &colFrame->StylePosition()->ISize(wm);
-        nscoord colISize;
-        if (styleISize->ConvertsToLength()) {
-            colISize = nsLayoutUtils::ComputeISizeValue(
-                         aReflowState.rendContext,
-                         colFrame, 0, 0, 0, *styleISize);
-            specTotal += colISize;
-        } else if (styleISize->GetUnit() == eStyleUnit_Percent) {
-            float pct = styleISize->GetPercentValue();
-            colISize = NSToCoordFloor(pct * float(tableISize));
-            colFrame->AddPrefPercent(pct);
-            pctTotal += pct;
-        } else {
-            NS_ASSERTION(styleISize->GetUnit() == eStyleUnit_Auto ||
-                         styleISize->GetUnit() == eStyleUnit_Enumerated ||
-                         (styleISize->IsCalcUnit() &&
-                          styleISize->CalcHasPercent()),
-                         "bad inline size");
-
-            // The 'table-layout: fixed' algorithm considers only cells
-            // in the first row.
-            bool originates;
-            int32_t colSpan;
-            nsTableCellFrame *cellFrame =
-                cellMap->GetCellInfoAt(0, col, &originates, &colSpan);
-            if (cellFrame) {
-                styleISize = &cellFrame->StylePosition()->ISize(wm);
-                if (styleISize->ConvertsToLength() ||
-                    (styleISize->GetUnit() == eStyleUnit_Enumerated &&
-                     (styleISize->GetIntValue() == NS_STYLE_WIDTH_MAX_CONTENT ||
-                      styleISize->GetIntValue() ==
-                      NS_STYLE_WIDTH_MIN_CONTENT))) {
-                    // XXX This should use real percentage padding
-                    // Note that the difference between MIN_ISIZE and
-                    // PREF_ISIZE shouldn't matter for any of these
-                    // values of styleISize; use MIN_ISIZE for symmetry
-                    // with GetMinISize above, just in case there is a
-                    // difference.
-                    colISize = nsLayoutUtils::IntrinsicForContainer(
-                                 aReflowState.rendContext,
-                                 cellFrame, nsLayoutUtils::MIN_ISIZE);
-                } else if (styleISize->GetUnit() == eStyleUnit_Percent) {
-                    // XXX This should use real percentage padding
-                    nsIFrame::IntrinsicISizeOffsetData offsets =
-                        cellFrame->IntrinsicISizeOffsets();
-                    float pct = styleISize->GetPercentValue();
-                    colISize = NSToCoordFloor(pct * float(tableISize));
-
-                    nscoord boxSizingAdjust = 0;
-                    switch (cellFrame->StylePosition()->mBoxSizing) {
-                      case NS_STYLE_BOX_SIZING_CONTENT:
-                        boxSizingAdjust += offsets.hPadding;
-                        // Fall through
-                      case NS_STYLE_BOX_SIZING_PADDING:
-                        boxSizingAdjust += offsets.hBorder;
-                        // Fall through
-                      case NS_STYLE_BOX_SIZING_BORDER:
-                        // Don't add anything
-                        break;
-                    }
-                    colISize += boxSizingAdjust;
-
-                    pct /= float(colSpan);
-                    colFrame->AddPrefPercent(pct);
-                    pctTotal += pct;
-                } else {
-                    // 'auto', '-moz-available', '-moz-fit-content', and
-                    // 'calc()' with percentages
-                    colISize = unassignedMarker;
-                }
-                if (colISize != unassignedMarker) {
-                    if (colSpan > 1) {
-                        // If a column-spanning cell is in the first
-                        // row, split up the space evenly.  (XXX This
-                        // isn't quite right if some of the columns it's
-                        // in have specified iSizes.  Should we care?)
-                        nscoord spacing = mTableFrame->GetColSpacing(col);
-                        colISize = ((colISize + spacing) / colSpan) - spacing;
-                        if (colISize < 0)
-                            colISize = 0;
-                    }
-                    if (styleISize->GetUnit() != eStyleUnit_Percent) {
-                        specTotal += colISize;
-                    }
-                }
-            } else {
-                colISize = unassignedMarker;
-            }
+        nscoord colISize = colFrame->GetFinalISize();
+        colISize -= NSToCoordFloor(colFrame->GetPrefPercent() * reduceRatio);
+        if (colISize < 0) {
+          colISize = 0;
         }
-
         colFrame->SetFinalISize(colISize);
-
-        if (colISize == unassignedMarker) {
-            ++unassignedCount;
-        } else {
-            unassignedSpace -= colISize;
-        }
+      }
     }
+    unassignedSpace = 0;
+  }
 
-    if (unassignedSpace < 0) {
-        if (pctTotal > 0) {
-            // If the columns took up too much space, reduce those that
-            // had percentage inline sizes.  The spec doesn't say to do
-            // this, but we've always done it in the past, and so does
-            // WinIE6.
-            nscoord pctUsed = NSToCoordFloor(pctTotal * float(tableISize));
-            nscoord reduce = std::min(pctUsed, -unassignedSpace);
-            float reduceRatio = float(reduce) / pctTotal;
-            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;
-                }
-                nscoord colISize = colFrame->GetFinalISize();
-                colISize -= NSToCoordFloor(colFrame->GetPrefPercent() *
-                                           reduceRatio);
-                if (colISize < 0)
-                    colISize = 0;
-                colFrame->SetFinalISize(colISize);
-            }
-        }
-        unassignedSpace = 0;
+  if (unassignedCount > 0) {
+    // The spec says to distribute the remaining space evenly among
+    // the columns.
+    nscoord toAssign = unassignedSpace / unassignedCount;
+    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 (colFrame->GetFinalISize() == unassignedMarker) {
+        colFrame->SetFinalISize(toAssign);
+      }
     }
-
-    if (unassignedCount > 0) {
-        // The spec says to distribute the remaining space evenly among
-        // the columns.
-        nscoord toAssign = unassignedSpace / unassignedCount;
-        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 (colFrame->GetFinalISize() == unassignedMarker)
-                colFrame->SetFinalISize(toAssign);
-        }
-    } else if (unassignedSpace > 0) {
-        // The spec doesn't say how to distribute the unassigned space.
-        if (specTotal > 0) {
-            // Distribute proportionally to non-percentage columns.
-            nscoord specUndist = specTotal;
-            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 (colFrame->GetPrefPercent() == 0.0f) {
-                    NS_ASSERTION(colFrame->GetFinalISize() <= specUndist,
-                                 "inline sizes don't add up");
-                    nscoord toAdd = AllocateUnassigned(unassignedSpace,
-                       float(colFrame->GetFinalISize()) / float(specUndist));
-                    specUndist -= colFrame->GetFinalISize();
-                    colFrame->SetFinalISize(colFrame->GetFinalISize() + toAdd);
-                    unassignedSpace -= toAdd;
-                    if (specUndist <= 0) {
-                        NS_ASSERTION(specUndist == 0,
-                                     "math should be exact");
-                        break;
-                    }
-                }
-            }
-            NS_ASSERTION(unassignedSpace == 0, "failed to redistribute");
-        } else if (pctTotal > 0) {
-            // Distribute proportionally to percentage columns.
-            float pctUndist = pctTotal;
-            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 (pctUndist < colFrame->GetPrefPercent()) {
-                    // This can happen with floating-point math.
-                    NS_ASSERTION(colFrame->GetPrefPercent() - pctUndist
-                                   < 0.0001,
-                                 "inline sizes don't add up");
-                    pctUndist = colFrame->GetPrefPercent();
-                }
-                nscoord toAdd = AllocateUnassigned(unassignedSpace,
-                    colFrame->GetPrefPercent() / pctUndist);
-                colFrame->SetFinalISize(colFrame->GetFinalISize() + toAdd);
-                unassignedSpace -= toAdd;
-                pctUndist -= colFrame->GetPrefPercent();
-                if (pctUndist <= 0.0f) {
-                    break;
-                }
-            }
-            NS_ASSERTION(unassignedSpace == 0, "failed to redistribute");
-        } else {
-            // Distribute equally to the zero-iSize columns.
-            int32_t colsRemaining = 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;
-                }
-                NS_ASSERTION(colFrame->GetFinalISize() == 0, "yikes");
-                nscoord toAdd = AllocateUnassigned(unassignedSpace,
-                                                   1.0f / float(colsRemaining));
-                colFrame->SetFinalISize(toAdd);
-                unassignedSpace -= toAdd;
-                --colsRemaining;
-            }
-            NS_ASSERTION(unassignedSpace == 0, "failed to redistribute");
-        }
-    }
-    for (int32_t col = 0; col < colCount; ++col) {
+  } else if (unassignedSpace > 0) {
+    // The spec doesn't say how to distribute the unassigned space.
+    if (specTotal > 0) {
+      // Distribute proportionally to non-percentage columns.
+      nscoord specUndist = specTotal;
+      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;
+          NS_ERROR("column frames out of sync with cell map");
+          continue;
+        }
+        if (colFrame->GetPrefPercent() == 0.0f) {
+          NS_ASSERTION(colFrame->GetFinalISize() <= specUndist,
+                       "inline sizes don't add up");
+          nscoord toAdd = AllocateUnassigned(unassignedSpace,
+                                             float(colFrame->GetFinalISize()) /
+                                              float(specUndist));
+          specUndist -= colFrame->GetFinalISize();
+          colFrame->SetFinalISize(colFrame->GetFinalISize() + toAdd);
+          unassignedSpace -= toAdd;
+          if (specUndist <= 0) {
+            NS_ASSERTION(specUndist == 0, "math should be exact");
+            break;
+          }
+        }
+      }
+      NS_ASSERTION(unassignedSpace == 0, "failed to redistribute");
+    } else if (pctTotal > 0) {
+      // Distribute proportionally to percentage columns.
+      float pctUndist = pctTotal;
+      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 (pctUndist < colFrame->GetPrefPercent()) {
+          // This can happen with floating-point math.
+          NS_ASSERTION(colFrame->GetPrefPercent() - pctUndist < 0.0001,
+                       "inline sizes don't add up");
+          pctUndist = colFrame->GetPrefPercent();
         }
-        if (oldColISizes.ElementAt(col) != colFrame->GetFinalISize()) {
-            mTableFrame->DidResizeColumns();
-            break;
+        nscoord toAdd = AllocateUnassigned(unassignedSpace,
+                                           colFrame->GetPrefPercent() /
+                                             pctUndist);
+        colFrame->SetFinalISize(colFrame->GetFinalISize() + toAdd);
+        unassignedSpace -= toAdd;
+        pctUndist -= colFrame->GetPrefPercent();
+        if (pctUndist <= 0.0f) {
+          break;
+        }
+      }
+      NS_ASSERTION(unassignedSpace == 0, "failed to redistribute");
+    } else {
+      // Distribute equally to the zero-iSize columns.
+      int32_t colsRemaining = 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;
         }
+        NS_ASSERTION(colFrame->GetFinalISize() == 0, "yikes");
+        nscoord toAdd = AllocateUnassigned(unassignedSpace,
+                                           1.0f / float(colsRemaining));
+        colFrame->SetFinalISize(toAdd);
+        unassignedSpace -= toAdd;
+        --colsRemaining;
+      }
+      NS_ASSERTION(unassignedSpace == 0, "failed to redistribute");
     }
+  }
+  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 (oldColISizes.ElementAt(col) != colFrame->GetFinalISize()) {
+      mTableFrame->DidResizeColumns();
+      break;
+    }
+  }
 }
--- a/layout/tables/FixedTableLayoutStrategy.h
+++ b/layout/tables/FixedTableLayoutStrategy.h
@@ -1,10 +1,10 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-// vim:cindent:ts=4:et:sw=4:
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+// vim:cindent:ts=2:et:sw=2:
 /* 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/. */
 
 /*
  * Algorithms that determine column and table isizes used for CSS2's
  * 'table-layout: fixed'.
  */
@@ -15,25 +15,26 @@
 #include "mozilla/Attributes.h"
 #include "nsITableLayoutStrategy.h"
 
 class nsTableFrame;
 
 class FixedTableLayoutStrategy : public nsITableLayoutStrategy
 {
 public:
-    explicit FixedTableLayoutStrategy(nsTableFrame *aTableFrame);
-    virtual ~FixedTableLayoutStrategy();
+  explicit FixedTableLayoutStrategy(nsTableFrame *aTableFrame);
+  virtual ~FixedTableLayoutStrategy();
 
-    // nsITableLayoutStrategy implementation
-    virtual nscoord GetMinISize(nsRenderingContext* aRenderingContext) override;
-    virtual nscoord GetPrefISize(nsRenderingContext* aRenderingContext,
-                                 bool aComputingSize) override;
-    virtual void MarkIntrinsicISizesDirty() override;
-    virtual void ComputeColumnISizes(const nsHTMLReflowState& aReflowState) override;
+  // nsITableLayoutStrategy implementation
+  virtual nscoord GetMinISize(nsRenderingContext* aRenderingContext) override;
+  virtual nscoord GetPrefISize(nsRenderingContext* aRenderingContext,
+                               bool aComputingSize) override;
+  virtual void MarkIntrinsicISizesDirty() override;
+  virtual void ComputeColumnISizes(const nsHTMLReflowState& aReflowState)
+               override;
 
 private:
-    nsTableFrame *mTableFrame;
-    nscoord mMinISize;
-    nscoord mLastCalcISize;
+  nsTableFrame *mTableFrame;
+  nscoord mMinISize;
+  nscoord mLastCalcISize;
 };
 
 #endif /* !defined(FixedTableLayoutStrategy_h_) */