The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* vim: set ts=2 sw=2 et tw=80: */

 /* 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/. */

 #include "mozilla/Likely.h"

 #include "mozilla/MathAlgorithms.h"

 #include "nsCOMPtr.h"

 #include "nsTableFrame.h"

 #include "nsRenderingContext.h"

 #include "nsStyleContext.h"

 #include "nsStyleConsts.h"

 #include "nsIContent.h"

 #include "nsCellMap.h"

 #include "nsTableCellFrame.h"

 #include "nsHTMLParts.h"

 #include "nsTableColFrame.h"

 #include "nsTableColGroupFrame.h"

 #include "nsTableRowFrame.h"

 #include "nsTableRowGroupFrame.h"

 #include "nsTableOuterFrame.h"

 #include "nsTablePainter.h"

 #include "BasicTableLayoutStrategy.h"

 #include "FixedTableLayoutStrategy.h"

 #include "nsPresContext.h"

 #include "nsContentUtils.h"

 #include "nsCSSRendering.h"

 #include "nsGkAtoms.h"

 #include "nsCSSAnonBoxes.h"

 #include "nsIPresShell.h"

 #include "nsIDOMElement.h"

 #include "nsIDOMHTMLElement.h"

 #include "nsIScriptError.h"

 #include "nsFrameManager.h"

 #include "nsError.h"

 #include "nsAutoPtr.h"

 #include "nsCSSFrameConstructor.h"

 #include "nsStyleSet.h"

 #include "nsDisplayList.h"

 #include "nsIScrollableFrame.h"

 #include "nsCSSProps.h"

 #include "RestyleTracker.h"

 #include <algorithm>

 using namespace mozilla;

 using namespace mozilla::layout;

 /********************************************************************************

  ** nsTableReflowState                                                         **

  ********************************************************************************/

 struct nsTableReflowState {

   // the real reflow state

   const nsHTMLReflowState& reflowState;

   // The table's available size

   nsSize availSize;

   // Stationary x-offset

   nscoord x;

   // Running y-offset

   nscoord y;

   nsTableReflowState(nsPresContext&           aPresContext,

                      const nsHTMLReflowState& aReflowState,

                      nsTableFrame&            aTableFrame,

                      nscoord                  aAvailWidth,

                      nscoord                  aAvailHeight)

     : reflowState(aReflowState)

   {

     Init(aPresContext, aTableFrame, aAvailWidth, aAvailHeight);

   }

   void Init(nsPresContext&  aPresContext,

             nsTableFrame&   aTableFrame,

             nscoord         aAvailWidth,

             nscoord         aAvailHeight)

   {

     nsTableFrame* table = static_cast<nsTableFrame*>(aTableFrame.FirstInFlow());

     nsMargin borderPadding = table->GetChildAreaOffset(&reflowState);

     nscoord cellSpacingX = table->GetCellSpacingX();

     x = borderPadding.left + cellSpacingX;

     y = borderPadding.top; //cellspacing added during reflow

     availSize.width  = aAvailWidth;

     if (NS_UNCONSTRAINEDSIZE != availSize.width) {

       availSize.width -= borderPadding.left + borderPadding.right

                          + (2 * cellSpacingX);

       availSize.width = std::max(0, availSize.width);

     }

     availSize.height = aAvailHeight;

     if (NS_UNCONSTRAINEDSIZE != availSize.height) {

       availSize.height -= borderPadding.top + borderPadding.bottom

                           + (2 * table->GetCellSpacingY());

       availSize.height = std::max(0, availSize.height);

     }

   }

   nsTableReflowState(nsPresContext&           aPresContext,

                      const nsHTMLReflowState& aReflowState,

                      nsTableFrame&            aTableFrame)

     : reflowState(aReflowState)

   {

     Init(aPresContext, aTableFrame, aReflowState.AvailableWidth(), aReflowState.AvailableHeight());

   }

 };

 /********************************************************************************

  ** nsTableFrame                                                               **

  ********************************************************************************/

 struct BCPropertyData

 {

   BCPropertyData() : mTopBorderWidth(0), mRightBorderWidth(0),

                      mBottomBorderWidth(0), mLeftBorderWidth(0),

                      mLeftCellBorderWidth(0), mRightCellBorderWidth(0) {}

   nsIntRect mDamageArea;

   BCPixelSize mTopBorderWidth;

   BCPixelSize mRightBorderWidth;

   BCPixelSize mBottomBorderWidth;

   BCPixelSize mLeftBorderWidth;

   BCPixelSize mLeftCellBorderWidth;

   BCPixelSize mRightCellBorderWidth;

 };

 nsIFrame*

 nsTableFrame::GetParentStyleContextFrame() const

 {

   // Since our parent, the table outer frame, returned this frame, we

   // must return whatever our parent would normally have returned.

   NS_PRECONDITION(mParent, "table constructed without outer table");

   if (!mContent->GetParent() && !StyleContext()->GetPseudo()) {

     // We're the root.  We have no style context parent.

     return nullptr;

   }

   return static_cast<nsFrame*>(GetParent())->DoGetParentStyleContextFrame();

 }

 nsIAtom*

 nsTableFrame::GetType() const

 {

   return nsGkAtoms::tableFrame;

 }

 nsTableFrame::nsTableFrame(nsStyleContext* aContext)

   : nsContainerFrame(aContext),

     mCellMap(nullptr),

     mTableLayoutStrategy(nullptr)

 {

   memset(&mBits, 0, sizeof(mBits));

 }

 void

 nsTableFrame::Init(nsIContent*      aContent,

                    nsIFrame*        aParent,

                    nsIFrame*        aPrevInFlow)

 {

   NS_PRECONDITION(!mCellMap, "Init called twice");

   NS_PRECONDITION(!aPrevInFlow ||

                   aPrevInFlow->GetType() == nsGkAtoms::tableFrame,

                   "prev-in-flow must be of same type");

   // Let the base class do its processing

   nsContainerFrame::Init(aContent, aParent, aPrevInFlow);

   // see if border collapse is on, if so set it

   const nsStyleTableBorder* tableStyle = StyleTableBorder();

   bool borderCollapse = (NS_STYLE_BORDER_COLLAPSE == tableStyle->mBorderCollapse);

   SetBorderCollapse(borderCollapse);

   // Create the cell map if this frame is the first-in-flow.

   if (!aPrevInFlow) {

     mCellMap = new nsTableCellMap(*this, borderCollapse);

   }

   if (aPrevInFlow) {

     // set my width, because all frames in a table flow are the same width and

     // code in nsTableOuterFrame depends on this being set

     mRect.width = aPrevInFlow->GetSize().width;

   }

   else {

     NS_ASSERTION(!mTableLayoutStrategy, "strategy was created before Init was called");

     // create the strategy

     if (IsAutoLayout())

       mTableLayoutStrategy = new BasicTableLayoutStrategy(this);

     else

       mTableLayoutStrategy = new FixedTableLayoutStrategy(this);

   }

 }

 nsTableFrame::~nsTableFrame()

 {

   delete mCellMap;

   delete mTableLayoutStrategy;

 }

 void

 nsTableFrame::DestroyFrom(nsIFrame* aDestructRoot)

 {

   mColGroups.DestroyFramesFrom(aDestructRoot);

   nsContainerFrame::DestroyFrom(aDestructRoot);

 }

 // Make sure any views are positioned properly

 void

 nsTableFrame::RePositionViews(nsIFrame* aFrame)

 {

   nsContainerFrame::PositionFrameView(aFrame);

   nsContainerFrame::PositionChildViews(aFrame);

 }

 static bool

 IsRepeatedFrame(nsIFrame* kidFrame)

 {

   return (kidFrame->GetType() == nsGkAtoms::tableRowFrame ||

           kidFrame->GetType() == nsGkAtoms::tableRowGroupFrame) &&

          (kidFrame->GetStateBits() & NS_REPEATED_ROW_OR_ROWGROUP);

 }

 bool

 nsTableFrame::PageBreakAfter(nsIFrame* aSourceFrame,

                              nsIFrame* aNextFrame)

 {

   const nsStyleDisplay* display = aSourceFrame->StyleDisplay();

   nsTableRowGroupFrame* prevRg = do_QueryFrame(aSourceFrame);

   // don't allow a page break after a repeated element ...

   if ((display->mBreakAfter || (prevRg && prevRg->HasInternalBreakAfter())) &&

       !IsRepeatedFrame(aSourceFrame)) {

     return !(aNextFrame && IsRepeatedFrame(aNextFrame)); // or before

   }

   if (aNextFrame) {

     display = aNextFrame->StyleDisplay();

     // don't allow a page break before a repeated element ...

      nsTableRowGroupFrame* nextRg = do_QueryFrame(aNextFrame);

     if ((display->mBreakBefore ||

         (nextRg && nextRg->HasInternalBreakBefore())) &&

         !IsRepeatedFrame(aNextFrame)) {

       return !IsRepeatedFrame(aSourceFrame); // or after

     }

   }

   return false;

 }

 typedef nsTArray<nsIFrame*> FrameTArray;

 /* static */ void

 nsTableFrame::DestroyPositionedTablePartArray(void* aPropertyValue)

 {

   auto positionedObjs = static_cast<FrameTArray*>(aPropertyValue);

   delete positionedObjs;

 }

 /* static */ void

 nsTableFrame::RegisterPositionedTablePart(nsIFrame* aFrame)

 {

   // Supporting relative positioning for table parts other than table cells has

   // the potential to break sites that apply 'position: relative' to those

   // parts, expecting nothing to happen. We warn at the console to make tracking

   // down the issue easy.

   if (nsGkAtoms::tableCellFrame != aFrame->GetType()) {

     nsIContent* content = aFrame->GetContent();

     nsPresContext* presContext = aFrame->PresContext();

     if (content && !presContext->HasWarnedAboutPositionedTableParts()) {

       presContext->SetHasWarnedAboutPositionedTableParts();

       nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,

                                       NS_LITERAL_CSTRING("Layout: Tables"),

                                       content->OwnerDoc(),

                                       nsContentUtils::eLAYOUT_PROPERTIES,

                                       "TablePartRelPosWarning");

     }

   }

   nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(aFrame);

   MOZ_ASSERT(tableFrame, "Should have a table frame here");

   tableFrame = static_cast<nsTableFrame*>(tableFrame->FirstContinuation());

   // Retrieve the positioned parts array for this table.

   FrameProperties props = tableFrame->Properties();

   auto positionedParts =

     static_cast<FrameTArray*>(props.Get(PositionedTablePartArray()));

   // Lazily create the array if it doesn't exist yet.

   if (!positionedParts) {

     positionedParts = new FrameTArray;

     props.Set(PositionedTablePartArray(), positionedParts);

   }

   // Add this frame to the list.

   positionedParts->AppendElement(aFrame);

 }

 /* static */ void

 nsTableFrame::UnregisterPositionedTablePart(nsIFrame* aFrame,

                                             nsIFrame* aDestructRoot)

 {

   // Retrieve the table frame, and ensure that we hit aDestructRoot on the way.

   // If we don't, that means that the table frame will be destroyed, so we don't

   // need to bother with unregistering this frame.

   nsTableFrame* tableFrame = GetTableFramePassingThrough(aDestructRoot, aFrame);

   if (!tableFrame) {

     return;

   }

   tableFrame = static_cast<nsTableFrame*>(tableFrame->FirstContinuation());

   // Retrieve the positioned parts array for this table.

   FrameProperties props = tableFrame->Properties();

   auto positionedParts =

     static_cast<FrameTArray*>(props.Get(PositionedTablePartArray()));

   // Remove the frame.

   MOZ_ASSERT(positionedParts &&

              positionedParts->IndexOf(aFrame) != FrameTArray::NoIndex,

              "Asked to unregister a positioned table part that wasn't registered");

   if (positionedParts) {

     positionedParts->RemoveElement(aFrame);

   }

 }

 // XXX this needs to be cleaned up so that the frame constructor breaks out col group

 // frames into a separate child list, bug 343048.

 nsresult

 nsTableFrame::SetInitialChildList(ChildListID     aListID,

                                   nsFrameList&    aChildList)

 {

   if (!mFrames.IsEmpty() || !mColGroups.IsEmpty()) {

     // We already have child frames which means we've already been

     // initialized

     NS_NOTREACHED("unexpected second call to SetInitialChildList");

     return NS_ERROR_UNEXPECTED;

   }

   if (aListID != kPrincipalList) {

     // All we know about is the principal child list.

     NS_NOTREACHED("unknown frame list");

     return NS_ERROR_INVALID_ARG;

   }

   // XXXbz the below code is an icky cesspit that's only needed in its current

   // form for two reasons:

   // 1) Both rowgroups and column groups come in on the principal child list.

   while (aChildList.NotEmpty()) {

     nsIFrame* childFrame = aChildList.FirstChild();

     aChildList.RemoveFirstChild();

     const nsStyleDisplay* childDisplay = childFrame->StyleDisplay();

     if (NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP == childDisplay->mDisplay) {

       NS_ASSERTION(nsGkAtoms::tableColGroupFrame == childFrame->GetType(),

                    "This is not a colgroup");

       mColGroups.AppendFrame(nullptr, childFrame);

     }

     else { // row groups and unknown frames go on the main list for now

       mFrames.AppendFrame(nullptr, childFrame);

     }

   }

   // If we have a prev-in-flow, then we're a table that has been split and

   // so don't treat this like an append

   if (!GetPrevInFlow()) {

     // process col groups first so that real cols get constructed before

     // anonymous ones due to cells in rows.

     InsertColGroups(0, mColGroups);

     InsertRowGroups(mFrames);

     // calc collapsing borders

     if (IsBorderCollapse()) {

       SetFullBCDamageArea();

     }

   }

   return NS_OK;

 }

 void nsTableFrame::AttributeChangedFor(nsIFrame*       aFrame,

                                        nsIContent*     aContent,

                                        nsIAtom*        aAttribute)

 {

   nsTableCellFrame *cellFrame = do_QueryFrame(aFrame);

   if (cellFrame) {

     if ((nsGkAtoms::rowspan == aAttribute) ||

         (nsGkAtoms::colspan == aAttribute)) {

       nsTableCellMap* cellMap = GetCellMap();

       if (cellMap) {

         // for now just remove the cell from the map and reinsert it

         int32_t rowIndex, colIndex;

         cellFrame->GetRowIndex(rowIndex);

         cellFrame->GetColIndex(colIndex);

         RemoveCell(cellFrame, rowIndex);

         nsAutoTArray<nsTableCellFrame*, 1> cells;

         cells.AppendElement(cellFrame);

         InsertCells(cells, rowIndex, colIndex - 1);

         // XXX Should this use eStyleChange?  It currently doesn't need

         // to, but it might given more optimization.

         PresContext()->PresShell()->

           FrameNeedsReflow(this, nsIPresShell::eTreeChange, NS_FRAME_IS_DIRTY);

       }

     }

   }

 }

 /* ****** CellMap methods ******* */

 /* return the effective col count */

 int32_t nsTableFrame::GetEffectiveColCount() const

 {

   int32_t colCount = GetColCount();

   if (LayoutStrategy()->GetType() == nsITableLayoutStrategy::Auto) {

     nsTableCellMap* cellMap = GetCellMap();

     if (!cellMap) {

       return 0;

     }

     // don't count cols at the end that don't have originating cells

     for (int32_t colX = colCount - 1; colX >= 0; colX--) {

       if (cellMap->GetNumCellsOriginatingInCol(colX) > 0) {

         break;

       }

       colCount--;

     }

   }

   return colCount;

 }

 int32_t nsTableFrame::GetIndexOfLastRealCol()

 {

   int32_t numCols = mColFrames.Length();

   if (numCols > 0) {

     for (int32_t colX = numCols - 1; colX >= 0; colX--) {

       nsTableColFrame* colFrame = GetColFrame(colX);

       if (colFrame) {

         if (eColAnonymousCell != colFrame->GetColType()) {

           return colX;

         }

       }

     }

   }

   return -1;

 }

 nsTableColFrame*

 nsTableFrame::GetColFrame(int32_t aColIndex) const

 {

   NS_ASSERTION(!GetPrevInFlow(), "GetColFrame called on next in flow");

   int32_t numCols = mColFrames.Length();

   if ((aColIndex >= 0) && (aColIndex < numCols)) {

     return mColFrames.ElementAt(aColIndex);

   }

   else {

     NS_ERROR("invalid col index");

     return nullptr;

   }

 }

 int32_t nsTableFrame::GetEffectiveRowSpan(int32_t                 aRowIndex,

                                           const nsTableCellFrame& aCell) const

 {

   nsTableCellMap* cellMap = GetCellMap();

   NS_PRECONDITION (nullptr != cellMap, "bad call, cellMap not yet allocated.");

   int32_t colIndex;

   aCell.GetColIndex(colIndex);

   return cellMap->GetEffectiveRowSpan(aRowIndex, colIndex);

 }

 int32_t nsTableFrame::GetEffectiveRowSpan(const nsTableCellFrame& aCell,

                                           nsCellMap*              aCellMap)

 {

   nsTableCellMap* tableCellMap = GetCellMap(); if (!tableCellMap) ABORT1(1);

   int32_t colIndex, rowIndex;

   aCell.GetColIndex(colIndex);

   aCell.GetRowIndex(rowIndex);

   if (aCellMap)

     return aCellMap->GetRowSpan(rowIndex, colIndex, true);

   else

     return tableCellMap->GetEffectiveRowSpan(rowIndex, colIndex);

 }

 int32_t nsTableFrame::GetEffectiveColSpan(const nsTableCellFrame& aCell,

                                           nsCellMap*              aCellMap) const

 {

   nsTableCellMap* tableCellMap = GetCellMap(); if (!tableCellMap) ABORT1(1);

   int32_t colIndex, rowIndex;

   aCell.GetColIndex(colIndex);

   aCell.GetRowIndex(rowIndex);

   bool ignore;

   if (aCellMap)

     return aCellMap->GetEffectiveColSpan(*tableCellMap, rowIndex, colIndex, ignore);

   else

     return tableCellMap->GetEffectiveColSpan(rowIndex, colIndex);

 }

 bool nsTableFrame::HasMoreThanOneCell(int32_t aRowIndex) const

 {

   nsTableCellMap* tableCellMap = GetCellMap(); if (!tableCellMap) ABORT1(1);

   return tableCellMap->HasMoreThanOneCell(aRowIndex);

 }

 void nsTableFrame::AdjustRowIndices(int32_t         aRowIndex,

                                     int32_t         aAdjustment)

 {

   // Iterate over the row groups and adjust the row indices of all rows

   // whose index is >= aRowIndex.

   RowGroupArray rowGroups;

   OrderRowGroups(rowGroups);

   for (uint32_t rgX = 0; rgX < rowGroups.Length(); rgX++) {

     rowGroups[rgX]->AdjustRowIndices(aRowIndex, aAdjustment);

   }

 }

 void nsTableFrame::ResetRowIndices(const nsFrameList::Slice& aRowGroupsToExclude)

 {

   // Iterate over the row groups and adjust the row indices of all rows

   // omit the rowgroups that will be inserted later

   RowGroupArray rowGroups;

   OrderRowGroups(rowGroups);

   int32_t rowIndex = 0;

   nsTHashtable<nsPtrHashKey<nsTableRowGroupFrame> > excludeRowGroups;

   nsFrameList::Enumerator excludeRowGroupsEnumerator(aRowGroupsToExclude);

   while (!excludeRowGroupsEnumerator.AtEnd()) {

     excludeRowGroups.PutEntry(static_cast<nsTableRowGroupFrame*>(excludeRowGroupsEnumerator.get()));

     excludeRowGroupsEnumerator.Next();

   }

   for (uint32_t rgX = 0; rgX < rowGroups.Length(); rgX++) {

     nsTableRowGroupFrame* rgFrame = rowGroups[rgX];

     if (!excludeRowGroups.GetEntry(rgFrame)) {

       const nsFrameList& rowFrames = rgFrame->PrincipalChildList();

       for (nsFrameList::Enumerator rows(rowFrames); !rows.AtEnd(); rows.Next()) {

         if (NS_STYLE_DISPLAY_TABLE_ROW==rows.get()->StyleDisplay()->mDisplay) {

           ((nsTableRowFrame *)rows.get())->SetRowIndex(rowIndex);

           rowIndex++;

         }

       }

     }

   }

 }

 void nsTableFrame::InsertColGroups(int32_t                   aStartColIndex,

                                    const nsFrameList::Slice& aColGroups)

 {

   int32_t colIndex = aStartColIndex;

   nsFrameList::Enumerator colGroups(aColGroups);

   for (; !colGroups.AtEnd(); colGroups.Next()) {

     MOZ_ASSERT(colGroups.get()->GetType() == nsGkAtoms::tableColGroupFrame);

     nsTableColGroupFrame* cgFrame =

       static_cast<nsTableColGroupFrame*>(colGroups.get());

     cgFrame->SetStartColumnIndex(colIndex);

     // XXXbz this sucks.  AddColsToTable will actually remove colgroups from

     // the list we're traversing!  Need to fix things here.  :( I guess this is

     // why the old code used pointer-to-last-frame as opposed to

     // pointer-to-frame-after-last....

     // How about dealing with this by storing a const reference to the

     // mNextSibling of the framelist's last frame, instead of storing a pointer

     // to the first-after-next frame?  Will involve making nsFrameList friend

     // of nsIFrame, but it's time for that anyway.

     cgFrame->AddColsToTable(colIndex, false,

                               colGroups.get()->PrincipalChildList());

     int32_t numCols = cgFrame->GetColCount();

     colIndex += numCols;

   }

   nsFrameList::Enumerator remainingColgroups = colGroups.GetUnlimitedEnumerator();

   if (!remainingColgroups.AtEnd()) {

     nsTableColGroupFrame::ResetColIndices(

       static_cast<nsTableColGroupFrame*>(remainingColgroups.get()), colIndex);

   }

 }

 void nsTableFrame::InsertCol(nsTableColFrame& aColFrame,

                              int32_t          aColIndex)

 {

   mColFrames.InsertElementAt(aColIndex, &aColFrame);

   nsTableColType insertedColType = aColFrame.GetColType();

   int32_t numCacheCols = mColFrames.Length();

   nsTableCellMap* cellMap = GetCellMap();

   if (cellMap) {

     int32_t numMapCols = cellMap->GetColCount();

     if (numCacheCols > numMapCols) {

       bool removedFromCache = false;

       if (eColAnonymousCell != insertedColType) {

         nsTableColFrame* lastCol = mColFrames.ElementAt(numCacheCols - 1);

         if (lastCol) {

           nsTableColType lastColType = lastCol->GetColType();

           if (eColAnonymousCell == lastColType) {

             // remove the col from the cache

             mColFrames.RemoveElementAt(numCacheCols - 1);

             // remove the col from the eColGroupAnonymousCell col group

             nsTableColGroupFrame* lastColGroup = (nsTableColGroupFrame *)mColGroups.LastChild();

             if (lastColGroup) {

               lastColGroup->RemoveChild(*lastCol, false);

               // remove the col group if it is empty

               if (lastColGroup->GetColCount() <= 0) {

                 mColGroups.DestroyFrame((nsIFrame*)lastColGroup);

               }

             }

             removedFromCache = true;

           }

         }

       }

       if (!removedFromCache) {

         cellMap->AddColsAtEnd(1);

       }

     }

   }

   // for now, just bail and recalc all of the collapsing borders

   if (IsBorderCollapse()) {

     nsIntRect damageArea(aColIndex, 0, 1, GetRowCount());

     AddBCDamageArea(damageArea);

   }

 }

 void nsTableFrame::RemoveCol(nsTableColGroupFrame* aColGroupFrame,

                              int32_t               aColIndex,

                              bool                  aRemoveFromCache,

                              bool                  aRemoveFromCellMap)

 {

   if (aRemoveFromCache) {

     mColFrames.RemoveElementAt(aColIndex);

   }

   if (aRemoveFromCellMap) {

     nsTableCellMap* cellMap = GetCellMap();

     if (cellMap) {

       AppendAnonymousColFrames(1);

     }

   }

   // for now, just bail and recalc all of the collapsing borders

   if (IsBorderCollapse()) {

     nsIntRect damageArea(0, 0, GetColCount(), GetRowCount());

     AddBCDamageArea(damageArea);

   }

 }

 /** Get the cell map for this table frame.  It is not always mCellMap.

   * Only the first-in-flow has a legit cell map.

   */

 nsTableCellMap*

 nsTableFrame::GetCellMap() const

 {

   return static_cast<nsTableFrame*>(FirstInFlow())->mCellMap;

 }

 // XXX this needs to be moved to nsCSSFrameConstructor

 nsTableColGroupFrame*

 nsTableFrame::CreateAnonymousColGroupFrame(nsTableColGroupType aColGroupType)

 {

   nsIContent* colGroupContent = GetContent();

   nsPresContext* presContext = PresContext();

   nsIPresShell *shell = presContext->PresShell();

   nsRefPtr<nsStyleContext> colGroupStyle;

   colGroupStyle = shell->StyleSet()->

     ResolveAnonymousBoxStyle(nsCSSAnonBoxes::tableColGroup, mStyleContext);

   // Create a col group frame

   nsIFrame* newFrame = NS_NewTableColGroupFrame(shell, colGroupStyle);

   ((nsTableColGroupFrame *)newFrame)->SetColType(aColGroupType);

   newFrame->Init(colGroupContent, this, nullptr);

   return (nsTableColGroupFrame *)newFrame;

 }

 void

 nsTableFrame::AppendAnonymousColFrames(int32_t aNumColsToAdd)

 {

   // get the last col group frame

   nsTableColGroupFrame* colGroupFrame =

     static_cast<nsTableColGroupFrame*>(mColGroups.LastChild());

   if (!colGroupFrame ||

       (colGroupFrame->GetColType() != eColGroupAnonymousCell)) {

     int32_t colIndex = (colGroupFrame) ?

                         colGroupFrame->GetStartColumnIndex() +

                         colGroupFrame->GetColCount() : 0;

     colGroupFrame = CreateAnonymousColGroupFrame(eColGroupAnonymousCell);

     if (!colGroupFrame) {

       return;

     }

     // add the new frame to the child list

     mColGroups.AppendFrame(this, colGroupFrame);

     colGroupFrame->SetStartColumnIndex(colIndex);

   }

   AppendAnonymousColFrames(colGroupFrame, aNumColsToAdd, eColAnonymousCell,

                            true);

 }

 // XXX this needs to be moved to nsCSSFrameConstructor

 // Right now it only creates the col frames at the end

 void

 nsTableFrame::AppendAnonymousColFrames(nsTableColGroupFrame* aColGroupFrame,

                                        int32_t               aNumColsToAdd,

                                        nsTableColType        aColType,

                                        bool                  aAddToTable)

 {

   NS_PRECONDITION(aColGroupFrame, "null frame");

   NS_PRECONDITION(aColType != eColAnonymousCol, "Shouldn't happen");

   nsIPresShell *shell = PresContext()->PresShell();

   // Get the last col frame

   nsFrameList newColFrames;

   int32_t startIndex = mColFrames.Length();

   int32_t lastIndex  = startIndex + aNumColsToAdd - 1;

   for (int32_t childX = startIndex; childX <= lastIndex; childX++) {

     nsIContent* iContent;

     nsRefPtr<nsStyleContext> styleContext;

     nsStyleContext* parentStyleContext;

     // all anonymous cols that we create here use a pseudo style context of the

     // col group

     iContent = aColGroupFrame->GetContent();

     parentStyleContext = aColGroupFrame->StyleContext();

     styleContext = shell->StyleSet()->

       ResolveAnonymousBoxStyle(nsCSSAnonBoxes::tableCol, parentStyleContext);

     // ASSERTION to check for bug 54454 sneaking back in...

     NS_ASSERTION(iContent, "null content in CreateAnonymousColFrames");

     // create the new col frame

     nsIFrame* colFrame = NS_NewTableColFrame(shell, styleContext);

     ((nsTableColFrame *) colFrame)->SetColType(aColType);

     colFrame->Init(iContent, aColGroupFrame, nullptr);

     newColFrames.AppendFrame(nullptr, colFrame);

   }

   nsFrameList& cols = aColGroupFrame->GetWritableChildList();

   nsIFrame* oldLastCol = cols.LastChild();

   const nsFrameList::Slice& newCols =

     cols.InsertFrames(nullptr, oldLastCol, newColFrames);

   if (aAddToTable) {

     // get the starting col index in the cache

     int32_t startColIndex;

     if (oldLastCol) {

       startColIndex =

         static_cast<nsTableColFrame*>(oldLastCol)->GetColIndex() + 1;

     } else {

       startColIndex = aColGroupFrame->GetStartColumnIndex();

     }

     aColGroupFrame->AddColsToTable(startColIndex, true, newCols);

   }

 }

 void

 nsTableFrame::MatchCellMapToColCache(nsTableCellMap* aCellMap)

 {

   int32_t numColsInMap   = GetColCount();

   int32_t numColsInCache = mColFrames.Length();

   int32_t numColsToAdd = numColsInMap - numColsInCache;

   if (numColsToAdd > 0) {

     // this sets the child list, updates the col cache and cell map

     AppendAnonymousColFrames(numColsToAdd);

   }

   if (numColsToAdd < 0) {

     int32_t numColsNotRemoved = DestroyAnonymousColFrames(-numColsToAdd);

     // if the cell map has fewer cols than the cache, correct it

     if (numColsNotRemoved > 0) {

       aCellMap->AddColsAtEnd(numColsNotRemoved);

     }

   }

   if (numColsToAdd && HasZeroColSpans()) {

     SetNeedColSpanExpansion(true);

   }

   if (NeedColSpanExpansion()) {

     // This flag can be set in two ways -- either by changing

     // the number of columns (that happens in the block above),

     // or by adding a cell with colspan="0" to the cellmap.  To

     // handle the latter case we need to explicitly check the

     // flag here -- it may be set even if the number of columns

     // did not change.

     //

     // @see nsCellMap::AppendCell

     aCellMap->ExpandZeroColSpans();

   }

 }

 void

 nsTableFrame::DidResizeColumns()

 {

   NS_PRECONDITION(!GetPrevInFlow(),

                   "should only be called on first-in-flow");

   if (mBits.mResizedColumns)

     return; // already marked

   for (nsTableFrame *f = this; f;

        f = static_cast<nsTableFrame*>(f->GetNextInFlow()))

     f->mBits.mResizedColumns = true;

 }

 void

 nsTableFrame::AppendCell(nsTableCellFrame& aCellFrame,

                          int32_t           aRowIndex)

 {

   nsTableCellMap* cellMap = GetCellMap();

   if (cellMap) {

     nsIntRect damageArea(0,0,0,0);

     cellMap->AppendCell(aCellFrame, aRowIndex, true, damageArea);

     MatchCellMapToColCache(cellMap);

     if (IsBorderCollapse()) {

       AddBCDamageArea(damageArea);

     }

   }

 }

 void nsTableFrame::InsertCells(nsTArray<nsTableCellFrame*>& aCellFrames,

                                int32_t                      aRowIndex,

                                int32_t                      aColIndexBefore)

 {

   nsTableCellMap* cellMap = GetCellMap();

   if (cellMap) {

     nsIntRect damageArea(0,0,0,0);

     cellMap->InsertCells(aCellFrames, aRowIndex, aColIndexBefore, damageArea);

     MatchCellMapToColCache(cellMap);

     if (IsBorderCollapse()) {

       AddBCDamageArea(damageArea);

     }

   }

 }

 // this removes the frames from the col group and table, but not the cell map

 int32_t

 nsTableFrame::DestroyAnonymousColFrames(int32_t aNumFrames)

 {

   // only remove cols that are of type eTypeAnonymous cell (they are at the end)

   int32_t endIndex   = mColFrames.Length() - 1;

   int32_t startIndex = (endIndex - aNumFrames) + 1;

   int32_t numColsRemoved = 0;

   for (int32_t colX = endIndex; colX >= startIndex; colX--) {

     nsTableColFrame* colFrame = GetColFrame(colX);

     if (colFrame && (eColAnonymousCell == colFrame->GetColType())) {

       nsTableColGroupFrame* cgFrame =

         static_cast<nsTableColGroupFrame*>(colFrame->GetParent());

       // remove the frame from the colgroup

       cgFrame->RemoveChild(*colFrame, false);

       // remove the frame from the cache, but not the cell map

       RemoveCol(nullptr, colX, true, false);

       numColsRemoved++;

     }

     else {

       break;

     }

   }

   return (aNumFrames - numColsRemoved);

 }

 void nsTableFrame::RemoveCell(nsTableCellFrame* aCellFrame,

                               int32_t           aRowIndex)

 {

   nsTableCellMap* cellMap = GetCellMap();

   if (cellMap) {

     nsIntRect damageArea(0,0,0,0);

     cellMap->RemoveCell(aCellFrame, aRowIndex, damageArea);

     MatchCellMapToColCache(cellMap);

     if (IsBorderCollapse()) {

       AddBCDamageArea(damageArea);

     }

   }

 }

 int32_t

 nsTableFrame::GetStartRowIndex(nsTableRowGroupFrame* aRowGroupFrame)

 {

   RowGroupArray orderedRowGroups;

   OrderRowGroups(orderedRowGroups);

   int32_t rowIndex = 0;

   for (uint32_t rgIndex = 0; rgIndex < orderedRowGroups.Length(); rgIndex++) {

     nsTableRowGroupFrame* rgFrame = orderedRowGroups[rgIndex];

     if (rgFrame == aRowGroupFrame) {

       break;

     }

     int32_t numRows = rgFrame->GetRowCount();

     rowIndex += numRows;

   }

   return rowIndex;

 }

 // this cannot extend beyond a single row group

 void nsTableFrame::AppendRows(nsTableRowGroupFrame*       aRowGroupFrame,

                               int32_t                     aRowIndex,

                               nsTArray<nsTableRowFrame*>& aRowFrames)

 {

   nsTableCellMap* cellMap = GetCellMap();

   if (cellMap) {

     int32_t absRowIndex = GetStartRowIndex(aRowGroupFrame) + aRowIndex;

     InsertRows(aRowGroupFrame, aRowFrames, absRowIndex, true);

   }

 }

 // this cannot extend beyond a single row group

 int32_t

 nsTableFrame::InsertRows(nsTableRowGroupFrame*       aRowGroupFrame,

                          nsTArray<nsTableRowFrame*>& aRowFrames,

                          int32_t                     aRowIndex,

                          bool                        aConsiderSpans)

 {

 #ifdef DEBUG_TABLE_CELLMAP

   printf("=== insertRowsBefore firstRow=%d \n", aRowIndex);

   Dump(true, false, true);

 #endif

   int32_t numColsToAdd = 0;

   nsTableCellMap* cellMap = GetCellMap();

   if (cellMap) {

     nsIntRect damageArea(0,0,0,0);

     int32_t origNumRows = cellMap->GetRowCount();

     int32_t numNewRows = aRowFrames.Length();

     cellMap->InsertRows(aRowGroupFrame, aRowFrames, aRowIndex, aConsiderSpans, damageArea);

     MatchCellMapToColCache(cellMap);

     if (aRowIndex < origNumRows) {

       AdjustRowIndices(aRowIndex, numNewRows);

     }

     // assign the correct row indices to the new rows. If they were adjusted above

     // it may not have been done correctly because each row is constructed with index 0

     for (int32_t rowY = 0; rowY < numNewRows; rowY++) {

       nsTableRowFrame* rowFrame = aRowFrames.ElementAt(rowY);

       rowFrame->SetRowIndex(aRowIndex + rowY);

     }

     if (IsBorderCollapse()) {

       AddBCDamageArea(damageArea);

     }

   }

 #ifdef DEBUG_TABLE_CELLMAP

   printf("=== insertRowsAfter \n");

   Dump(true, false, true);

 #endif

   return numColsToAdd;

 }

 // this cannot extend beyond a single row group

 void nsTableFrame::RemoveRows(nsTableRowFrame& aFirstRowFrame,

                               int32_t          aNumRowsToRemove,

                               bool             aConsiderSpans)

 {

 #ifdef TBD_OPTIMIZATION

   // decide if we need to rebalance. we have to do this here because the row group

   // cannot do it when it gets the dirty reflow corresponding to the frame being destroyed

   bool stopTelling = false;

   for (nsIFrame* kidFrame = aFirstFrame.FirstChild(); (kidFrame && !stopAsking);

        kidFrame = kidFrame->GetNextSibling()) {

     nsTableCellFrame *cellFrame = do_QueryFrame(kidFrame);

     if (cellFrame) {

       stopTelling = tableFrame->CellChangedWidth(*cellFrame, cellFrame->GetPass1MaxElementWidth(),

                                                  cellFrame->GetMaximumWidth(), true);

     }

   }

   // XXX need to consider what happens if there are cells that have rowspans

   // into the deleted row. Need to consider moving rows if a rebalance doesn't happen

 #endif

   int32_t firstRowIndex = aFirstRowFrame.GetRowIndex();

 #ifdef DEBUG_TABLE_CELLMAP

   printf("=== removeRowsBefore firstRow=%d numRows=%d\n", firstRowIndex, aNumRowsToRemove);

   Dump(true, false, true);

 #endif

   nsTableCellMap* cellMap = GetCellMap();

   if (cellMap) {

     nsIntRect damageArea(0,0,0,0);

     cellMap->RemoveRows(firstRowIndex, aNumRowsToRemove, aConsiderSpans, damageArea);

     MatchCellMapToColCache(cellMap);

     if (IsBorderCollapse()) {

       AddBCDamageArea(damageArea);

     }

   }

   AdjustRowIndices(firstRowIndex, -aNumRowsToRemove);

 #ifdef DEBUG_TABLE_CELLMAP

   printf("=== removeRowsAfter\n");

   Dump(true, true, true);

 #endif

 }

 // collect the rows ancestors of aFrame

 int32_t

 nsTableFrame::CollectRows(nsIFrame*                   aFrame,

                           nsTArray<nsTableRowFrame*>& aCollection)

 {

   NS_PRECONDITION(aFrame, "null frame");

   int32_t numRows = 0;

   nsIFrame* childFrame = aFrame->GetFirstPrincipalChild();

   while (childFrame) {

     aCollection.AppendElement(static_cast<nsTableRowFrame*>(childFrame));

     numRows++;

     childFrame = childFrame->GetNextSibling();

   }

   return numRows;

 }

 void

 nsTableFrame::InsertRowGroups(const nsFrameList::Slice& aRowGroups)

 {

 #ifdef DEBUG_TABLE_CELLMAP

   printf("=== insertRowGroupsBefore\n");

   Dump(true, false, true);

 #endif

   nsTableCellMap* cellMap = GetCellMap();

   if (cellMap) {

     RowGroupArray orderedRowGroups;

     OrderRowGroups(orderedRowGroups);

     nsAutoTArray<nsTableRowFrame*, 8> rows;

     // Loop over the rowgroups and check if some of them are new, if they are

     // insert cellmaps in the order that is predefined by OrderRowGroups,

     // XXXbz this code is O(N*M) where N is number of new rowgroups

     // and M is number of rowgroups we have!

     uint32_t rgIndex;

     for (rgIndex = 0; rgIndex < orderedRowGroups.Length(); rgIndex++) {

       for (nsFrameList::Enumerator rowgroups(aRowGroups); !rowgroups.AtEnd();

            rowgroups.Next()) {

         if (orderedRowGroups[rgIndex] == rowgroups.get()) {

           nsTableRowGroupFrame* priorRG =

             (0 == rgIndex) ? nullptr : orderedRowGroups[rgIndex - 1];

           // create and add the cell map for the row group

           cellMap->InsertGroupCellMap(orderedRowGroups[rgIndex], priorRG);

           break;

         }

       }

     }

     cellMap->Synchronize(this);

     ResetRowIndices(aRowGroups);

     //now that the cellmaps are reordered too insert the rows

     for (rgIndex = 0; rgIndex < orderedRowGroups.Length(); rgIndex++) {

       for (nsFrameList::Enumerator rowgroups(aRowGroups); !rowgroups.AtEnd();

            rowgroups.Next()) {

         if (orderedRowGroups[rgIndex] == rowgroups.get()) {

           nsTableRowGroupFrame* priorRG =

             (0 == rgIndex) ? nullptr : orderedRowGroups[rgIndex - 1];

           // collect the new row frames in an array and add them to the table

           int32_t numRows = CollectRows(rowgroups.get(), rows);

           if (numRows > 0) {

             int32_t rowIndex = 0;

             if (priorRG) {

               int32_t priorNumRows = priorRG->GetRowCount();

               rowIndex = priorRG->GetStartRowIndex() + priorNumRows;

             }

             InsertRows(orderedRowGroups[rgIndex], rows, rowIndex, true);

             rows.Clear();

           }

           break;

         }

       }

     }

   }

 #ifdef DEBUG_TABLE_CELLMAP

   printf("=== insertRowGroupsAfter\n");

   Dump(true, true, true);

 #endif

 }

 /////////////////////////////////////////////////////////////////////////////

 // Child frame enumeration

 const nsFrameList&

 nsTableFrame::GetChildList(ChildListID aListID) const

 {

   if (aListID == kColGroupList) {

     return mColGroups;

   }

   return nsContainerFrame::GetChildList(aListID);

 }

 void

 nsTableFrame::GetChildLists(nsTArray<ChildList>* aLists) const

 {

   nsContainerFrame::GetChildLists(aLists);

   mColGroups.AppendIfNonempty(aLists, kColGroupList);

 }

 nsRect

 nsDisplayTableItem::GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) {

   *aSnap = false;

   return mFrame->GetVisualOverflowRectRelativeToSelf() + ToReferenceFrame();

 }

 bool

 nsDisplayTableItem::IsVaryingRelativeToMovingFrame(nsDisplayListBuilder* aBuilder,

                                                    nsIFrame* aFrame)

 {

   if (!mPartHasFixedBackground)

     return false;

   // If aFrame is mFrame or an ancestor in this document, and aFrame is

   // not the viewport frame, then moving aFrame will move mFrame

   // relative to the viewport, so our fixed-pos background will change.

   return mFrame == aFrame ||

     nsLayoutUtils::IsProperAncestorFrame(aFrame, mFrame);

 }

 /* static */ void

 nsDisplayTableItem::UpdateForFrameBackground(nsIFrame* aFrame)

 {

   nsStyleContext *bgSC;

   if (!nsCSSRendering::FindBackground(aFrame, &bgSC))

     return;

   if (!bgSC->StyleBackground()->HasFixedBackground())

     return;

   mPartHasFixedBackground = true;

 }

 class nsDisplayTableBorderBackground : public nsDisplayTableItem {

 public:

   nsDisplayTableBorderBackground(nsDisplayListBuilder* aBuilder,

                                  nsTableFrame* aFrame) :

     nsDisplayTableItem(aBuilder, aFrame) {

     MOZ_COUNT_CTOR(nsDisplayTableBorderBackground);

   }

 #ifdef NS_BUILD_REFCNT_LOGGING

   virtual ~nsDisplayTableBorderBackground() {

     MOZ_COUNT_DTOR(nsDisplayTableBorderBackground);

   }

 #endif

   virtual void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,

                                          const nsDisplayItemGeometry* aGeometry,

                                          nsRegion *aInvalidRegion) MOZ_OVERRIDE;

   virtual void Paint(nsDisplayListBuilder* aBuilder,

                      nsRenderingContext* aCtx) MOZ_OVERRIDE;

   NS_DISPLAY_DECL_NAME("TableBorderBackground", TYPE_TABLE_BORDER_BACKGROUND)

 };

 #ifdef DEBUG

 static bool

 IsFrameAllowedInTable(nsIAtom* aType)

 {

   return IS_TABLE_CELL(aType) ||

          nsGkAtoms::tableRowFrame == aType ||

          nsGkAtoms::tableRowGroupFrame == aType ||

          nsGkAtoms::scrollFrame == aType ||

          nsGkAtoms::tableFrame == aType ||

          nsGkAtoms::tableColFrame == aType ||

          nsGkAtoms::tableColGroupFrame == aType;

 }

 #endif

 /* static */ bool

 nsTableFrame::AnyTablePartHasUndecodedBackgroundImage(nsIFrame* aStart,

                                                       nsIFrame* aEnd)

 {

   for (nsIFrame* f = aStart; f != aEnd; f = f->GetNextSibling()) {

     NS_ASSERTION(IsFrameAllowedInTable(f->GetType()), "unexpected frame type");

     if (!nsCSSRendering::AreAllBackgroundImagesDecodedForFrame(f))

       return true;

     nsTableCellFrame *cellFrame = do_QueryFrame(f);

     if (cellFrame)

       continue;

     if (AnyTablePartHasUndecodedBackgroundImage(f->PrincipalChildList().FirstChild(), nullptr))

       return true;

   }

   return false;

 }

 void

 nsDisplayTableBorderBackground::ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,

                                                           const nsDisplayItemGeometry* aGeometry,

                                                           nsRegion *aInvalidRegion)

 {

   if (aBuilder->ShouldSyncDecodeImages()) {

     if (nsTableFrame::AnyTablePartHasUndecodedBackgroundImage(mFrame, mFrame->GetNextSibling()) ||

         nsTableFrame::AnyTablePartHasUndecodedBackgroundImage(

           mFrame->GetChildList(nsIFrame::kColGroupList).FirstChild(), nullptr)) {

       bool snap;

       aInvalidRegion->Or(*aInvalidRegion, GetBounds(aBuilder, &snap));

     }

   }

   nsDisplayTableItem::ComputeInvalidationRegion(aBuilder, aGeometry, aInvalidRegion);

 }

 void

 nsDisplayTableBorderBackground::Paint(nsDisplayListBuilder* aBuilder,

                                       nsRenderingContext* aCtx)

 {

   static_cast<nsTableFrame*>(mFrame)->

     PaintTableBorderBackground(*aCtx, mVisibleRect,

                                ToReferenceFrame(),

                                aBuilder->GetBackgroundPaintFlags());

 }

 static int32_t GetTablePartRank(nsDisplayItem* aItem)

 {

   nsIAtom* type = aItem->Frame()->GetType();

   if (type == nsGkAtoms::tableFrame)

     return 0;

   if (type == nsGkAtoms::tableRowGroupFrame)

     return 1;

   if (type == nsGkAtoms::tableRowFrame)

     return 2;

   return 3;

 }

 static bool CompareByTablePartRank(nsDisplayItem* aItem1, nsDisplayItem* aItem2,

                                      void* aClosure)

 {

   return GetTablePartRank(aItem1) <= GetTablePartRank(aItem2);

 }

 /* static */ void

 nsTableFrame::GenericTraversal(nsDisplayListBuilder* aBuilder, nsFrame* aFrame,

                                const nsRect& aDirtyRect, const nsDisplayListSet& aLists)

 {

   // This is similar to what nsContainerFrame::BuildDisplayListForNonBlockChildren

   // does, except that we allow the children's background and borders to go

   // in our BorderBackground list. This doesn't really affect background

   // painting --- the children won't actually draw their own backgrounds

   // because the nsTableFrame already drew them, unless a child has its own

   // stacking context, in which case the child won't use its passed-in

   // BorderBackground list anyway. It does affect cell borders though; this

   // lets us get cell borders into the nsTableFrame's BorderBackground list.

   nsIFrame* kid = aFrame->GetFirstPrincipalChild();

   while (kid) {

     aFrame->BuildDisplayListForChild(aBuilder, kid, aDirtyRect, aLists);

     kid = kid->GetNextSibling();

   }

 }

 /* static */ void

 nsTableFrame::DisplayGenericTablePart(nsDisplayListBuilder* aBuilder,

                                       nsFrame* aFrame,

                                       const nsRect& aDirtyRect,

                                       const nsDisplayListSet& aLists,

                                       nsDisplayTableItem* aDisplayItem,

                                       DisplayGenericTablePartTraversal aTraversal)

 {

   nsDisplayList eventsBorderBackground;

   // If we need to sort the event backgrounds, then we'll put descendants'

   // display items into their own set of lists.

   bool sortEventBackgrounds = aDisplayItem && aBuilder->IsForEventDelivery();

   nsDisplayListCollection separatedCollection;

   const nsDisplayListSet* lists = sortEventBackgrounds ? &separatedCollection : &aLists;

   nsAutoPushCurrentTableItem pushTableItem;

   if (aDisplayItem) {

     pushTableItem.Push(aBuilder, aDisplayItem);

   }

   if (aFrame->IsVisibleForPainting(aBuilder)) {

     nsDisplayTableItem* currentItem = aBuilder->GetCurrentTableItem();

     // currentItem may be null, when none of the table parts have a

     // background or border

     if (currentItem) {

       currentItem->UpdateForFrameBackground(aFrame);

     }

     // Paint the outset box-shadows for the table frames

     bool hasBoxShadow = aFrame->StyleBorder()->mBoxShadow != nullptr;

     if (hasBoxShadow) {

       lists->BorderBackground()->AppendNewToTop(

         new (aBuilder) nsDisplayBoxShadowOuter(aBuilder, aFrame));

     }

     // Create dedicated background display items per-frame when we're

     // handling events.

     // XXX how to handle collapsed borders?

     if (aBuilder->IsForEventDelivery()) {

       nsDisplayBackgroundImage::AppendBackgroundItemsToTop(aBuilder, aFrame,

                                                            lists->BorderBackground());

     }

     // Paint the inset box-shadows for the table frames

     if (hasBoxShadow) {

       lists->BorderBackground()->AppendNewToTop(

         new (aBuilder) nsDisplayBoxShadowInner(aBuilder, aFrame));

     }

   }

   aTraversal(aBuilder, aFrame, aDirtyRect, *lists);

   if (sortEventBackgrounds) {

     // Ensure that the table frame event background goes before the

     // table rowgroups event backgrounds, before the table row event backgrounds,

     // before everything else (cells and their blocks)

     separatedCollection.BorderBackground()->Sort(aBuilder, CompareByTablePartRank, nullptr);

     separatedCollection.MoveTo(aLists);

   }

   aFrame->DisplayOutline(aBuilder, aLists);

 }

 static bool

 AnyTablePartHasBorderOrBackground(nsIFrame* aStart, nsIFrame* aEnd)

 {

   for (nsIFrame* f = aStart; f != aEnd; f = f->GetNextSibling()) {

     NS_ASSERTION(IsFrameAllowedInTable(f->GetType()), "unexpected frame type");

     if (FrameHasBorderOrBackground(f))

       return true;

     nsTableCellFrame *cellFrame = do_QueryFrame(f);

     if (cellFrame)

       continue;

     if (AnyTablePartHasBorderOrBackground(f->PrincipalChildList().FirstChild(), nullptr))

       return true;

   }

   return false;

 }

 // table paint code is concerned primarily with borders and bg color

 // SEC: TODO: adjust the rect for captions

 void

 nsTableFrame::BuildDisplayList(nsDisplayListBuilder*   aBuilder,

                                const nsRect&           aDirtyRect,

                                const nsDisplayListSet& aLists)

 {

   DO_GLOBAL_REFLOW_COUNT_DSP_COLOR("nsTableFrame", NS_RGB(255,128,255));

   nsDisplayTableItem* item = nullptr;

   if (IsVisibleInSelection(aBuilder)) {

     if (StyleVisibility()->IsVisible()) {

       nsMargin deflate = GetDeflationForBackground(PresContext());

       // If 'deflate' is (0,0,0,0) then we can paint the table background

       // in its own display item, so do that to take advantage of

       // opacity and visibility optimizations

       if (deflate == nsMargin(0, 0, 0, 0)) {

         DisplayBackgroundUnconditional(aBuilder, aLists, false);

       }

     }

     // This background is created if any of the table parts are visible,

     // or if we're doing event handling (since DisplayGenericTablePart

     // needs the item for the |sortEventBackgrounds|-dependent code).

     // Specific visibility decisions are delegated to the table background

     // painter, which handles borders and backgrounds for the table.

     if (aBuilder->IsForEventDelivery() ||

         AnyTablePartHasBorderOrBackground(this, GetNextSibling()) ||

         AnyTablePartHasBorderOrBackground(mColGroups.FirstChild(), nullptr)) {

       item = new (aBuilder) nsDisplayTableBorderBackground(aBuilder, this);

       aLists.BorderBackground()->AppendNewToTop(item);

     }

   }

   DisplayGenericTablePart(aBuilder, this, aDirtyRect, aLists, item);

 }

 nsMargin

 nsTableFrame::GetDeflationForBackground(nsPresContext* aPresContext) const

 {

   if (eCompatibility_NavQuirks != aPresContext->CompatibilityMode() ||

       !IsBorderCollapse())

     return nsMargin(0,0,0,0);

   return GetOuterBCBorder();

 }

 // XXX We don't put the borders and backgrounds in tree order like we should.

 // That requires some major surgery which we aren't going to do right now.

 void

 nsTableFrame::PaintTableBorderBackground(nsRenderingContext& aRenderingContext,

                                          const nsRect& aDirtyRect,

                                          nsPoint aPt, uint32_t aBGPaintFlags)

 {

   nsPresContext* presContext = PresContext();

   TableBackgroundPainter painter(this, TableBackgroundPainter::eOrigin_Table,

                                  presContext, aRenderingContext,

                                  aDirtyRect, aPt, aBGPaintFlags);

   nsMargin deflate = GetDeflationForBackground(presContext);

   // If 'deflate' is (0,0,0,0) then we'll paint the table background

   // in a separate display item, so don't do it here.

   nsresult rv = painter.PaintTable(this, deflate, deflate != nsMargin(0, 0, 0, 0));

   if (NS_FAILED(rv)) return;

   if (StyleVisibility()->IsVisible()) {

     if (!IsBorderCollapse()) {

       int skipSides = GetSkipSides();

       nsRect rect(aPt, mRect.Size());

       nsCSSRendering::PaintBorder(presContext, aRenderingContext, this,

                                   aDirtyRect, rect, mStyleContext, skipSides);

     }

     else {

       // XXX we should probably get rid of this translation at some stage

       // But that would mean modifying PaintBCBorders, ugh

       nsRenderingContext::AutoPushTranslation translate(&aRenderingContext, aPt);

       PaintBCBorders(aRenderingContext, aDirtyRect - aPt);

     }

   }

 }

 int

 nsTableFrame::GetLogicalSkipSides(const nsHTMLReflowState* aReflowState) const

 {

   int skip = 0;

   // frame attribute was accounted for in nsHTMLTableElement::MapTableBorderInto

   // account for pagination

   if (nullptr != GetPrevInFlow()) {

     skip |= LOGICAL_SIDE_B_START;

   }

   if (nullptr != GetNextInFlow()) {

     skip |= LOGICAL_SIDE_B_END;

   }

   return skip;

 }

 void

 nsTableFrame::SetColumnDimensions(nscoord         aHeight,

                                   const nsMargin& aBorderPadding)

 {

   nscoord cellSpacingX = GetCellSpacingX();

   nscoord cellSpacingY = GetCellSpacingY();

   nscoord colHeight = aHeight -= aBorderPadding.top + aBorderPadding.bottom +

                                  2* cellSpacingY;

   nsTableIterator iter(mColGroups);

   nsIFrame* colGroupFrame = iter.First();

   bool tableIsLTR = StyleVisibility()->mDirection == NS_STYLE_DIRECTION_LTR;

   int32_t colX =tableIsLTR ? 0 : std::max(0, GetColCount() - 1);

   int32_t tableColIncr = tableIsLTR ? 1 : -1;

   nsPoint colGroupOrigin(aBorderPadding.left + cellSpacingX,

                          aBorderPadding.top + cellSpacingY);

   while (colGroupFrame) {

     MOZ_ASSERT(colGroupFrame->GetType() == nsGkAtoms::tableColGroupFrame);

     nscoord colGroupWidth = 0;

     nsTableIterator iterCol(*colGroupFrame);

     nsIFrame* colFrame = iterCol.First();

     nsPoint colOrigin(0,0);

     while (colFrame) {

       if (NS_STYLE_DISPLAY_TABLE_COLUMN ==

           colFrame->StyleDisplay()->mDisplay) {

         NS_ASSERTION(colX < GetColCount(), "invalid number of columns");

         nscoord colWidth = GetColumnWidth(colX);

         nsRect colRect(colOrigin.x, colOrigin.y, colWidth, colHeight);

         colFrame->SetRect(colRect);

         colOrigin.x += colWidth + cellSpacingX;

         colGroupWidth += colWidth + cellSpacingX;

         colX += tableColIncr;

       }

       colFrame = iterCol.Next();

     }

     if (colGroupWidth) {

       colGroupWidth -= cellSpacingX;

     }

     nsRect colGroupRect(colGroupOrigin.x, colGroupOrigin.y, colGroupWidth, colHeight);

     colGroupFrame->SetRect(colGroupRect);

     colGroupFrame = iter.Next();

     colGroupOrigin.x += colGroupWidth + cellSpacingX;

   }

 }

 // SEC: TODO need to worry about continuing frames prev/next in flow for splitting across pages.

 // XXX this could be made more general to handle row modifications that change the

 // table height, but first we need to scrutinize every Invalidate

 void

 nsTableFrame::ProcessRowInserted(nscoord aNewHeight)

 {

   SetRowInserted(false); // reset the bit that got us here

   nsTableFrame::RowGroupArray rowGroups;

   OrderRowGroups(rowGroups);

   // find the row group containing the inserted row

   for (uint32_t rgX = 0; rgX < rowGroups.Length(); rgX++) {

     nsTableRowGroupFrame* rgFrame = rowGroups[rgX];

     NS_ASSERTION(rgFrame, "Must have rgFrame here");

     nsIFrame* childFrame = rgFrame->GetFirstPrincipalChild();

     // find the row that was inserted first

     while (childFrame) {

       nsTableRowFrame *rowFrame = do_QueryFrame(childFrame);

       if (rowFrame) {

         if (rowFrame->IsFirstInserted()) {

           rowFrame->SetFirstInserted(false);

           // damage the table from the 1st row inserted to the end of the table

           nsIFrame::InvalidateFrame();

           // XXXbz didn't we do this up front?  Why do we need to do it again?

           SetRowInserted(false);

           return; // found it, so leave

         }

       }

       childFrame = childFrame->GetNextSibling();

     }

   }

 }

 /* virtual */ void

 nsTableFrame::MarkIntrinsicWidthsDirty()

 {

   nsITableLayoutStrategy* tls = LayoutStrategy();

   if (MOZ_UNLIKELY(!tls)) {

     // This is a FrameNeedsReflow() from nsBlockFrame::RemoveFrame()

     // walking up the ancestor chain in a table next-in-flow.  In this case

     // our original first-in-flow (which owns the TableLayoutStrategy) has

     // already been destroyed and unhooked from the flow chain and thusly

     // LayoutStrategy() returns null.  All the frames in the flow will be

     // destroyed so no need to mark anything dirty here.  See bug 595758.

     return;

   }

   tls->MarkIntrinsicWidthsDirty();

   // XXXldb Call SetBCDamageArea?

   nsContainerFrame::MarkIntrinsicWidthsDirty();

 }

 /* virtual */ nscoord

 nsTableFrame::GetMinWidth(nsRenderingContext *aRenderingContext)

 {

   if (NeedToCalcBCBorders())

     CalcBCBorders();

   ReflowColGroups(aRenderingContext);

   return LayoutStrategy()->GetMinWidth(aRenderingContext);

 }

 /* virtual */ nscoord

 nsTableFrame::GetPrefWidth(nsRenderingContext *aRenderingContext)

 {

   if (NeedToCalcBCBorders())

     CalcBCBorders();

   ReflowColGroups(aRenderingContext);

   return LayoutStrategy()->GetPrefWidth(aRenderingContext, false);

 }

 /* virtual */ nsIFrame::IntrinsicWidthOffsetData

 nsTableFrame::IntrinsicWidthOffsets(nsRenderingContext* aRenderingContext)

 {

   IntrinsicWidthOffsetData result =

     nsContainerFrame::IntrinsicWidthOffsets(aRenderingContext);

   result.hMargin = 0;

   result.hPctMargin = 0;

   if (IsBorderCollapse()) {

     result.hPadding = 0;

     result.hPctPadding = 0;

     nsMargin outerBC = GetIncludedOuterBCBorder();

     result.hBorder = outerBC.LeftRight();

   }

   return result;

 }

 /* virtual */ nsSize

 nsTableFrame::ComputeSize(nsRenderingContext *aRenderingContext,

                           nsSize aCBSize, nscoord aAvailableWidth,

                           nsSize aMargin, nsSize aBorder, nsSize aPadding,

                           uint32_t aFlags)

 {

   nsSize result =

     nsContainerFrame::ComputeSize(aRenderingContext, aCBSize, aAvailableWidth,

                                   aMargin, aBorder, aPadding, aFlags);

   // If we're a container for font size inflation, then shrink

   // wrapping inside of us should not apply font size inflation.

   AutoMaybeDisableFontInflation an(this);

   // Tables never shrink below their min width.

   nscoord minWidth = GetMinWidth(aRenderingContext);

   if (minWidth > result.width)

     result.width = minWidth;

   return result;

 }

 nscoord

 nsTableFrame::TableShrinkWidthToFit(nsRenderingContext *aRenderingContext,

                                     nscoord aWidthInCB)

 {

   // If we're a container for font size inflation, then shrink

   // wrapping inside of us should not apply font size inflation.

   AutoMaybeDisableFontInflation an(this);

   nscoord result;

   nscoord minWidth = GetMinWidth(aRenderingContext);

   if (minWidth > aWidthInCB) {

     result = minWidth;

   } else {

     // Tables shrink width to fit with a slightly different algorithm

     // from the one they use for their intrinsic widths (the difference

     // relates to handling of percentage widths on columns).  So this

     // function differs from nsFrame::ShrinkWidthToFit by only the

     // following line.

     // Since we've already called GetMinWidth, we don't need to do any

     // of the other stuff GetPrefWidth does.

     nscoord prefWidth =

       LayoutStrategy()->GetPrefWidth(aRenderingContext, true);

     if (prefWidth > aWidthInCB) {

       result = aWidthInCB;

     } else {

       result = prefWidth;

     }

   }

   return result;

 }

 /* virtual */ nsSize

 nsTableFrame::ComputeAutoSize(nsRenderingContext *aRenderingContext,

                               nsSize aCBSize, nscoord aAvailableWidth,

                               nsSize aMargin, nsSize aBorder, nsSize aPadding,

                               bool aShrinkWrap)

 {

   // Tables always shrink-wrap.

   nscoord cbBased = aAvailableWidth - aMargin.width - aBorder.width -

                     aPadding.width;

   return nsSize(TableShrinkWidthToFit(aRenderingContext, cbBased),

                 NS_UNCONSTRAINEDSIZE);

 }

 // Return true if aParentReflowState.frame or any of its ancestors within

 // the containing table have non-auto height. (e.g. pct or fixed height)

 bool

 nsTableFrame::AncestorsHaveStyleHeight(const nsHTMLReflowState& aParentReflowState)

 {

   for (const nsHTMLReflowState* rs = &aParentReflowState;

        rs && rs->frame; rs = rs->parentReflowState) {

     nsIAtom* frameType = rs->frame->GetType();

     if (IS_TABLE_CELL(frameType)                     ||

         (nsGkAtoms::tableRowFrame      == frameType) ||

         (nsGkAtoms::tableRowGroupFrame == frameType)) {

       const nsStyleCoord &height = rs->mStylePosition->mHeight;

       // calc() with percentages treated like 'auto' on internal table elements

       if (height.GetUnit() != eStyleUnit_Auto &&

           (!height.IsCalcUnit() || !height.HasPercent())) {

         return true;

       }

     }

     else if (nsGkAtoms::tableFrame == frameType) {

       // we reached the containing table, so always return

       return rs->mStylePosition->mHeight.GetUnit() != eStyleUnit_Auto;

     }

   }

   return false;

 }

 // See if a special height reflow needs to occur and if so, call RequestSpecialHeightReflow

 void

 nsTableFrame::CheckRequestSpecialHeightReflow(const nsHTMLReflowState& aReflowState)

 {

   NS_ASSERTION(IS_TABLE_CELL(aReflowState.frame->GetType()) ||

                aReflowState.frame->GetType() == nsGkAtoms::tableRowFrame ||

                aReflowState.frame->GetType() == nsGkAtoms::tableRowGroupFrame ||

                aReflowState.frame->GetType() == nsGkAtoms::tableFrame,

                "unexpected frame type");

   if (!aReflowState.frame->GetPrevInFlow() &&  // 1st in flow

       (NS_UNCONSTRAINEDSIZE == aReflowState.ComputedHeight() ||  // no computed height

        0                    == aReflowState.ComputedHeight()) &&

       eStyleUnit_Percent == aReflowState.mStylePosition->mHeight.GetUnit() && // pct height

       nsTableFrame::AncestorsHaveStyleHeight(*aReflowState.parentReflowState)) {

     nsTableFrame::RequestSpecialHeightReflow(aReflowState);

   }

 }

 // Notify the frame and its ancestors (up to the containing table) that a special

 // height reflow will occur. During a special height reflow, a table, row group,

 // row, or cell returns the last size it was reflowed at. However, the table may

 // change the height of row groups, rows, cells in DistributeHeightToRows after.

 // And the row group can change the height of rows, cells in CalculateRowHeights.

 void

 nsTableFrame::RequestSpecialHeightReflow(const nsHTMLReflowState& aReflowState)

 {

   // notify the frame and its ancestors of the special reflow, stopping at the containing table

   for (const nsHTMLReflowState* rs = &aReflowState; rs && rs->frame; rs = rs->parentReflowState) {

     nsIAtom* frameType = rs->frame->GetType();

     NS_ASSERTION(IS_TABLE_CELL(frameType) ||

                  nsGkAtoms::tableRowFrame == frameType ||

                  nsGkAtoms::tableRowGroupFrame == frameType ||

                  nsGkAtoms::tableFrame == frameType,

                  "unexpected frame type");

     rs->frame->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_HEIGHT);

     if (nsGkAtoms::tableFrame == frameType) {

       NS_ASSERTION(rs != &aReflowState,

                    "should not request special height reflow for table");

       // always stop when we reach a table

       break;

     }

   }

 }

 /******************************************************************************************

  * Before reflow, intrinsic width calculation is done using GetMinWidth

  * and GetPrefWidth.  This used to be known as pass 1 reflow.

  *

  * After the intrinsic width calculation, the table determines the

  * column widths using BalanceColumnWidths() and

  * then reflows each child again with a constrained avail width. This reflow is referred to

  * as the pass 2 reflow.

  *

  * A special height reflow (pass 3 reflow) can occur during an initial or resize reflow

  * if (a) a row group, row, cell, or a frame inside a cell has a percent height but no computed

  * height or (b) in paginated mode, a table has a height. (a) supports percent nested tables

  * contained inside cells whose heights aren't known until after the pass 2 reflow. (b) is

  * necessary because the table cannot split until after the pass 2 reflow. The mechanics of

  * the special height reflow (variety a) are as follows:

  *

  * 1) Each table related frame (table, row group, row, cell) implements NeedsSpecialReflow()

  *    to indicate that it should get the reflow. It does this when it has a percent height but

  *    no computed height by calling CheckRequestSpecialHeightReflow(). This method calls

  *    RequestSpecialHeightReflow() which calls SetNeedSpecialReflow() on its ancestors until

  *    it reaches the containing table and calls SetNeedToInitiateSpecialReflow() on it. For

  *    percent height frames inside cells, during DidReflow(), the cell's NotifyPercentHeight()

  *    is called (the cell is the reflow state's mPercentHeightObserver in this case).

  *    NotifyPercentHeight() calls RequestSpecialHeightReflow().

  *

  * 2) After the pass 2 reflow, if the table's NeedToInitiateSpecialReflow(true) was called, it

  *    will do the special height reflow, setting the reflow state's mFlags.mSpecialHeightReflow

  *    to true and mSpecialHeightInitiator to itself. It won't do this if IsPrematureSpecialHeightReflow()

  *    returns true because in that case another special height reflow will be coming along with the

  *    containing table as the mSpecialHeightInitiator. It is only relevant to do the reflow when

  *    the mSpecialHeightInitiator is the containing table, because if it is a remote ancestor, then

  *    appropriate heights will not be known.

  *

  * 3) Since the heights of the table, row groups, rows, and cells was determined during the pass 2

  *    reflow, they return their last desired sizes during the special height reflow. The reflow only

  *    permits percent height frames inside the cells to resize based on the cells height and that height

  *    was determined during the pass 2 reflow.

  *

  * So, in the case of deeply nested tables, all of the tables that were told to initiate a special

  * reflow will do so, but if a table is already in a special reflow, it won't inititate the reflow

  * until the current initiator is its containing table. Since these reflows are only received by

  * frames that need them and they don't cause any rebalancing of tables, the extra overhead is minimal.

  *

  * The type of special reflow that occurs during printing (variety b) follows the same mechanism except

  * that all frames will receive the reflow even if they don't really need them.

  *

  * Open issues with the special height reflow:

  *

  * 1) At some point there should be 2 kinds of special height reflows because (a) and (b) above are

  *    really quite different. This would avoid unnecessary reflows during printing.

  * 2) When a cell contains frames whose percent heights > 100%, there is data loss (see bug 115245).

  *    However, this can also occur if a cell has a fixed height and there is no special height reflow.

  *

  * XXXldb Special height reflow should really be its own method, not

  * part of nsIFrame::Reflow.  It should then call nsIFrame::Reflow on

  * the contents of the cells to do the necessary vertical resizing.

  *

  ******************************************************************************************/

 /* Layout the entire inner table. */

 nsresult nsTableFrame::Reflow(nsPresContext*           aPresContext,

                                nsHTMLReflowMetrics&     aDesiredSize,

                                const nsHTMLReflowState& aReflowState,

                                nsReflowStatus&          aStatus)

 {

   DO_GLOBAL_REFLOW_COUNT("nsTableFrame");

   DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);

   bool isPaginated = aPresContext->IsPaginated();

   aStatus = NS_FRAME_COMPLETE;

   if (!GetPrevInFlow() && !mTableLayoutStrategy) {

     NS_ASSERTION(false, "strategy should have been created in Init");

     return NS_ERROR_NULL_POINTER;

   }

   nsresult rv = NS_OK;

   // see if collapsing borders need to be calculated

   if (!GetPrevInFlow() && IsBorderCollapse() && NeedToCalcBCBorders()) {

     CalcBCBorders();

   }

   aDesiredSize.Width() = aReflowState.AvailableWidth();

   // Check for an overflow list, and append any row group frames being pushed

   MoveOverflowToChildList();

   bool haveDesiredHeight = false;

   SetHaveReflowedColGroups(false);

   // Reflow the entire table (pass 2 and possibly pass 3). This phase is necessary during a

   // constrained initial reflow and other reflows which require either a strategy init or balance.

   // This isn't done during an unconstrained reflow, because it will occur later when the parent

   // reflows with a constrained width.

   if (NS_SUBTREE_DIRTY(this) ||

       aReflowState.ShouldReflowAllKids() ||

       IsGeometryDirty() ||

       aReflowState.mFlags.mVResize) {

     if (aReflowState.ComputedHeight() != NS_UNCONSTRAINEDSIZE ||

         // Also check mVResize, to handle the first Reflow preceding a

         // special height Reflow, when we've already had a special height

         // Reflow (where mComputedHeight would not be

         // NS_UNCONSTRAINEDSIZE, but without a style change in between).

         aReflowState.mFlags.mVResize) {

       // XXX Eventually, we should modify DistributeHeightToRows to use

       // nsTableRowFrame::GetHeight instead of nsIFrame::GetSize().height.

       // That way, it will make its calculations based on internal table

       // frame heights as they are before they ever had any extra height

       // distributed to them.  In the meantime, this reflows all the

       // internal table frames, which restores them to their state before

       // DistributeHeightToRows was called.

       SetGeometryDirty();

     }

     bool needToInitiateSpecialReflow =

       !!(GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_HEIGHT);

     // see if an extra reflow will be necessary in pagination mode when there is a specified table height

     if (isPaginated && !GetPrevInFlow() && (NS_UNCONSTRAINEDSIZE != aReflowState.AvailableHeight())) {

       nscoord tableSpecifiedHeight = CalcBorderBoxHeight(aReflowState);

       if ((tableSpecifiedHeight > 0) &&

           (tableSpecifiedHeight != NS_UNCONSTRAINEDSIZE)) {

         needToInitiateSpecialReflow = true;

       }

     }

     nsIFrame* lastChildReflowed = nullptr;

     NS_ASSERTION(!aReflowState.mFlags.mSpecialHeightReflow,

                  "Shouldn't be in special height reflow here!");

     // do the pass 2 reflow unless this is a special height reflow and we will be

     // initiating a special height reflow

     // XXXldb I changed this.  Should I change it back?

     // if we need to initiate a special height reflow, then don't constrain the

     // height of the reflow before that

     nscoord availHeight = needToInitiateSpecialReflow

                           ? NS_UNCONSTRAINEDSIZE : aReflowState.AvailableHeight();

     ReflowTable(aDesiredSize, aReflowState, availHeight,

                 lastChildReflowed, aStatus);

     // reevaluate special height reflow conditions

     if (GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_HEIGHT)

       needToInitiateSpecialReflow = true;

     // XXXldb Are all these conditions correct?

     if (needToInitiateSpecialReflow && NS_FRAME_IS_COMPLETE(aStatus)) {

       // XXXldb Do we need to set the mVResize flag on any reflow states?

       nsHTMLReflowState &mutable_rs =

         const_cast<nsHTMLReflowState&>(aReflowState);

       // distribute extra vertical space to rows

       CalcDesiredHeight(aReflowState, aDesiredSize);

       mutable_rs.mFlags.mSpecialHeightReflow = true;

       ReflowTable(aDesiredSize, aReflowState, aReflowState.AvailableHeight(),

                   lastChildReflowed, aStatus);

       if (lastChildReflowed && NS_FRAME_IS_NOT_COMPLETE(aStatus)) {

         // if there is an incomplete child, then set the desired height to include it but not the next one

         nsMargin borderPadding = GetChildAreaOffset(&aReflowState);

         aDesiredSize.Height() = borderPadding.bottom + GetCellSpacingY() +

                               lastChildReflowed->GetRect().YMost();

       }

       haveDesiredHeight = true;

       mutable_rs.mFlags.mSpecialHeightReflow = false;

     }

   }

   else {

     // Calculate the overflow area contribution from our children.

     for (nsIFrame* kid = GetFirstPrincipalChild(); kid; kid = kid->GetNextSibling()) {

       ConsiderChildOverflow(aDesiredSize.mOverflowAreas, kid);

     }

   }

   aDesiredSize.Width() = aReflowState.ComputedWidth() +

                        aReflowState.ComputedPhysicalBorderPadding().LeftRight();

   if (!haveDesiredHeight) {

     CalcDesiredHeight(aReflowState, aDesiredSize);

   }

   if (IsRowInserted()) {

     ProcessRowInserted(aDesiredSize.Height());

   }

   nsMargin borderPadding = GetChildAreaOffset(&aReflowState);

   SetColumnDimensions(aDesiredSize.Height(), borderPadding);

   if (NeedToCollapse() &&

       (NS_UNCONSTRAINEDSIZE != aReflowState.AvailableWidth())) {

     AdjustForCollapsingRowsCols(aDesiredSize, borderPadding);

   }

   // If there are any relatively-positioned table parts, we need to reflow their

   // absolutely-positioned descendants now that their dimensions are final.

   FixupPositionedTableParts(aPresContext, aDesiredSize, aReflowState);

   // make sure the table overflow area does include the table rect.

   nsRect tableRect(0, 0, aDesiredSize.Width(), aDesiredSize.Height()) ;

   if (!ShouldApplyOverflowClipping(this, aReflowState.mStyleDisplay)) {

     // collapsed border may leak out

     nsMargin bcMargin = GetExcludedOuterBCBorder();

     tableRect.Inflate(bcMargin);

   }

   aDesiredSize.mOverflowAreas.UnionAllWith(tableRect);

   if ((GetStateBits() & NS_FRAME_FIRST_REFLOW) ||

       nsSize(aDesiredSize.Width(), aDesiredSize.Height()) != mRect.Size()) {

       nsIFrame::InvalidateFrame();

   }

   FinishAndStoreOverflow(&aDesiredSize);

   NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);

   return rv;

 }

 void

 nsTableFrame::FixupPositionedTableParts(nsPresContext*           aPresContext,

                                         nsHTMLReflowMetrics&     aDesiredSize,

                                         const nsHTMLReflowState& aReflowState)

 {

   auto positionedParts =

     static_cast<FrameTArray*>(Properties().Get(PositionedTablePartArray()));

   if (!positionedParts) {

     return;

   }

   OverflowChangedTracker overflowTracker;

   overflowTracker.SetSubtreeRoot(this);

   for (size_t i = 0; i < positionedParts->Length(); ++i) {

     nsIFrame* positionedPart = positionedParts->ElementAt(i);

     // As we've already finished reflow, positionedParts's size and overflow

     // areas have already been assigned, so we just pull them back out.

     nsSize size(positionedPart->GetSize());

     nsHTMLReflowMetrics desiredSize(aReflowState.GetWritingMode());

     desiredSize.Width() = size.width;

     desiredSize.Height() = size.height;

     desiredSize.mOverflowAreas = positionedPart->GetOverflowAreasRelativeToSelf();

     // Construct a dummy reflow state and reflow status.

     // XXX(seth): Note that the dummy reflow state doesn't have a correct

     // chain of parent reflow states. It also doesn't necessarily have a

     // correct containing block.

     nsHTMLReflowState reflowState(aPresContext, positionedPart,

                                   aReflowState.rendContext,

                                   nsSize(size.width, NS_UNCONSTRAINEDSIZE),

                                   nsHTMLReflowState::DUMMY_PARENT_REFLOW_STATE);

     nsReflowStatus reflowStatus = NS_FRAME_COMPLETE;

     // Reflow absolutely-positioned descendants of the positioned part.

     // FIXME: Unconditionally using NS_UNCONSTRAINEDSIZE for the height and

     // ignoring any change to the reflow status aren't correct. We'll never

     // paginate absolutely positioned frames.

     overflowTracker.AddFrame(positionedPart,

       OverflowChangedTracker::CHILDREN_AND_PARENT_CHANGED);

     nsFrame* positionedFrame = static_cast<nsFrame*>(positionedPart);

     positionedFrame->FinishReflowWithAbsoluteFrames(PresContext(),

                                                     desiredSize,

                                                     reflowState,

                                                     reflowStatus,

                                                     true);

   }

   // Propagate updated overflow areas up the tree.

   overflowTracker.Flush();

   // Update our own overflow areas. (OverflowChangedTracker doesn't update the

   // subtree root itself.)

   aDesiredSize.SetOverflowAreasToDesiredBounds();

   nsLayoutUtils::UnionChildOverflow(this, aDesiredSize.mOverflowAreas);

 }

 bool

 nsTableFrame::UpdateOverflow()

 {

   nsRect bounds(nsPoint(0, 0), GetSize());

   // As above in Reflow, make sure the table overflow area includes the table

   // rect, and check for collapsed borders leaking out.

   if (!ShouldApplyOverflowClipping(this, StyleDisplay())) {

     nsMargin bcMargin = GetExcludedOuterBCBorder();

     bounds.Inflate(bcMargin);

   }

   nsOverflowAreas overflowAreas(bounds, bounds);

   nsLayoutUtils::UnionChildOverflow(this, overflowAreas);

   return FinishAndStoreOverflow(overflowAreas, GetSize());

 }

 nsresult

 nsTableFrame::ReflowTable(nsHTMLReflowMetrics&     aDesiredSize,

                           const nsHTMLReflowState& aReflowState,

                           nscoord                  aAvailHeight,

                           nsIFrame*&               aLastChildReflowed,

                           nsReflowStatus&          aStatus)

 {

   nsresult rv = NS_OK;

   aLastChildReflowed = nullptr;

   if (!GetPrevInFlow()) {

     mTableLayoutStrategy->ComputeColumnWidths(aReflowState);

   }

   // Constrain our reflow width to the computed table width (of the 1st in flow).

   // and our reflow height to our avail height minus border, padding, cellspacing

   aDesiredSize.Width() = aReflowState.ComputedWidth() +

                        aReflowState.ComputedPhysicalBorderPadding().LeftRight();

   nsTableReflowState reflowState(*PresContext(), aReflowState, *this,

                                  aDesiredSize.Width(), aAvailHeight);

   ReflowChildren(reflowState, aStatus, aLastChildReflowed,

                  aDesiredSize.mOverflowAreas);

   ReflowColGroups(aReflowState.rendContext);

   return rv;

 }

 nsIFrame*

 nsTableFrame::GetFirstBodyRowGroupFrame()

 {

   nsIFrame* headerFrame = nullptr;

   nsIFrame* footerFrame = nullptr;

   for (nsIFrame* kidFrame = mFrames.FirstChild(); nullptr != kidFrame; ) {

     const nsStyleDisplay* childDisplay = kidFrame->StyleDisplay();

     // We expect the header and footer row group frames to be first, and we only

     // allow one header and one footer

     if (NS_STYLE_DISPLAY_TABLE_HEADER_GROUP == childDisplay->mDisplay) {

       if (headerFrame) {

         // We already have a header frame and so this header frame is treated

         // like an ordinary body row group frame

         return kidFrame;

       }

       headerFrame = kidFrame;

     } else if (NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP == childDisplay->mDisplay) {

       if (footerFrame) {

         // We already have a footer frame and so this footer frame is treated

         // like an ordinary body row group frame

         return kidFrame;

       }

       footerFrame = kidFrame;

     } else if (NS_STYLE_DISPLAY_TABLE_ROW_GROUP == childDisplay->mDisplay) {

       return kidFrame;

     }

     // Get the next child

     kidFrame = kidFrame->GetNextSibling();

   }

   return nullptr;

 }

 // Table specific version that takes into account repeated header and footer

 // frames when continuing table frames

 void

 nsTableFrame::PushChildren(const RowGroupArray& aRowGroups,

                            int32_t aPushFrom)

 {

   NS_PRECONDITION(aPushFrom > 0, "pushing first child");

   // extract the frames from the array into a sibling list

   nsFrameList frames;

   uint32_t childX;

   for (childX = aPushFrom; childX < aRowGroups.Length(); ++childX) {

     nsTableRowGroupFrame* rgFrame = aRowGroups[childX];

     if (!rgFrame->IsRepeatable()) {

       mFrames.RemoveFrame(rgFrame);

       frames.AppendFrame(nullptr, rgFrame);

     }

   }

   if (frames.IsEmpty()) {

     return;

   }

   nsTableFrame* nextInFlow = static_cast<nsTableFrame*>(GetNextInFlow());

   if (nextInFlow) {

     // Insert the frames after any repeated header and footer frames.

     nsIFrame* firstBodyFrame = nextInFlow->GetFirstBodyRowGroupFrame();

     nsIFrame* prevSibling = nullptr;

     if (firstBodyFrame) {

       prevSibling = firstBodyFrame->GetPrevSibling();

     }

     // When pushing and pulling frames we need to check for whether any

     // views need to be reparented.

     ReparentFrameViewList(frames, this, nextInFlow);

     nextInFlow->mFrames.InsertFrames(nextInFlow, prevSibling,

                                      frames);

   }

   else {

     // Add the frames to our overflow list.

     SetOverflowFrames(frames);

   }

 }

 // collapsing row groups, rows, col groups and cols are accounted for after both passes of

 // reflow so that it has no effect on the calculations of reflow.

 void

 nsTableFrame::AdjustForCollapsingRowsCols(nsHTMLReflowMetrics& aDesiredSize,

                                           nsMargin             aBorderPadding)

 {

   nscoord yTotalOffset = 0; // total offset among all rows in all row groups

   // reset the bit, it will be set again if row/rowgroup or col/colgroup are

   // collapsed

   SetNeedToCollapse(false);

   // collapse the rows and/or row groups as necessary

   // Get the ordered children

   RowGroupArray rowGroups;

   OrderRowGroups(rowGroups);

   nsTableFrame* firstInFlow = static_cast<nsTableFrame*>(FirstInFlow());

   nscoord width = firstInFlow->GetCollapsedWidth(aBorderPadding);

   nscoord rgWidth = width - 2 * GetCellSpacingX();

   nsOverflowAreas overflow;

   // Walk the list of children

   for (uint32_t childX = 0; childX < rowGroups.Length(); childX++) {

     nsTableRowGroupFrame* rgFrame = rowGroups[childX];

     NS_ASSERTION(rgFrame, "Must have row group frame here");

     yTotalOffset += rgFrame->CollapseRowGroupIfNecessary(yTotalOffset, rgWidth);

     ConsiderChildOverflow(overflow, rgFrame);

   }

   aDesiredSize.Height() -= yTotalOffset;

   aDesiredSize.Width() = width;

   overflow.UnionAllWith(nsRect(0, 0, aDesiredSize.Width(), aDesiredSize.Height()));

   FinishAndStoreOverflow(overflow,

                          nsSize(aDesiredSize.Width(), aDesiredSize.Height()));

 }

 nscoord

 nsTableFrame::GetCollapsedWidth(nsMargin aBorderPadding)

 {

   NS_ASSERTION(!GetPrevInFlow(), "GetCollapsedWidth called on next in flow");

   nscoord cellSpacingX = GetCellSpacingX();

   nscoord width = cellSpacingX;

   width += aBorderPadding.left + aBorderPadding.right;

   for (nsIFrame* groupFrame = mColGroups.FirstChild(); groupFrame;

          groupFrame = groupFrame->GetNextSibling()) {

     const nsStyleVisibility* groupVis = groupFrame->StyleVisibility();

     bool collapseGroup = (NS_STYLE_VISIBILITY_COLLAPSE == groupVis->mVisible);

     nsTableColGroupFrame* cgFrame = (nsTableColGroupFrame*)groupFrame;

     for (nsTableColFrame* colFrame = cgFrame->GetFirstColumn(); colFrame;

          colFrame = colFrame->GetNextCol()) {

       const nsStyleDisplay* colDisplay = colFrame->StyleDisplay();

       int32_t colX = colFrame->GetColIndex();

       if (NS_STYLE_DISPLAY_TABLE_COLUMN == colDisplay->mDisplay) {

         const nsStyleVisibility* colVis = colFrame->StyleVisibility();

         bool collapseCol = (NS_STYLE_VISIBILITY_COLLAPSE == colVis->mVisible);

         int32_t colWidth = GetColumnWidth(colX);

         if (!collapseGroup && !collapseCol) {

           width += colWidth;

           if (ColumnHasCellSpacingBefore(colX))

             width += cellSpacingX;

         }

         else {

           SetNeedToCollapse(true);

         }

       }

     }

   }

   return width;

 }

 /* virtual */ void

 nsTableFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)

 {

   nsContainerFrame::DidSetStyleContext(aOldStyleContext);

   if (!aOldStyleContext) //avoid this on init

     return;

   if (IsBorderCollapse() &&

       BCRecalcNeeded(aOldStyleContext, StyleContext())) {

     SetFullBCDamageArea();

   }

   //avoid this on init or nextinflow

   if (!mTableLayoutStrategy || GetPrevInFlow())

     return;

   bool isAuto = IsAutoLayout();

   if (isAuto != (LayoutStrategy()->GetType() == nsITableLayoutStrategy::Auto)) {

     nsITableLayoutStrategy* temp;

     if (isAuto)

       temp = new BasicTableLayoutStrategy(this);

     else

       temp = new FixedTableLayoutStrategy(this);

     if (temp) {

       delete mTableLayoutStrategy;

       mTableLayoutStrategy = temp;

     }

   }

 }

 nsresult

 nsTableFrame::AppendFrames(ChildListID     aListID,

                            nsFrameList&    aFrameList)

 {

   NS_ASSERTION(aListID == kPrincipalList || aListID == kColGroupList,

                "unexpected child list");

   // Because we actually have two child lists, one for col group frames and one

   // for everything else, we need to look at each frame individually

   // XXX The frame construction code should be separating out child frames

   // based on the type, bug 343048.

   while (!aFrameList.IsEmpty()) {

     nsIFrame* f = aFrameList.FirstChild();

     aFrameList.RemoveFrame(f);

     // See what kind of frame we have

     const nsStyleDisplay* display = f->StyleDisplay();

     if (NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP == display->mDisplay) {

       nsTableColGroupFrame* lastColGroup =

         nsTableColGroupFrame::GetLastRealColGroup(this);

       int32_t startColIndex = (lastColGroup)

         ? lastColGroup->GetStartColumnIndex() + lastColGroup->GetColCount() : 0;

       mColGroups.InsertFrame(nullptr, lastColGroup, f);

       // Insert the colgroup and its cols into the table

       InsertColGroups(startColIndex,

                       nsFrameList::Slice(mColGroups, f, f->GetNextSibling()));

     } else if (IsRowGroup(display->mDisplay)) {

       // Append the new row group frame to the sibling chain

       mFrames.AppendFrame(nullptr, f);

       // insert the row group and its rows into the table

       InsertRowGroups(nsFrameList::Slice(mFrames, f, nullptr));

     } else {

       // Nothing special to do, just add the frame to our child list

       NS_NOTREACHED("How did we get here?  Frame construction screwed up");

       mFrames.AppendFrame(nullptr, f);

     }

   }

 #ifdef DEBUG_TABLE_CELLMAP

   printf("=== TableFrame::AppendFrames\n");

   Dump(true, true, true);

 #endif

   PresContext()->PresShell()->FrameNeedsReflow(this, nsIPresShell::eTreeChange,

                                                NS_FRAME_HAS_DIRTY_CHILDREN);

   SetGeometryDirty();

   return NS_OK;

 }

 // Needs to be at file scope or ArrayLength fails to compile.

 struct ChildListInsertions {

   nsIFrame::ChildListID mID;

   nsFrameList mList;

 };

 nsresult

 nsTableFrame::InsertFrames(ChildListID     aListID,

                            nsIFrame*       aPrevFrame,

                            nsFrameList&    aFrameList)

 {

   // The frames in aFrameList can be a mix of row group frames and col group

   // frames. The problem is that they should go in separate child lists so

   // we need to deal with that here...

   // XXX The frame construction code should be separating out child frames

   // based on the type, bug 343048.

   NS_ASSERTION(!aPrevFrame || aPrevFrame->GetParent() == this,

                "inserting after sibling frame with different parent");

   if ((aPrevFrame && !aPrevFrame->GetNextSibling()) ||

       (!aPrevFrame && GetChildList(aListID).IsEmpty())) {

     // Treat this like an append; still a workaround for bug 343048.

     return AppendFrames(aListID, aFrameList);

   }

   // Collect ColGroupFrames into a separate list and insert those separately

   // from the other frames (bug 759249).

   ChildListInsertions insertions[2]; // ColGroup, other

   const nsStyleDisplay* display = aFrameList.FirstChild()->StyleDisplay();

   nsFrameList::FrameLinkEnumerator e(aFrameList);

   for (; !aFrameList.IsEmpty(); e.Next()) {

     nsIFrame* next = e.NextFrame();

     if (!next || next->StyleDisplay()->mDisplay != display->mDisplay) {

       nsFrameList head = aFrameList.ExtractHead(e);

       if (display->mDisplay == NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP) {

         insertions[0].mID = kColGroupList;

         insertions[0].mList.AppendFrames(nullptr, head);

       } else {

         insertions[1].mID = kPrincipalList;

         insertions[1].mList.AppendFrames(nullptr, head);

       }

       if (!next) {

         break;

       }

       display = next->StyleDisplay();

     }

   }

   for (uint32_t i = 0; i < ArrayLength(insertions); ++i) {

     // We pass aPrevFrame for both ColGroup and other frames since

     // HomogenousInsertFrames will only use it if it's a suitable

     // prev-sibling for the frames in the frame list.

     if (!insertions[i].mList.IsEmpty()) {

       HomogenousInsertFrames(insertions[i].mID, aPrevFrame,

                              insertions[i].mList);

     }

   }

   return NS_OK;

 }

 void

 nsTableFrame::HomogenousInsertFrames(ChildListID     aListID,

                                      nsIFrame*       aPrevFrame,

                                      nsFrameList&    aFrameList)

 {

   // See what kind of frame we have

   const nsStyleDisplay* display = aFrameList.FirstChild()->StyleDisplay();

 #ifdef DEBUG

   // Verify that either all siblings have display:table-column-group, or they

   // all have display values different from table-column-group.

   for (nsFrameList::Enumerator e(aFrameList); !e.AtEnd(); e.Next()) {

     const nsStyleDisplay* nextDisplay = e.get()->StyleDisplay();

     MOZ_ASSERT((display->mDisplay == NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP) ==

                (nextDisplay->mDisplay == NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP),

                "heterogenous childlist");

   }

 #endif

   if (aPrevFrame) {

     const nsStyleDisplay* prevDisplay = aPrevFrame->StyleDisplay();

     // Make sure they belong on the same frame list

     if ((display->mDisplay == NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP) !=

         (prevDisplay->mDisplay == NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP)) {

       // the previous frame is not valid, see comment at ::AppendFrames

       // XXXbz Using content indices here means XBL will get screwed

       // over...  Oh, well.

       nsIFrame* pseudoFrame = aFrameList.FirstChild();

       nsIContent* parentContent = GetContent();

       nsIContent* content;

       aPrevFrame = nullptr;

       while (pseudoFrame  && (parentContent ==

                               (content = pseudoFrame->GetContent()))) {

         pseudoFrame = pseudoFrame->GetFirstPrincipalChild();

       }

       nsCOMPtr<nsIContent> container = content->GetParent();

       if (MOZ_LIKELY(container)) { // XXX need this null-check, see bug 411823.

         int32_t newIndex = container->IndexOf(content);

         nsIFrame* kidFrame;

         bool isColGroup = (NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP ==

                              display->mDisplay);

         nsTableColGroupFrame* lastColGroup;

         if (isColGroup) {

           kidFrame = mColGroups.FirstChild();

           lastColGroup = nsTableColGroupFrame::GetLastRealColGroup(this);

         }

         else {

           kidFrame = mFrames.FirstChild();

         }

         // Important: need to start at a value smaller than all valid indices

         int32_t lastIndex = -1;

         while (kidFrame) {

           if (isColGroup) {

             if (kidFrame == lastColGroup) {

               aPrevFrame = kidFrame; // there is no real colgroup after this one

               break;

             }

           }

           pseudoFrame = kidFrame;

           while (pseudoFrame  && (parentContent ==

                                   (content = pseudoFrame->GetContent()))) {

             pseudoFrame = pseudoFrame->GetFirstPrincipalChild();

           }

           int32_t index = container->IndexOf(content);

           if (index > lastIndex && index < newIndex) {

             lastIndex = index;

             aPrevFrame = kidFrame;

           }

           kidFrame = kidFrame->GetNextSibling();

         }

       }

     }

   }

   if (NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP == display->mDisplay) {

     NS_ASSERTION(aListID == kColGroupList, "unexpected child list");

     // Insert the column group frames

     const nsFrameList::Slice& newColgroups =

       mColGroups.InsertFrames(nullptr, aPrevFrame, aFrameList);

     // find the starting col index for the first new col group

     int32_t startColIndex = 0;

     if (aPrevFrame) {

       nsTableColGroupFrame* prevColGroup =

         (nsTableColGroupFrame*)GetFrameAtOrBefore(this, aPrevFrame,

                                                   nsGkAtoms::tableColGroupFrame);

       if (prevColGroup) {

         startColIndex = prevColGroup->GetStartColumnIndex() + prevColGroup->GetColCount();

       }

     }

     InsertColGroups(startColIndex, newColgroups);

   } else if (IsRowGroup(display->mDisplay)) {

     NS_ASSERTION(aListID == kPrincipalList, "unexpected child list");

     // Insert the frames in the sibling chain

     const nsFrameList::Slice& newRowGroups =

       mFrames.InsertFrames(nullptr, aPrevFrame, aFrameList);

     InsertRowGroups(newRowGroups);

   } else {

     NS_ASSERTION(aListID == kPrincipalList, "unexpected child list");

     NS_NOTREACHED("How did we even get here?");

     // Just insert the frame and don't worry about reflowing it

     mFrames.InsertFrames(nullptr, aPrevFrame, aFrameList);

     return;

   }

   PresContext()->PresShell()->FrameNeedsReflow(this, nsIPresShell::eTreeChange,

                                                NS_FRAME_HAS_DIRTY_CHILDREN);

   SetGeometryDirty();

 #ifdef DEBUG_TABLE_CELLMAP

   printf("=== TableFrame::InsertFrames\n");

   Dump(true, true, true);

 #endif

   return;

 }

 void

 nsTableFrame::DoRemoveFrame(ChildListID     aListID,

                             nsIFrame*       aOldFrame)

 {

   if (aListID == kColGroupList) {

     nsIFrame* nextColGroupFrame = aOldFrame->GetNextSibling();

     nsTableColGroupFrame* colGroup = (nsTableColGroupFrame*)aOldFrame;

     int32_t firstColIndex = colGroup->GetStartColumnIndex();

     int32_t lastColIndex  = firstColIndex + colGroup->GetColCount() - 1;

     mColGroups.DestroyFrame(aOldFrame);

     nsTableColGroupFrame::ResetColIndices(nextColGroupFrame, firstColIndex);

     // remove the cols from the table

     int32_t colX;

     for (colX = lastColIndex; colX >= firstColIndex; colX--) {

       nsTableColFrame* colFrame = mColFrames.SafeElementAt(colX);

       if (colFrame) {

         RemoveCol(colGroup, colX, true, false);

       }

     }

     int32_t numAnonymousColsToAdd = GetColCount() - mColFrames.Length();

     if (numAnonymousColsToAdd > 0) {

       // this sets the child list, updates the col cache and cell map

       AppendAnonymousColFrames(numAnonymousColsToAdd);

     }

   } else {

     NS_ASSERTION(aListID == kPrincipalList, "unexpected child list");

     nsTableRowGroupFrame* rgFrame =

       static_cast<nsTableRowGroupFrame*>(aOldFrame);

     // remove the row group from the cell map

     nsTableCellMap* cellMap = GetCellMap();

     if (cellMap) {

       cellMap->RemoveGroupCellMap(rgFrame);

     }

     // remove the row group frame from the sibling chain

     mFrames.DestroyFrame(aOldFrame);

     // the removal of a row group changes the cellmap, the columns might change

     if (cellMap) {

       cellMap->Synchronize(this);

       // Create an empty slice

       ResetRowIndices(nsFrameList::Slice(mFrames, nullptr, nullptr));

       nsIntRect damageArea;

       cellMap->RebuildConsideringCells(nullptr, nullptr, 0, 0, false, damageArea);

       static_cast<nsTableFrame*>(FirstInFlow())->MatchCellMapToColCache(cellMap);

     }

   }

 }

 nsresult

 nsTableFrame::RemoveFrame(ChildListID     aListID,

                           nsIFrame*       aOldFrame)

 {

   NS_ASSERTION(aListID == kColGroupList ||

                NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP !=

                  aOldFrame->StyleDisplay()->mDisplay,

                "Wrong list name; use kColGroupList iff colgroup");

   nsIPresShell* shell = PresContext()->PresShell();

   nsTableFrame* lastParent = nullptr;

   while (aOldFrame) {

     nsIFrame* oldFrameNextContinuation = aOldFrame->GetNextContinuation();

     nsTableFrame* parent = static_cast<nsTableFrame*>(aOldFrame->GetParent());

     if (parent != lastParent) {

       parent->DrainSelfOverflowList();

     }

     parent->DoRemoveFrame(aListID, aOldFrame);

     aOldFrame = oldFrameNextContinuation;

     if (parent != lastParent) {

       // for now, just bail and recalc all of the collapsing borders

       // as the cellmap changes we need to recalc

       if (parent->IsBorderCollapse()) {

         parent->SetFullBCDamageArea();

       }

       parent->SetGeometryDirty();

       shell->FrameNeedsReflow(parent, nsIPresShell::eTreeChange,

                               NS_FRAME_HAS_DIRTY_CHILDREN);

       lastParent = parent;

     }

   }

 #ifdef DEBUG_TABLE_CELLMAP

   printf("=== TableFrame::RemoveFrame\n");

   Dump(true, true, true);

 #endif

   return NS_OK;

 }

 /* virtual */ nsMargin

 nsTableFrame::GetUsedBorder() const

 {

   if (!IsBorderCollapse())

     return nsContainerFrame::GetUsedBorder();

   return GetIncludedOuterBCBorder();

 }

 /* virtual */ nsMargin

 nsTableFrame::GetUsedPadding() const

 {

   if (!IsBorderCollapse())

     return nsContainerFrame::GetUsedPadding();

   return nsMargin(0,0,0,0);

 }

 /* virtual */ nsMargin

 nsTableFrame::GetUsedMargin() const

 {

   // The margin is inherited to the outer table frame via

   // the ::-moz-table-outer rule in ua.css.

   return nsMargin(0, 0, 0, 0);

 }

 // Destructor function for BCPropertyData properties

 static void

 DestroyBCProperty(void* aPropertyValue)

 {

   delete static_cast<BCPropertyData*>(aPropertyValue);

 }

 NS_DECLARE_FRAME_PROPERTY(TableBCProperty, DestroyBCProperty)

 BCPropertyData*

 nsTableFrame::GetBCProperty(bool aCreateIfNecessary) const

 {

   FrameProperties props = Properties();

   BCPropertyData* value = static_cast<BCPropertyData*>

                           (props.Get(TableBCProperty()));

   if (!value && aCreateIfNecessary) {

     value = new BCPropertyData();

     props.Set(TableBCProperty(), value);

   }

   return value;

 }

 static void

 DivideBCBorderSize(BCPixelSize  aPixelSize,

                    BCPixelSize& aSmallHalf,

                    BCPixelSize& aLargeHalf)

 {

   aSmallHalf = aPixelSize / 2;

   aLargeHalf = aPixelSize - aSmallHalf;

 }

 nsMargin

 nsTableFrame::GetOuterBCBorder() const

 {

   if (NeedToCalcBCBorders())

     const_cast<nsTableFrame*>(this)->CalcBCBorders();

   nsMargin border(0, 0, 0, 0);

   int32_t p2t = nsPresContext::AppUnitsPerCSSPixel();

   BCPropertyData* propData = GetBCProperty();

   if (propData) {

     border.top    = BC_BORDER_TOP_HALF_COORD(p2t, propData->mTopBorderWidth);

     border.right  = BC_BORDER_RIGHT_HALF_COORD(p2t, propData->mRightBorderWidth);

     border.bottom = BC_BORDER_BOTTOM_HALF_COORD(p2t, propData->mBottomBorderWidth);

     border.left   = BC_BORDER_LEFT_HALF_COORD(p2t, propData->mLeftBorderWidth);

   }

   return border;

 }

 nsMargin

 nsTableFrame::GetIncludedOuterBCBorder() const

 {

   if (NeedToCalcBCBorders())

     const_cast<nsTableFrame*>(this)->CalcBCBorders();

   nsMargin border(0, 0, 0, 0);

   int32_t p2t = nsPresContext::AppUnitsPerCSSPixel();

   BCPropertyData* propData = GetBCProperty();

   if (propData) {

     border.top += BC_BORDER_TOP_HALF_COORD(p2t, propData->mTopBorderWidth);

     border.right += BC_BORDER_RIGHT_HALF_COORD(p2t, propData->mRightCellBorderWidth);

     border.bottom += BC_BORDER_BOTTOM_HALF_COORD(p2t, propData->mBottomBorderWidth);

     border.left += BC_BORDER_LEFT_HALF_COORD(p2t, propData->mLeftCellBorderWidth);

   }

   return border;

 }

 nsMargin

 nsTableFrame::GetExcludedOuterBCBorder() const

 {

   return GetOuterBCBorder() - GetIncludedOuterBCBorder();

 }

 static

 void GetSeparateModelBorderPadding(const nsHTMLReflowState* aReflowState,

                                    nsStyleContext&          aStyleContext,

                                    nsMargin&                aBorderPadding)

 {

   // XXXbz Either we _do_ have a reflow state and then we can use its

   // mComputedBorderPadding or we don't and then we get the padding

   // wrong!

   const nsStyleBorder* border = aStyleContext.StyleBorder();

   aBorderPadding = border->GetComputedBorder();

   if (aReflowState) {

     aBorderPadding += aReflowState->ComputedPhysicalPadding();

   }

 }

 nsMargin

 nsTableFrame::GetChildAreaOffset(const nsHTMLReflowState* aReflowState) const

 {

   nsMargin offset(0,0,0,0);

   if (IsBorderCollapse()) {

     offset = GetIncludedOuterBCBorder();

   }

   else {

     GetSeparateModelBorderPadding(aReflowState, *mStyleContext, offset);

   }

   return offset;

 }