The Tor Browser: layout/tables/nsCellMap.cpp@97036ab72558 (annotated)

layout/tables/nsCellMap.cpp@97036ab72558 (annotated)

layout/tables/nsCellMap.cpp

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "nsTArray.h"
 #include "nsCellMap.h"
 #include "nsTableFrame.h"
 #include "nsTableCellFrame.h"
 #include "nsTableRowFrame.h"
 #include "nsTableRowGroupFrame.h"
 #include <algorithm>
 static void
 SetDamageArea(int32_t aXOrigin,
               int32_t aYOrigin,
               int32_t aWidth,
               int32_t aHeight,
               nsIntRect& aDamageArea)
 {
   NS_ASSERTION(aXOrigin >= 0, "negative col index");
   NS_ASSERTION(aYOrigin >= 0, "negative row index");
   NS_ASSERTION(aWidth >= 0, "negative horizontal damage");
   NS_ASSERTION(aHeight >= 0, "negative vertical damage");
   aDamageArea.x      = aXOrigin;
   aDamageArea.y      = aYOrigin;
   aDamageArea.width  = aWidth;
   aDamageArea.height = aHeight;
 }
 // Empty static array used for SafeElementAt() calls on mRows.
 static nsCellMap::CellDataArray * sEmptyRow;
 // CellData
 CellData::CellData(nsTableCellFrame* aOrigCell)
 {
   MOZ_COUNT_CTOR(CellData);
   static_assert(sizeof(mOrigCell) == sizeof(mBits),
                 "mOrigCell and mBits must be the same size");
   mOrigCell = aOrigCell;
 }
 CellData::~CellData()
 {
   MOZ_COUNT_DTOR(CellData);
 }
 BCCellData::BCCellData(nsTableCellFrame* aOrigCell)
 :CellData(aOrigCell)
 {
   MOZ_COUNT_CTOR(BCCellData);
 }
 BCCellData::~BCCellData()
 {
   MOZ_COUNT_DTOR(BCCellData);
 }
 // nsTableCellMap
 nsTableCellMap::nsTableCellMap(nsTableFrame&   aTableFrame,
                                bool            aBorderCollapse)
 :mTableFrame(aTableFrame), mFirstMap(nullptr), mBCInfo(nullptr)
 {
   MOZ_COUNT_CTOR(nsTableCellMap);
   nsTableFrame::RowGroupArray orderedRowGroups;
   aTableFrame.OrderRowGroups(orderedRowGroups);
   nsTableRowGroupFrame* prior = nullptr;
   for (uint32_t rgX = 0; rgX < orderedRowGroups.Length(); rgX++) {
     nsTableRowGroupFrame* rgFrame = orderedRowGroups[rgX];
     InsertGroupCellMap(rgFrame, prior);
     prior = rgFrame;
   }
   if (aBorderCollapse) {
     mBCInfo = new BCInfo();
   }
 }
 nsTableCellMap::~nsTableCellMap()
 {
   MOZ_COUNT_DTOR(nsTableCellMap);
   nsCellMap* cellMap = mFirstMap;
   while (cellMap) {
     nsCellMap* next = cellMap->GetNextSibling();
     delete cellMap;
     cellMap = next;
   }
   if (mBCInfo) {
     DeleteRightBottomBorders();
     delete mBCInfo;
   }
 }
 // Get the bcData holding the border segments of the right edge of the table
 BCData*
 nsTableCellMap::GetRightMostBorder(int32_t aRowIndex)
 {
   if (!mBCInfo) ABORT1(nullptr);
   int32_t numRows = mBCInfo->mRightBorders.Length();
   if (aRowIndex < numRows) {
     return &mBCInfo->mRightBorders.ElementAt(aRowIndex);
   }
   mBCInfo->mRightBorders.SetLength(aRowIndex+1);
   return &mBCInfo->mRightBorders.ElementAt(aRowIndex);
 }
 // Get the bcData holding the border segments of the bottom edge of the table
 BCData*
 nsTableCellMap::GetBottomMostBorder(int32_t aColIndex)
 {
   if (!mBCInfo) ABORT1(nullptr);
   int32_t numCols = mBCInfo->mBottomBorders.Length();
   if (aColIndex < numCols) {
     return &mBCInfo->mBottomBorders.ElementAt(aColIndex);
   }
   mBCInfo->mBottomBorders.SetLength(aColIndex+1);
   return &mBCInfo->mBottomBorders.ElementAt(aColIndex);
 }
 // delete the borders corresponding to the right and bottom edges of the table
 void
 nsTableCellMap::DeleteRightBottomBorders()
 {
   if (mBCInfo) {
     mBCInfo->mBottomBorders.Clear();
     mBCInfo->mRightBorders.Clear();
   }
 }
 void
 nsTableCellMap::InsertGroupCellMap(nsCellMap* aPrevMap,
                                    nsCellMap& aNewMap)
 {
   nsCellMap* next;
   if (aPrevMap) {
     next = aPrevMap->GetNextSibling();
     aPrevMap->SetNextSibling(&aNewMap);
   }
   else {
     next = mFirstMap;
     mFirstMap = &aNewMap;
   }
   aNewMap.SetNextSibling(next);
 }
 void nsTableCellMap::InsertGroupCellMap(nsTableRowGroupFrame*  aNewGroup,
                                         nsTableRowGroupFrame*& aPrevGroup)
 {
   nsCellMap* newMap = new nsCellMap(aNewGroup, mBCInfo != nullptr);
   nsCellMap* prevMap = nullptr;
   nsCellMap* lastMap = mFirstMap;
   if (aPrevGroup) {
     nsCellMap* map = mFirstMap;
     while (map) {
       lastMap = map;
       if (map->GetRowGroup() == aPrevGroup) {
         prevMap = map;
         break;
       }
       map = map->GetNextSibling();
     }
   }
   if (!prevMap) {
     if (aPrevGroup) {
       prevMap = lastMap;
       aPrevGroup = (prevMap) ? prevMap->GetRowGroup() : nullptr;
     }
     else {
       aPrevGroup = nullptr;
     }
   }
   InsertGroupCellMap(prevMap, *newMap);
 }
 void nsTableCellMap::RemoveGroupCellMap(nsTableRowGroupFrame* aGroup)
 {
   nsCellMap* map = mFirstMap;
   nsCellMap* prior = nullptr;
   while (map) {
     if (map->GetRowGroup() == aGroup) {
       nsCellMap* next = map->GetNextSibling();
       if (mFirstMap == map) {
         mFirstMap = next;
       }
       else {
         prior->SetNextSibling(next);
       }
       delete map;
       break;
     }
     prior = map;
     map = map->GetNextSibling();
   }
 }
 static nsCellMap*
 FindMapFor(const nsTableRowGroupFrame* aRowGroup,
            nsCellMap* aStart,
            const nsCellMap* aEnd)
 {
   for (nsCellMap* map = aStart; map != aEnd; map = map->GetNextSibling()) {
     if (aRowGroup == map->GetRowGroup()) {
       return map;
     }
   }
   return nullptr;
 }
 nsCellMap*
 nsTableCellMap::GetMapFor(const nsTableRowGroupFrame* aRowGroup,
                           nsCellMap* aStartHint) const
 {
   NS_PRECONDITION(aRowGroup, "Must have a rowgroup");
   NS_ASSERTION(!aRowGroup->GetPrevInFlow(), "GetMapFor called with continuation");
   if (aStartHint) {
     nsCellMap* map = FindMapFor(aRowGroup, aStartHint, nullptr);
     if (map) {
       return map;
     }
   }
   nsCellMap* map = FindMapFor(aRowGroup, mFirstMap, aStartHint);
   if (map) {
     return map;
   }
   // if aRowGroup is a repeated header or footer find the header or footer it was repeated from
   if (aRowGroup->IsRepeatable()) {
     nsTableFrame* fifTable = static_cast<nsTableFrame*>(mTableFrame.FirstInFlow());
     const nsStyleDisplay* display = aRowGroup->StyleDisplay();
     nsTableRowGroupFrame* rgOrig =
       (NS_STYLE_DISPLAY_TABLE_HEADER_GROUP == display->mDisplay) ?
       fifTable->GetTHead() : fifTable->GetTFoot();
     // find the row group cell map using the original header/footer
     if (rgOrig && rgOrig != aRowGroup) {
       return GetMapFor(rgOrig, aStartHint);
     }
   }
   return nullptr;
 }
 void
 nsTableCellMap::Synchronize(nsTableFrame* aTableFrame)
 {
   nsTableFrame::RowGroupArray orderedRowGroups;
   nsAutoTArray<nsCellMap*, 8> maps;
   aTableFrame->OrderRowGroups(orderedRowGroups);
   if (!orderedRowGroups.Length()) {
     return;
   }
   // XXXbz this fails if orderedRowGroups is missing some row groups
   // (due to OOM when appending to the array, e.g. -- we leak maps in
   // that case).
   // Scope |map| outside the loop so we can use it as a hint.
   nsCellMap* map = nullptr;
   for (uint32_t rgX = 0; rgX < orderedRowGroups.Length(); rgX++) {
     nsTableRowGroupFrame* rgFrame = orderedRowGroups[rgX];
     map = GetMapFor(static_cast<nsTableRowGroupFrame*>(rgFrame->FirstInFlow()),
                     map);
     if (map) {
       if (!maps.AppendElement(map)) {
         delete map;
         map = nullptr;
         NS_WARNING("Could not AppendElement");
         break;
       }
     }
   }
   if (maps.IsEmpty()) {
     MOZ_ASSERT(!mFirstMap);
     return;
   }
   int32_t mapIndex = maps.Length() - 1;  // Might end up -1
   nsCellMap* nextMap = maps.ElementAt(mapIndex);
   nextMap->SetNextSibling(nullptr);
   for (mapIndex-- ; mapIndex >= 0; mapIndex--) {
     nsCellMap* map = maps.ElementAt(mapIndex);
     map->SetNextSibling(nextMap);
     nextMap = map;
   }
   mFirstMap = nextMap;
 }
 bool
 nsTableCellMap::HasMoreThanOneCell(int32_t aRowIndex) const
 {
   int32_t rowIndex = aRowIndex;
   nsCellMap* map = mFirstMap;
   while (map) {
     if (map->GetRowCount() > rowIndex) {
       return map->HasMoreThanOneCell(rowIndex);
     }
     rowIndex -= map->GetRowCount();
     map = map->GetNextSibling();
   }
   return false;
 }
 int32_t
 nsTableCellMap::GetNumCellsOriginatingInRow(int32_t aRowIndex) const
 {
   int32_t rowIndex = aRowIndex;
   nsCellMap* map = mFirstMap;
   while (map) {
     if (map->GetRowCount() > rowIndex) {
       return map->GetNumCellsOriginatingInRow(rowIndex);
     }
     rowIndex -= map->GetRowCount();
     map = map->GetNextSibling();
   }
   return 0;
 }
 int32_t
 nsTableCellMap::GetEffectiveRowSpan(int32_t aRowIndex,
                                     int32_t aColIndex) const
 {
   int32_t rowIndex = aRowIndex;
   nsCellMap* map = mFirstMap;
   while (map) {
     if (map->GetRowCount() > rowIndex) {
       return map->GetRowSpan(rowIndex, aColIndex, true);
     }
     rowIndex -= map->GetRowCount();
     map = map->GetNextSibling();
   }
   NS_NOTREACHED("Bogus row index?");
   return 0;
 }
 int32_t
 nsTableCellMap::GetEffectiveColSpan(int32_t aRowIndex,
                                     int32_t aColIndex) const
 {
   int32_t rowIndex = aRowIndex;
   nsCellMap* map = mFirstMap;
   while (map) {
     if (map->GetRowCount() > rowIndex) {
       bool zeroColSpan;
       return map->GetEffectiveColSpan(*this, rowIndex, aColIndex, zeroColSpan);
     }
     rowIndex -= map->GetRowCount();
     map = map->GetNextSibling();
   }
   NS_NOTREACHED("Bogus row index?");
   return 0;
 }
 nsTableCellFrame*
 nsTableCellMap::GetCellFrame(int32_t   aRowIndex,
                              int32_t   aColIndex,
                              CellData& aData,
                              bool      aUseRowIfOverlap) const
 {
   int32_t rowIndex = aRowIndex;
   nsCellMap* map = mFirstMap;
   while (map) {
     if (map->GetRowCount() > rowIndex) {
       return map->GetCellFrame(rowIndex, aColIndex, aData, aUseRowIfOverlap);
     }
     rowIndex -= map->GetRowCount();
     map = map->GetNextSibling();
   }
   return nullptr;
 }
 nsColInfo*
 nsTableCellMap::GetColInfoAt(int32_t aColIndex)
 {
   int32_t numColsToAdd = aColIndex + 1 - mCols.Length();
   if (numColsToAdd > 0) {
     AddColsAtEnd(numColsToAdd);  // XXX this could fail to add cols in theory
   }
   return &mCols.ElementAt(aColIndex);
 }
 int32_t
 nsTableCellMap::GetRowCount() const
 {
   int32_t numRows = 0;
   nsCellMap* map = mFirstMap;
   while (map) {
     numRows += map->GetRowCount();
     map = map->GetNextSibling();
   }
   return numRows;
 }
 CellData*
 nsTableCellMap::GetDataAt(int32_t aRowIndex,
                           int32_t aColIndex) const
 {
   int32_t rowIndex = aRowIndex;
   nsCellMap* map = mFirstMap;
   while (map) {
     if (map->GetRowCount() > rowIndex) {
       return map->GetDataAt(rowIndex, aColIndex);
     }
     rowIndex -= map->GetRowCount();
     map = map->GetNextSibling();
   }
   return nullptr;
 }
 void
 nsTableCellMap::AddColsAtEnd(uint32_t aNumCols)
 {
   if (!mCols.AppendElements(aNumCols)) {
     NS_WARNING("Could not AppendElement");
   }
   if (mBCInfo) {
     if (!mBCInfo->mBottomBorders.AppendElements(aNumCols)) {
       NS_WARNING("Could not AppendElement");
     }
   }
 }
 void
 nsTableCellMap::RemoveColsAtEnd()
 {
   // Remove the cols at the end which don't have originating cells or cells spanning
   // into them. Only do this if the col was created as eColAnonymousCell
   int32_t numCols = GetColCount();
   int32_t lastGoodColIndex = mTableFrame.GetIndexOfLastRealCol();
   for (int32_t colX = numCols - 1; (colX >= 0) && (colX > lastGoodColIndex); colX--) {
     nsColInfo& colInfo = mCols.ElementAt(colX);
     if ((colInfo.mNumCellsOrig <= 0) && (colInfo.mNumCellsSpan <= 0))  {
       mCols.RemoveElementAt(colX);
       if (mBCInfo) {
         int32_t count = mBCInfo->mBottomBorders.Length();
         if (colX < count) {
           mBCInfo->mBottomBorders.RemoveElementAt(colX);
         }
       }
     }
     else break; // only remove until we encounter the 1st valid one
   }
 }
 void
 nsTableCellMap::ClearCols()
 {
   mCols.Clear();
   if (mBCInfo)
     mBCInfo->mBottomBorders.Clear();
 }
 void
 nsTableCellMap::InsertRows(nsTableRowGroupFrame*       aParent,
                            nsTArray<nsTableRowFrame*>& aRows,
                            int32_t                     aFirstRowIndex,
                            bool                        aConsiderSpans,
                            nsIntRect&                  aDamageArea)
 {
   int32_t numNewRows = aRows.Length();
   if ((numNewRows <= 0) || (aFirstRowIndex < 0)) ABORT0();
   int32_t rowIndex = aFirstRowIndex;
   int32_t rgStartRowIndex = 0;
   nsCellMap* cellMap = mFirstMap;
   while (cellMap) {
     nsTableRowGroupFrame* rg = cellMap->GetRowGroup();
     if (rg == aParent) {
       cellMap->InsertRows(*this, aRows, rowIndex, aConsiderSpans,
                           rgStartRowIndex, aDamageArea);
 #ifdef DEBUG_TABLE_CELLMAP
       Dump("after InsertRows");
 #endif
       if (mBCInfo) {
         int32_t count = mBCInfo->mRightBorders.Length();
         if (aFirstRowIndex < count) {
           for (int32_t rowX = aFirstRowIndex; rowX < aFirstRowIndex + numNewRows; rowX++) {
             mBCInfo->mRightBorders.InsertElementAt(rowX);
           }
         }
         else {
           GetRightMostBorder(aFirstRowIndex); // this will create missing entries
           for (int32_t rowX = aFirstRowIndex + 1; rowX < aFirstRowIndex + numNewRows; rowX++) {
             mBCInfo->mRightBorders.AppendElement();
           }
         }
       }
       return;
     }
     int32_t rowCount = cellMap->GetRowCount();
     rgStartRowIndex += rowCount;
     rowIndex -= rowCount;
     cellMap = cellMap->GetNextSibling();
   }
   NS_ERROR("Attempt to insert row into wrong map.");
 }
 void
 nsTableCellMap::RemoveRows(int32_t         aFirstRowIndex,
                            int32_t         aNumRowsToRemove,
                            bool            aConsiderSpans,
                            nsIntRect&      aDamageArea)
 {
   int32_t rowIndex = aFirstRowIndex;
   int32_t rgStartRowIndex = 0;
   nsCellMap* cellMap = mFirstMap;
   while (cellMap) {
     int32_t rowCount = cellMap->GetRowCount();
     if (rowCount > rowIndex) {
       cellMap->RemoveRows(*this, rowIndex, aNumRowsToRemove, aConsiderSpans,
                           rgStartRowIndex, aDamageArea);
       if (mBCInfo) {
         for (int32_t rowX = aFirstRowIndex + aNumRowsToRemove - 1; rowX >= aFirstRowIndex; rowX--) {
           if (uint32_t(rowX) < mBCInfo->mRightBorders.Length()) {
             mBCInfo->mRightBorders.RemoveElementAt(rowX);
           }
         }
       }
       break;
     }
     rgStartRowIndex += rowCount;
     rowIndex -= rowCount;
     cellMap = cellMap->GetNextSibling();
   }
 #ifdef DEBUG_TABLE_CELLMAP
   Dump("after RemoveRows");
 #endif
 }
 CellData*
 nsTableCellMap::AppendCell(nsTableCellFrame& aCellFrame,
                            int32_t           aRowIndex,
                            bool              aRebuildIfNecessary,
                            nsIntRect&        aDamageArea)
 {
   MOZ_ASSERT(&aCellFrame == aCellFrame.FirstInFlow(),
              "invalid call on continuing frame");
   nsIFrame* rgFrame = aCellFrame.GetParent(); // get the row
   if (!rgFrame) return 0;
   rgFrame = rgFrame->GetParent();   // get the row group
   if (!rgFrame) return 0;
   CellData* result = nullptr;
   int32_t rowIndex = aRowIndex;
   int32_t rgStartRowIndex = 0;
   nsCellMap* cellMap = mFirstMap;
   while (cellMap) {
     if (cellMap->GetRowGroup() == rgFrame) {
       result = cellMap->AppendCell(*this, &aCellFrame, rowIndex,
                                    aRebuildIfNecessary, rgStartRowIndex,
                                    aDamageArea);
       break;
     }
     int32_t rowCount = cellMap->GetRowCount();
     rgStartRowIndex += rowCount;
     rowIndex -= rowCount;
     cellMap = cellMap->GetNextSibling();
   }
 #ifdef DEBUG_TABLE_CELLMAP
   Dump("after AppendCell");
 #endif
   return result;
 }
 void
 nsTableCellMap::InsertCells(nsTArray<nsTableCellFrame*>& aCellFrames,
                             int32_t                      aRowIndex,
                             int32_t                      aColIndexBefore,
                             nsIntRect&                   aDamageArea)
 {
   int32_t rowIndex = aRowIndex;
   int32_t rgStartRowIndex = 0;
   nsCellMap* cellMap = mFirstMap;
   while (cellMap) {
     int32_t rowCount = cellMap->GetRowCount();
     if (rowCount > rowIndex) {
       cellMap->InsertCells(*this, aCellFrames, rowIndex, aColIndexBefore,
                            rgStartRowIndex, aDamageArea);
       break;
     }
     rgStartRowIndex += rowCount;
     rowIndex -= rowCount;
     cellMap = cellMap->GetNextSibling();
   }
 #ifdef DEBUG_TABLE_CELLMAP
   Dump("after InsertCells");
 #endif
 }
 void
 nsTableCellMap::RemoveCell(nsTableCellFrame* aCellFrame,
                            int32_t           aRowIndex,
                            nsIntRect&        aDamageArea)
 {
   if (!aCellFrame) ABORT0();
   MOZ_ASSERT(aCellFrame == aCellFrame->FirstInFlow(),
              "invalid call on continuing frame");
   int32_t rowIndex = aRowIndex;
   int32_t rgStartRowIndex = 0;
   nsCellMap* cellMap = mFirstMap;
   while (cellMap) {
     int32_t rowCount = cellMap->GetRowCount();
     if (rowCount > rowIndex) {
       cellMap->RemoveCell(*this, aCellFrame, rowIndex, rgStartRowIndex,
                           aDamageArea);
 #ifdef DEBUG_TABLE_CELLMAP
       Dump("after RemoveCell");
 #endif
       return;
     }
     rgStartRowIndex += rowCount;
     rowIndex -= rowCount;
     cellMap = cellMap->GetNextSibling();
   }
   // if we reach this point - the cell did not get removed, the caller of this routine
   // will delete the cell and the cellmap will probably hold a reference to
   // the deleted cell which will cause a subsequent crash when this cell is
   // referenced later
   NS_ERROR("nsTableCellMap::RemoveCell - could not remove cell");
 }
 void
 nsTableCellMap::RebuildConsideringCells(nsCellMap*                   aCellMap,
                                         nsTArray<nsTableCellFrame*>* aCellFrames,
                                         int32_t                      aRowIndex,
                                         int32_t                      aColIndex,
                                         bool                         aInsert,
                                         nsIntRect&                   aDamageArea)
 {
   int32_t numOrigCols = GetColCount();
   ClearCols();
   nsCellMap* cellMap = mFirstMap;
   int32_t rowCount = 0;
   while (cellMap) {
     if (cellMap == aCellMap) {
       cellMap->RebuildConsideringCells(*this, numOrigCols, aCellFrames,
                                        aRowIndex, aColIndex, aInsert);
     }
     else {
       cellMap->RebuildConsideringCells(*this, numOrigCols, nullptr, -1, 0,
                                        false);
     }
     rowCount += cellMap->GetRowCount();
     cellMap = cellMap->GetNextSibling();
   }
   SetDamageArea(0, 0, GetColCount(), rowCount, aDamageArea);
 }
 void
 nsTableCellMap::RebuildConsideringRows(nsCellMap*                  aCellMap,
                                        int32_t                     aStartRowIndex,
                                        nsTArray<nsTableRowFrame*>* aRowsToInsert,
                                        int32_t                     aNumRowsToRemove,
                                        nsIntRect&                  aDamageArea)
 {
   NS_PRECONDITION(!aRowsToInsert || aNumRowsToRemove == 0,
                   "Can't handle both removing and inserting rows at once");
   int32_t numOrigCols = GetColCount();
   ClearCols();
   nsCellMap* cellMap = mFirstMap;
   int32_t rowCount = 0;
   while (cellMap) {
     if (cellMap == aCellMap) {
       cellMap->RebuildConsideringRows(*this, aStartRowIndex, aRowsToInsert,
                                       aNumRowsToRemove);
     }
     else {
       cellMap->RebuildConsideringCells(*this, numOrigCols, nullptr, -1, 0,
                                        false);
     }
     rowCount += cellMap->GetRowCount();
     cellMap = cellMap->GetNextSibling();
   }
   SetDamageArea(0, 0, GetColCount(), rowCount, aDamageArea);
 }
 int32_t
 nsTableCellMap::GetNumCellsOriginatingInCol(int32_t aColIndex) const
 {
   int32_t colCount = mCols.Length();
   if ((aColIndex >= 0) && (aColIndex < colCount)) {
     return mCols.ElementAt(aColIndex).mNumCellsOrig;
   }
   else {
     NS_ERROR("nsCellMap::GetNumCellsOriginatingInCol - bad col index");
     return 0;
   }
 }
 #ifdef DEBUG
 void
 nsTableCellMap::Dump(char* aString) const
 {
   if (aString)
     printf("%s \n", aString);
   printf("***** START TABLE CELL MAP DUMP ***** %p\n", (void*)this);
   // output col info
   int32_t colCount = mCols.Length();
   printf ("cols array orig/span-> %p", (void*)this);
   for (int32_t colX = 0; colX < colCount; colX++) {
     const nsColInfo& colInfo = mCols.ElementAt(colX);
     printf ("%d=%d/%d ", colX, colInfo.mNumCellsOrig, colInfo.mNumCellsSpan);
   }
   printf(" cols in cache %d\n", mTableFrame.GetColCache().Length());
   nsCellMap* cellMap = mFirstMap;
   while (cellMap) {
     cellMap->Dump(nullptr != mBCInfo);
     cellMap = cellMap->GetNextSibling();
   }
   if (nullptr != mBCInfo) {
     printf("***** bottom borders *****\n");
     nscoord       size;
     BCBorderOwner owner;
     mozilla::css::Side side;
     bool          segStart;
     bool          bevel;
     int32_t       colIndex;
     int32_t numCols = mBCInfo->mBottomBorders.Length();
     for (int32_t i = 0; i <= 2; i++) {
       printf("\n          ");
       for (colIndex = 0; colIndex < numCols; colIndex++) {
         BCData& cd = mBCInfo->mBottomBorders.ElementAt(colIndex);
         if (0 == i) {
           size = cd.GetTopEdge(owner, segStart);
           printf("t=%d%X%d ", int32_t(size), owner, segStart);
         }
         else if (1 == i) {
           size = cd.GetLeftEdge(owner, segStart);
           printf("l=%d%X%d ", int32_t(size), owner, segStart);
         }
         else {
           size = cd.GetCorner(side, bevel);
           printf("c=%d%X%d ", int32_t(size), side, bevel);
         }
       }
       BCData& cd = mBCInfo->mLowerRightCorner;
       if (0 == i) {
          size = cd.GetTopEdge(owner, segStart);
          printf("t=%d%X%d ", int32_t(size), owner, segStart);
       }
       else if (1 == i) {
         size = cd.GetLeftEdge(owner, segStart);
         printf("l=%d%X%d ", int32_t(size), owner, segStart);
       }
       else {
         size = cd.GetCorner(side, bevel);
         printf("c=%d%X%d ", int32_t(size), side, bevel);
       }
     }
     printf("\n");
   }
   printf("***** END TABLE CELL MAP DUMP *****\n");
 }
 #endif
 nsTableCellFrame*
 nsTableCellMap::GetCellInfoAt(int32_t  aRowIndex,
                               int32_t  aColIndex,
                               bool*  aOriginates,
                               int32_t* aColSpan) const
 {
   int32_t rowIndex = aRowIndex;
   nsCellMap* cellMap = mFirstMap;
   while (cellMap) {
     if (cellMap->GetRowCount() > rowIndex) {
       return cellMap->GetCellInfoAt(*this, rowIndex, aColIndex, aOriginates, aColSpan);
     }
     rowIndex -= cellMap->GetRowCount();
     cellMap = cellMap->GetNextSibling();
   }
   return nullptr;
 }
 int32_t
 nsTableCellMap::GetIndexByRowAndColumn(int32_t aRow, int32_t aColumn) const
 {
   int32_t index = 0;
   int32_t colCount = mCols.Length();
   int32_t rowIndex = aRow;
   nsCellMap* cellMap = mFirstMap;
   while (cellMap) {
     int32_t rowCount = cellMap->GetRowCount();
     if (rowIndex >= rowCount) {
       // If the rowCount is less than the rowIndex, this means that the index is
       // not within the current map. If so, get the index of the last cell in
       // the last row.
       rowIndex -= rowCount;
       int32_t cellMapIdx = cellMap->GetHighestIndex(colCount);
       if (cellMapIdx != -1)
         index += cellMapIdx + 1;
     } else {
       // Index is in valid range for this cellmap, so get the index of rowIndex
       // and aColumn.
       int32_t cellMapIdx = cellMap->GetIndexByRowAndColumn(colCount, rowIndex,
                                                            aColumn);
       if (cellMapIdx == -1)
         return -1; // no cell at the given row and column.
       index += cellMapIdx;
       return index;  // no need to look through further maps here
     }
     cellMap = cellMap->GetNextSibling();
   }
   return -1;
 }
 void
 nsTableCellMap::GetRowAndColumnByIndex(int32_t aIndex,
                                        int32_t *aRow, int32_t *aColumn) const
 {
   *aRow = -1;
   *aColumn = -1;
   int32_t colCount = mCols.Length();
   int32_t previousRows = 0;
   int32_t index = aIndex;
   nsCellMap* cellMap = mFirstMap;
   while (cellMap) {
     int32_t rowCount = cellMap->GetRowCount();
     // Determine the highest possible index in this map to see
     // if wanted index is in here.
     int32_t cellMapIdx = cellMap->GetHighestIndex(colCount);
     if (cellMapIdx == -1) {
       // The index is not within this map, increase the total row index
       // accordingly.
       previousRows += rowCount;
     } else {
       if (index > cellMapIdx) {
         // The index is not within this map, so decrease it by the cellMapIdx
         // determined index and increase the total row index accordingly.
         index -= cellMapIdx + 1;
         previousRows += rowCount;
       } else {
         cellMap->GetRowAndColumnByIndex(colCount, index, aRow, aColumn);
         // If there were previous indexes, take them into account.
         *aRow += previousRows;
         return; // no need to look any further.
       }
     }
     cellMap = cellMap->GetNextSibling();
   }
 }
 bool nsTableCellMap::RowIsSpannedInto(int32_t aRowIndex,
                                         int32_t aNumEffCols) const
 {
   int32_t rowIndex = aRowIndex;
   nsCellMap* cellMap = mFirstMap;
   while (cellMap) {
     if (cellMap->GetRowCount() > rowIndex) {
       return cellMap->RowIsSpannedInto(rowIndex, aNumEffCols);
     }
     rowIndex -= cellMap->GetRowCount();
     cellMap = cellMap->GetNextSibling();
   }
   return false;
 }
 bool nsTableCellMap::RowHasSpanningCells(int32_t aRowIndex,
                                            int32_t aNumEffCols) const
 {
   int32_t rowIndex = aRowIndex;
   nsCellMap* cellMap = mFirstMap;
   while (cellMap) {
     if (cellMap->GetRowCount() > rowIndex) {
       return cellMap->RowHasSpanningCells(rowIndex, aNumEffCols);
     }
     rowIndex -= cellMap->GetRowCount();
     cellMap = cellMap->GetNextSibling();
   }
   return false;
 }
 void nsTableCellMap::ExpandZeroColSpans()
 {
   mTableFrame.SetNeedColSpanExpansion(false); // mark the work done
   mTableFrame.SetHasZeroColSpans(false); // reset the bit, if there is a
                                             // zerospan it will be set again.
   nsCellMap* cellMap = mFirstMap;
   while (cellMap) {
     cellMap->ExpandZeroColSpans(*this);
     cellMap = cellMap->GetNextSibling();
   }
 }
 void
 nsTableCellMap::ResetTopStart(uint8_t    aSide,
                               nsCellMap& aCellMap,
                               uint32_t   aRowIndex,
                               uint32_t   aColIndex,
                               bool       aIsLowerRight)
 {
   if (!mBCInfo || aIsLowerRight) ABORT0();
   BCCellData* cellData;
   BCData* bcData = nullptr;
   switch(aSide) {
   case NS_SIDE_BOTTOM:
     aRowIndex++;
     // FALLTHROUGH
   case NS_SIDE_TOP:
     cellData = (BCCellData*)aCellMap.GetDataAt(aRowIndex, aColIndex);
     if (cellData) {
       bcData = &cellData->mData;
     }
     else {
       NS_ASSERTION(aSide == NS_SIDE_BOTTOM, "program error");
       // try the next row group
       nsCellMap* cellMap = aCellMap.GetNextSibling();
       if (cellMap) {
         cellData = (BCCellData*)cellMap->GetDataAt(0, aColIndex);
         if (cellData) {
           bcData = &cellData->mData;
         }
         else {
           bcData = GetBottomMostBorder(aColIndex);
         }
       }
     }
     break;
   case NS_SIDE_RIGHT:
     aColIndex++;
     // FALLTHROUGH
   case NS_SIDE_LEFT:
     cellData = (BCCellData*)aCellMap.GetDataAt(aRowIndex, aColIndex);
     if (cellData) {
       bcData = &cellData->mData;
     }
     else {
       NS_ASSERTION(aSide == NS_SIDE_RIGHT, "program error");
       bcData = GetRightMostBorder(aRowIndex);
     }
     break;
   }
   if (bcData) {
     bcData->SetTopStart(false);
   }
 }
 // store the aSide border segment at coord = (aRowIndex, aColIndex). For top/left, store
 // the info at coord. For bottom/left store it at the adjacent location so that it is
 // top/left at that location. If the new location is at the right or bottom edge of the
 // table, then store it one of the special arrays (right most borders, bottom most borders).
 void
 nsTableCellMap::SetBCBorderEdge(mozilla::css::Side aSide,
                                 nsCellMap&    aCellMap,
                                 uint32_t      aCellMapStart,
                                 uint32_t      aRowIndex,
                                 uint32_t      aColIndex,
                                 uint32_t      aLength,
                                 BCBorderOwner aOwner,
                                 nscoord       aSize,
                                 bool          aChanged)
 {
   if (!mBCInfo) ABORT0();
   BCCellData* cellData;
   int32_t lastIndex, xIndex, yIndex;
   int32_t xPos = aColIndex;
   int32_t yPos = aRowIndex;
   int32_t rgYPos = aRowIndex - aCellMapStart;
   bool changed;
   switch(aSide) {
   case NS_SIDE_BOTTOM:
     rgYPos++;
     yPos++;
   case NS_SIDE_TOP:
     lastIndex = xPos + aLength - 1;
     for (xIndex = xPos; xIndex <= lastIndex; xIndex++) {
       changed = aChanged && (xIndex == xPos);
       BCData* bcData = nullptr;
       cellData = (BCCellData*)aCellMap.GetDataAt(rgYPos, xIndex);
       if (!cellData) {
         int32_t numRgRows = aCellMap.GetRowCount();
         if (yPos < numRgRows) { // add a dead cell data
           nsIntRect damageArea;
           cellData = (BCCellData*)aCellMap.AppendCell(*this, nullptr, rgYPos,
                                                        false, 0, damageArea);
           if (!cellData) ABORT0();
         }
         else {
           NS_ASSERTION(aSide == NS_SIDE_BOTTOM, "program error");
           // try the next non empty row group
           nsCellMap* cellMap = aCellMap.GetNextSibling();
           while (cellMap && (0 == cellMap->GetRowCount())) {
             cellMap = cellMap->GetNextSibling();
           }
           if (cellMap) {
             cellData = (BCCellData*)cellMap->GetDataAt(0, xIndex);
             if (!cellData) { // add a dead cell
               nsIntRect damageArea;
               cellData = (BCCellData*)cellMap->AppendCell(*this, nullptr, 0,
                                                            false, 0,
                                                            damageArea);
             }
           }
           else { // must be at the end of the table
             bcData = GetBottomMostBorder(xIndex);
           }
         }
       }
       if (!bcData && cellData) {
         bcData = &cellData->mData;
       }
       if (bcData) {
         bcData->SetTopEdge(aOwner, aSize, changed);
       }
       else NS_ERROR("Cellmap: Top edge not found");
     }
     break;
   case NS_SIDE_RIGHT:
     xPos++;
   case NS_SIDE_LEFT:
     // since top, bottom borders were set, there should already be a cellData entry
     lastIndex = rgYPos + aLength - 1;
     for (yIndex = rgYPos; yIndex <= lastIndex; yIndex++) {
       changed = aChanged && (yIndex == rgYPos);
       cellData = (BCCellData*)aCellMap.GetDataAt(yIndex, xPos);
       if (cellData) {
         cellData->mData.SetLeftEdge(aOwner, aSize, changed);
       }
       else {
         NS_ASSERTION(aSide == NS_SIDE_RIGHT, "program error");
         BCData* bcData = GetRightMostBorder(yIndex + aCellMapStart);
         if (bcData) {
           bcData->SetLeftEdge(aOwner, aSize, changed);
         }
         else NS_ERROR("Cellmap: Left edge not found");
       }
     }
     break;
   }
 }
 // store corner info (aOwner, aSubSize, aBevel). For aCorner = eTopLeft, store the info at
 // (aRowIndex, aColIndex). For eTopRight, store it in the entry to the right where
 // it would be top left. For eBottomRight, store it in the entry to the bottom. etc.
 void
 nsTableCellMap::SetBCBorderCorner(Corner      aCorner,
                                   nsCellMap&  aCellMap,
                                   uint32_t    aCellMapStart,
                                   uint32_t    aRowIndex,
                                   uint32_t    aColIndex,
                                   mozilla::css::Side aOwner,
                                   nscoord     aSubSize,
                                   bool        aBevel,
                                   bool        aIsBottomRight)
 {
   if (!mBCInfo) ABORT0();
   if (aIsBottomRight) {
     mBCInfo->mLowerRightCorner.SetCorner(aSubSize, aOwner, aBevel);
     return;
   }
   int32_t xPos = aColIndex;
   int32_t yPos = aRowIndex;
   int32_t rgYPos = aRowIndex - aCellMapStart;
   if (eTopRight == aCorner) {
     xPos++;
   }
   else if (eBottomRight == aCorner) {
     xPos++;
     rgYPos++;
     yPos++;
   }
   else if (eBottomLeft == aCorner) {
     rgYPos++;
     yPos++;
   }
   BCCellData* cellData = nullptr;
   BCData*     bcData   = nullptr;
   if (GetColCount() <= xPos) {
     NS_ASSERTION(xPos == GetColCount(), "program error");
     // at the right edge of the table as we checked the corner before
     NS_ASSERTION(!aIsBottomRight, "should be handled before");
     bcData = GetRightMostBorder(yPos);
   }
   else {
     cellData = (BCCellData*)aCellMap.GetDataAt(rgYPos, xPos);
     if (!cellData) {
       int32_t numRgRows = aCellMap.GetRowCount();
       if (yPos < numRgRows) { // add a dead cell data
         nsIntRect damageArea;
         cellData = (BCCellData*)aCellMap.AppendCell(*this, nullptr, rgYPos,
                                                      false, 0, damageArea);
       }
       else {
         // try the next non empty row group
         nsCellMap* cellMap = aCellMap.GetNextSibling();
         while (cellMap && (0 == cellMap->GetRowCount())) {
           cellMap = cellMap->GetNextSibling();
         }
         if (cellMap) {
           cellData = (BCCellData*)cellMap->GetDataAt(0, xPos);
           if (!cellData) { // add a dead cell
             nsIntRect damageArea;
             cellData = (BCCellData*)cellMap->AppendCell(*this, nullptr, 0,
                                                          false, 0, damageArea);
           }
         }
         else { // must be at the bottom of the table
           bcData = GetBottomMostBorder(xPos);
         }
       }
     }
   }
   if (!bcData && cellData) {
     bcData = &cellData->mData;
   }
   if (bcData) {
     bcData->SetCorner(aSubSize, aOwner, aBevel);
   }
   else NS_ERROR("program error: Corner not found");
 }
 nsCellMap::nsCellMap(nsTableRowGroupFrame* aRowGroup, bool aIsBC)
   : mRows(8), mContentRowCount(0), mRowGroupFrame(aRowGroup),
     mNextSibling(nullptr), mIsBC(aIsBC),
     mPresContext(aRowGroup->PresContext())
 {
   MOZ_COUNT_CTOR(nsCellMap);
   NS_ASSERTION(mPresContext, "Must have prescontext");
 }
 nsCellMap::~nsCellMap()
 {
   MOZ_COUNT_DTOR(nsCellMap);
   uint32_t mapRowCount = mRows.Length();
   for (uint32_t rowX = 0; rowX < mapRowCount; rowX++) {
     CellDataArray &row = mRows[rowX];
     uint32_t colCount = row.Length();
     for (uint32_t colX = 0; colX < colCount; colX++) {
       DestroyCellData(row[colX]);
     }
   }
 }
 /* static */
 void
 nsCellMap::Init()
 {
   NS_ABORT_IF_FALSE(!sEmptyRow, "How did that happen?");
   sEmptyRow = new nsCellMap::CellDataArray();
 }
 /* static */
 void
 nsCellMap::Shutdown()
 {
   delete sEmptyRow;
   sEmptyRow = nullptr;
 }
 nsTableCellFrame*
 nsCellMap::GetCellFrame(int32_t   aRowIndexIn,
                         int32_t   aColIndexIn,
                         CellData& aData,
                         bool      aUseRowIfOverlap) const
 {
   int32_t rowIndex = aRowIndexIn - aData.GetRowSpanOffset();
   int32_t colIndex = aColIndexIn - aData.GetColSpanOffset();
   if (aData.IsOverlap()) {
     if (aUseRowIfOverlap) {
       colIndex = aColIndexIn;
     }
     else {
       rowIndex = aRowIndexIn;
     }
   }
   CellData* data =
     mRows.SafeElementAt(rowIndex, *sEmptyRow).SafeElementAt(colIndex);
   if (data) {
     return data->GetCellFrame();
   }
   return nullptr;
 }
 int32_t
 nsCellMap::GetHighestIndex(int32_t aColCount)
 {
   int32_t index = -1;
   int32_t rowCount = mRows.Length();
   for (int32_t rowIdx = 0; rowIdx < rowCount; rowIdx++) {
     const CellDataArray& row = mRows[rowIdx];
     for (int32_t colIdx = 0; colIdx < aColCount; colIdx++) {
       CellData* data = row.SafeElementAt(colIdx);
       // No data means row doesn't have more cells.
       if (!data)
         break;
       if (data->IsOrig())
         index++;
     }
   }
   return index;
 }
 int32_t
 nsCellMap::GetIndexByRowAndColumn(int32_t aColCount,
                                   int32_t aRow, int32_t aColumn) const
 {
   if (uint32_t(aRow) >= mRows.Length())
     return -1;
   int32_t index = -1;
   int32_t lastColsIdx = aColCount - 1;
   // Find row index of the cell where row span is started.
   const CellDataArray& row = mRows[aRow];
   CellData* data = row.SafeElementAt(aColumn);
   int32_t origRow = data ? aRow - data->GetRowSpanOffset() : aRow;
   // Calculate cell index.
   for (int32_t rowIdx = 0; rowIdx <= origRow; rowIdx++) {
     const CellDataArray& row = mRows[rowIdx];
     int32_t colCount = (rowIdx == origRow) ? aColumn : lastColsIdx;
     for (int32_t colIdx = 0; colIdx <= colCount; colIdx++) {
       data = row.SafeElementAt(colIdx);
       // No data means row doesn't have more cells.
       if (!data)
         break;
       if (data->IsOrig())
         index++;
     }
   }
   // Given row and column don't point to the cell.
   if (!data)
     return -1;
   return index;
 }
 void
 nsCellMap::GetRowAndColumnByIndex(int32_t aColCount, int32_t aIndex,
                                   int32_t *aRow, int32_t *aColumn) const
 {
   *aRow = -1;
   *aColumn = -1;
   int32_t index = aIndex;
   int32_t rowCount = mRows.Length();
   for (int32_t rowIdx = 0; rowIdx < rowCount; rowIdx++) {
     const CellDataArray& row = mRows[rowIdx];
     for (int32_t colIdx = 0; colIdx < aColCount; colIdx++) {
       CellData* data = row.SafeElementAt(colIdx);
       // The row doesn't have more cells.
       if (!data)
         break;
       if (data->IsOrig())
         index--;
       if (index < 0) {
         *aRow = rowIdx;
         *aColumn = colIdx;
         return;
       }
     }
   }
 }
 bool nsCellMap::Grow(nsTableCellMap& aMap,
                        int32_t         aNumRows,
                        int32_t         aRowIndex)
 {
   NS_ASSERTION(aNumRows >= 1, "Why are we calling this?");
   // Get the number of cols we want to use for preallocating the row arrays.
   int32_t numCols = aMap.GetColCount();
   if (numCols == 0) {
     numCols = 4;
   }
   uint32_t startRowIndex = (aRowIndex >= 0) ? aRowIndex : mRows.Length();
   NS_ASSERTION(startRowIndex <= mRows.Length(), "Missing grow call inbetween");
   return mRows.InsertElementsAt(startRowIndex, aNumRows, numCols) != nullptr;
 }
 void nsCellMap::GrowRow(CellDataArray& aRow,
                         int32_t        aNumCols)
 {
   // Have to have the cast to get the template to do the right thing.
   aRow.InsertElementsAt(aRow.Length(), aNumCols, (CellData*)nullptr);
 }
 void
 nsCellMap::InsertRows(nsTableCellMap&             aMap,
                       nsTArray<nsTableRowFrame*>& aRows,
                       int32_t                     aFirstRowIndex,
                       bool                        aConsiderSpans,
                       int32_t                     aRgFirstRowIndex,
                       nsIntRect&                  aDamageArea)
 {
   int32_t numCols = aMap.GetColCount();
   NS_ASSERTION(aFirstRowIndex >= 0, "nsCellMap::InsertRows called with negative rowIndex");
   if (uint32_t(aFirstRowIndex) > mRows.Length()) {
     // create (aFirstRowIndex - mRows.Length()) empty rows up to aFirstRowIndex
     int32_t numEmptyRows = aFirstRowIndex - mRows.Length();
     if (!Grow(aMap, numEmptyRows)) {
       return;
     }
   }
   if (!aConsiderSpans) {
     // update mContentRowCount, since non-empty rows will be added
     mContentRowCount = std::max(aFirstRowIndex, mContentRowCount);
     ExpandWithRows(aMap, aRows, aFirstRowIndex, aRgFirstRowIndex, aDamageArea);
     return;
   }
   // if any cells span into or out of the row being inserted, then rebuild
   bool spansCauseRebuild = CellsSpanInOrOut(aFirstRowIndex,
                                               aFirstRowIndex, 0, numCols - 1);
   // update mContentRowCount, since non-empty rows will be added
   mContentRowCount = std::max(aFirstRowIndex, mContentRowCount);
   // if any of the new cells span out of the new rows being added, then rebuild
   // XXX it would be better to only rebuild the portion of the map that follows the new rows
   if (!spansCauseRebuild && (uint32_t(aFirstRowIndex) < mRows.Length())) {
     spansCauseRebuild = CellsSpanOut(aRows);
   }
   if (spansCauseRebuild) {
     aMap.RebuildConsideringRows(this, aFirstRowIndex, &aRows, 0, aDamageArea);
   }
   else {
     ExpandWithRows(aMap, aRows, aFirstRowIndex, aRgFirstRowIndex, aDamageArea);
   }
 }
 void
 nsCellMap::RemoveRows(nsTableCellMap& aMap,
                       int32_t         aFirstRowIndex,
                       int32_t         aNumRowsToRemove,
                       bool            aConsiderSpans,
                       int32_t         aRgFirstRowIndex,
                       nsIntRect&      aDamageArea)
 {
   int32_t numRows = mRows.Length();
   int32_t numCols = aMap.GetColCount();
   if (aFirstRowIndex >= numRows) {
     // reduce the content based row count based on the function arguments
     // as they are known to be real rows even if the cell map did not create
     // rows for them before.
     mContentRowCount -= aNumRowsToRemove;
     return;
   }
   if (!aConsiderSpans) {
     ShrinkWithoutRows(aMap, aFirstRowIndex, aNumRowsToRemove, aRgFirstRowIndex,
                       aDamageArea);
     return;
   }
   int32_t endRowIndex = aFirstRowIndex + aNumRowsToRemove - 1;
   if (endRowIndex >= numRows) {
     NS_ERROR("nsCellMap::RemoveRows tried to remove too many rows");
     endRowIndex = numRows - 1;
   }
   bool spansCauseRebuild = CellsSpanInOrOut(aFirstRowIndex, endRowIndex,
 , numCols - 1);
   if (spansCauseRebuild) {
     aMap.RebuildConsideringRows(this, aFirstRowIndex, nullptr, aNumRowsToRemove,
                                 aDamageArea);
   }
   else {
     ShrinkWithoutRows(aMap, aFirstRowIndex, aNumRowsToRemove, aRgFirstRowIndex,
                       aDamageArea);
   }
 }
 CellData*
 nsCellMap::AppendCell(nsTableCellMap&   aMap,
                       nsTableCellFrame* aCellFrame,
                       int32_t           aRowIndex,
                       bool              aRebuildIfNecessary,
                       int32_t           aRgFirstRowIndex,
                       nsIntRect&        aDamageArea,
                       int32_t*          aColToBeginSearch)
 {
   NS_ASSERTION(!!aMap.mBCInfo == mIsBC, "BC state mismatch");
   int32_t origNumMapRows = mRows.Length();
   int32_t origNumCols = aMap.GetColCount();
   bool    zeroRowSpan = false;
   int32_t rowSpan = (aCellFrame) ? GetRowSpanForNewCell(aCellFrame, aRowIndex,
                                                         zeroRowSpan) : 1;
   // add new rows if necessary
   int32_t endRowIndex = aRowIndex + rowSpan - 1;
   if (endRowIndex >= origNumMapRows) {
     // XXXbz handle allocation failures?
     Grow(aMap, 1 + endRowIndex - origNumMapRows);
   }
   // get the first null or dead CellData in the desired row. It will equal origNumCols if there are none
   CellData* origData = nullptr;
   int32_t startColIndex = 0;
   if (aColToBeginSearch)
     startColIndex = *aColToBeginSearch;
   for (; startColIndex < origNumCols; startColIndex++) {
     CellData* data = GetDataAt(aRowIndex, startColIndex);
     if (!data)
       break;
     // The border collapse code relies on having multiple dead cell data entries
     // in a row.
     if (data->IsDead() && aCellFrame) {
       origData = data;
       break;
     }
     if (data->IsZeroColSpan() ) {
       // appending a cell collapses zerospans.
       CollapseZeroColSpan(aMap, data, aRowIndex, startColIndex);
       // ask again for the data as it should be modified
       origData = GetDataAt(aRowIndex, startColIndex);
       NS_ASSERTION(origData->IsDead(),
                    "The cellposition should have been cleared");
       break;
     }
   }
   // We found the place to append the cell, when the next cell is appended
   // the next search does not need to duplicate the search but can start
   // just at the next cell.
   if (aColToBeginSearch)
     *aColToBeginSearch =  startColIndex + 1;
   bool    zeroColSpan = false;
   int32_t colSpan = (aCellFrame) ?
                     GetColSpanForNewCell(*aCellFrame, zeroColSpan) : 1;
   if (zeroColSpan) {
     aMap.mTableFrame.SetHasZeroColSpans(true);
     aMap.mTableFrame.SetNeedColSpanExpansion(true);
   }
   // if the new cell could potentially span into other rows and collide with
   // originating cells there, we will play it safe and just rebuild the map
   if (aRebuildIfNecessary && (aRowIndex < mContentRowCount - 1) && (rowSpan > 1)) {
     nsAutoTArray<nsTableCellFrame*, 1> newCellArray;
     newCellArray.AppendElement(aCellFrame);
     aMap.RebuildConsideringCells(this, &newCellArray, aRowIndex, startColIndex, true, aDamageArea);
     return origData;
   }
   mContentRowCount = std::max(mContentRowCount, aRowIndex + 1);
   // add new cols to the table map if necessary
   int32_t endColIndex = startColIndex + colSpan - 1;
   if (endColIndex >= origNumCols) {
     NS_ASSERTION(aCellFrame, "dead cells should not require new columns");
     aMap.AddColsAtEnd(1 + endColIndex - origNumCols);
   }
   // Setup CellData for this cell
   if (origData) {
     NS_ASSERTION(origData->IsDead(), "replacing a non dead cell is a memory leak");
     if (aCellFrame) { // do nothing to replace a dead cell with a dead cell
       origData->Init(aCellFrame);
       // we are replacing a dead cell, increase the number of cells
       // originating at this column
       nsColInfo* colInfo = aMap.GetColInfoAt(startColIndex);
       NS_ASSERTION(colInfo, "access to a non existing column");
       if (colInfo) {
         colInfo->mNumCellsOrig++;
       }
     }
   }
   else {
     origData = AllocCellData(aCellFrame);
     if (!origData) ABORT1(origData);
     SetDataAt(aMap, *origData, aRowIndex, startColIndex);
   }
   if (aRebuildIfNecessary) {
     //the caller depends on the damageArea
     // The special case for zeroRowSpan is to adjust for the '2' in
     // GetRowSpanForNewCell.
     uint32_t height = zeroRowSpan ? endRowIndex - aRowIndex  :
 + endRowIndex - aRowIndex;
     SetDamageArea(startColIndex, aRgFirstRowIndex + aRowIndex,
 + endColIndex - startColIndex, height, aDamageArea);
   }
   if (!aCellFrame) {
     return origData;
   }
   // initialize the cell frame
   aCellFrame->SetColIndex(startColIndex);
   // Create CellData objects for the rows that this cell spans. Set
   // their mOrigCell to nullptr and their mSpanData to point to data.
   for (int32_t rowX = aRowIndex; rowX <= endRowIndex; rowX++) {
     // The row at rowX will need to have at least endColIndex columns
     mRows[rowX].SetCapacity(endColIndex);
     for (int32_t colX = startColIndex; colX <= endColIndex; colX++) {
       if ((rowX != aRowIndex) || (colX != startColIndex)) { // skip orig cell data done above
         CellData* cellData = GetDataAt(rowX, colX);
         if (cellData) {
           if (cellData->IsOrig()) {
             NS_ERROR("cannot overlap originating cell");
             continue;
           }
           if (rowX > aRowIndex) { // row spanning into cell
             if (cellData->IsRowSpan()) {
               // do nothing, this can be caused by rowspan which is overlapped
               // by a another cell with a rowspan and a colspan
             }
             else {
               cellData->SetRowSpanOffset(rowX - aRowIndex);
               if (zeroRowSpan) {
                 cellData->SetZeroRowSpan(true);
               }
             }
           }
           if (colX > startColIndex) { // col spanning into cell
             if (!cellData->IsColSpan()) {
               if (cellData->IsRowSpan()) {
                 cellData->SetOverlap(true);
               }
               cellData->SetColSpanOffset(colX - startColIndex);
               if (zeroColSpan) {
                 cellData->SetZeroColSpan(true);
               }
               nsColInfo* colInfo = aMap.GetColInfoAt(colX);
               colInfo->mNumCellsSpan++;
             }
           }
         }
         else {
           cellData = AllocCellData(nullptr);
           if (!cellData) return origData;
           if (rowX > aRowIndex) {
             cellData->SetRowSpanOffset(rowX - aRowIndex);
             if (zeroRowSpan) {
               cellData->SetZeroRowSpan(true);
             }
           }
           if (colX > startColIndex) {
             cellData->SetColSpanOffset(colX - startColIndex);
             if (zeroColSpan) {
               cellData->SetZeroColSpan(true);
             }
           }
           SetDataAt(aMap, *cellData, rowX, colX);
         }
       }
     }
   }
 #ifdef DEBUG_TABLE_CELLMAP
   printf("appended cell=%p row=%d \n", aCellFrame, aRowIndex);
   aMap.Dump();
 #endif
   return origData;
 }
 void nsCellMap::CollapseZeroColSpan(nsTableCellMap& aMap,
                                     CellData*       aOrigData,
                                     int32_t         aRowIndex,
                                     int32_t         aColIndex)
 {
   // if after a colspan = 0 cell another cell is appended in a row the html 4
   // spec is already violated. In principle one should then append the cell
   // after the last column but then the zero spanning cell would also have
   // to grow. The only plausible way to break this cycle is ignore the zero
   // colspan and reset the cell to colspan = 1.
   NS_ASSERTION(aOrigData && aOrigData->IsZeroColSpan(),
                "zero colspan should have been passed");
   // find the originating cellframe
   nsTableCellFrame* cell = GetCellFrame(aRowIndex, aColIndex, *aOrigData, true);
   NS_ASSERTION(cell, "originating cell not found");
   // find the clearing region
   int32_t startRowIndex = aRowIndex - aOrigData->GetRowSpanOffset();
   bool    zeroSpan;
   int32_t rowSpan = GetRowSpanForNewCell(cell, startRowIndex, zeroSpan);
   int32_t endRowIndex = startRowIndex + rowSpan;
   int32_t origColIndex = aColIndex - aOrigData->GetColSpanOffset();
   int32_t endColIndex = origColIndex +
                         GetEffectiveColSpan(aMap, startRowIndex,
                                             origColIndex, zeroSpan);
   for (int32_t colX = origColIndex +1; colX < endColIndex; colX++) {
     // Start the collapse just after the originating cell, since
     // we're basically making the originating cell act as if it
     // has colspan="1".
     nsColInfo* colInfo = aMap.GetColInfoAt(colX);
     colInfo->mNumCellsSpan -= rowSpan;
     for (int32_t rowX = startRowIndex; rowX < endRowIndex; rowX++)
     {
       CellData* data = mRows[rowX][colX];
       NS_ASSERTION(data->IsZeroColSpan(),
                    "Overwriting previous data - memory leak");
       data->Init(nullptr); // mark the cell as a dead cell.
     }
   }
 }
 bool nsCellMap::CellsSpanOut(nsTArray<nsTableRowFrame*>& aRows) const
 {
   int32_t numNewRows = aRows.Length();
   for (int32_t rowX = 0; rowX < numNewRows; rowX++) {
     nsIFrame* rowFrame = (nsIFrame *) aRows.ElementAt(rowX);
     nsIFrame* childFrame = rowFrame->GetFirstPrincipalChild();
     while (childFrame) {
       nsTableCellFrame *cellFrame = do_QueryFrame(childFrame);
       if (cellFrame) {
         bool zeroSpan;
         int32_t rowSpan = GetRowSpanForNewCell(cellFrame, rowX, zeroSpan);
         if (zeroSpan || rowX + rowSpan > numNewRows) {
           return true;
         }
       }
       childFrame = childFrame->GetNextSibling();
     }
   }
   return false;
 }
 // return true if any cells have rows spans into or out of the region
 // defined by the row and col indices or any cells have colspans into the region
 bool nsCellMap::CellsSpanInOrOut(int32_t aStartRowIndex,
                                    int32_t aEndRowIndex,
                                    int32_t aStartColIndex,
                                    int32_t aEndColIndex) const
 {
   /*
    * this routine will watch the cells adjacent to the region or at the edge
    * they are marked with *. The routine will verify whether they span in or
    * are spanned out.
    *
    *                           startCol          endCol
    *             r1c1   r1c2   r1c3      r1c4    r1c5    r1rc6  r1c7
    *  startrow   r2c1   r2c2  *r2c3     *r2c4   *r2c5   *r2rc6  r2c7
    *  endrow     r3c1   r3c2  *r3c3      r3c4    r3c5   *r3rc6  r3c7
    *             r4c1   r4c2  *r4c3     *r4c4   *r4c5    r4rc6  r4c7
    *             r5c1   r5c2   r5c3      r5c4    r5c5    r5rc6  r5c7
    */
   int32_t numRows = mRows.Length(); // use the cellmap rows to determine the
                                     // current cellmap extent.
   for (int32_t colX = aStartColIndex; colX <= aEndColIndex; colX++) {
     CellData* cellData;
     if (aStartRowIndex > 0) {
       cellData = GetDataAt(aStartRowIndex, colX);
       if (cellData && (cellData->IsRowSpan())) {
         return true; // there is a row span into the region
       }
       if ((aStartRowIndex >= mContentRowCount) &&  (mContentRowCount > 0)) {
         cellData = GetDataAt(mContentRowCount - 1, colX);
         if (cellData && cellData->IsZeroRowSpan()) {
           return true;  // When we expand the zerospan it'll span into our row
         }
       }
     }
     if (aEndRowIndex < numRows - 1) { // is there anything below aEndRowIndex
       cellData = GetDataAt(aEndRowIndex + 1, colX);
       if ((cellData) && (cellData->IsRowSpan())) {
         return true; // there is a row span out of the region
       }
     }
     else {
       cellData = GetDataAt(aEndRowIndex, colX);
       if ((cellData) && (cellData->IsRowSpan()) && (mContentRowCount < numRows)) {
         return true; // this cell might be the cause of a dead row
       }
     }
   }
   if (aStartColIndex > 0) {
     for (int32_t rowX = aStartRowIndex; rowX <= aEndRowIndex; rowX++) {
       CellData* cellData = GetDataAt(rowX, aStartColIndex);
       if (cellData && (cellData->IsColSpan())) {
         return true; // there is a col span into the region
       }
       cellData = GetDataAt(rowX, aEndColIndex + 1);
       if (cellData && (cellData->IsColSpan())) {
         return true; // there is a col span out of the region
       }
     }
   }
   return false;
 }
 void nsCellMap::InsertCells(nsTableCellMap&              aMap,
                             nsTArray<nsTableCellFrame*>& aCellFrames,
                             int32_t                      aRowIndex,
                             int32_t                      aColIndexBefore,
                             int32_t                      aRgFirstRowIndex,
                             nsIntRect&                   aDamageArea)
 {
   if (aCellFrames.Length() == 0) return;
   NS_ASSERTION(aColIndexBefore >= -1, "index out of range");
   int32_t numCols = aMap.GetColCount();
   if (aColIndexBefore >= numCols) {
     NS_ERROR("Inserting instead of appending cells indicates a serious cellmap error");
     aColIndexBefore = numCols - 1;
   }
   // get the starting col index of the 1st new cells
   int32_t startColIndex;
   for (startColIndex = aColIndexBefore + 1; startColIndex < numCols; startColIndex++) {
     CellData* data = GetDataAt(aRowIndex, startColIndex);
     if (!data || data->IsOrig() || data->IsDead()) {
       // // Not a span.  Stop.
       break;
     }
     if (data->IsZeroColSpan()) {
       // Zero colspans collapse.  Stop in this case too.
       CollapseZeroColSpan(aMap, data, aRowIndex, startColIndex);
       break;
     }
   }
   // record whether inserted cells are going to cause complications due
   // to existing row spans, col spans or table sizing.
   bool spansCauseRebuild = false;
   // check that all cells have the same row span
   int32_t numNewCells = aCellFrames.Length();
   bool zeroRowSpan = false;
   int32_t rowSpan = 0;
   for (int32_t cellX = 0; cellX < numNewCells; cellX++) {
     nsTableCellFrame* cell = aCellFrames.ElementAt(cellX);
     int32_t rowSpan2 = GetRowSpanForNewCell(cell, aRowIndex, zeroRowSpan);
     if (rowSpan == 0) {
       rowSpan = rowSpan2;
     }
     else if (rowSpan != rowSpan2) {
       spansCauseRebuild = true;
       break;
     }
   }
   // check if the new cells will cause the table to add more rows
   if (!spansCauseRebuild) {
     if (mRows.Length() < uint32_t(aRowIndex + rowSpan)) {
       spansCauseRebuild = true;
     }
   }
   if (!spansCauseRebuild) {
     spansCauseRebuild = CellsSpanInOrOut(aRowIndex, aRowIndex + rowSpan - 1,
                                          startColIndex, numCols - 1);
   }
   if (spansCauseRebuild) {
     aMap.RebuildConsideringCells(this, &aCellFrames, aRowIndex, startColIndex,
                                  true, aDamageArea);
   }
   else {
     ExpandWithCells(aMap, aCellFrames, aRowIndex, startColIndex, rowSpan,
                     zeroRowSpan, aRgFirstRowIndex, aDamageArea);
   }
 }
 void
 nsCellMap::ExpandWithRows(nsTableCellMap&             aMap,
                           nsTArray<nsTableRowFrame*>& aRowFrames,
                           int32_t                     aStartRowIndexIn,
                           int32_t                     aRgFirstRowIndex,
                           nsIntRect&                  aDamageArea)
 {
   int32_t startRowIndex = (aStartRowIndexIn >= 0) ? aStartRowIndexIn : 0;
   NS_ASSERTION(uint32_t(startRowIndex) <= mRows.Length(), "caller should have grown cellmap before");
   int32_t numNewRows  = aRowFrames.Length();
   mContentRowCount += numNewRows;
   int32_t endRowIndex = startRowIndex + numNewRows - 1;
   // shift the rows after startRowIndex down and insert empty rows that will
   // be filled via the AppendCell call below
   if (!Grow(aMap, numNewRows, startRowIndex)) {
     return;
   }
   int32_t newRowIndex = 0;
   for (int32_t rowX = startRowIndex; rowX <= endRowIndex; rowX++) {
     nsTableRowFrame* rFrame = aRowFrames.ElementAt(newRowIndex);
     // append cells
     nsIFrame* cFrame = rFrame->GetFirstPrincipalChild();
     int32_t colIndex = 0;
     while (cFrame) {
       nsTableCellFrame *cellFrame = do_QueryFrame(cFrame);
       if (cellFrame) {
         AppendCell(aMap, cellFrame, rowX, false, aRgFirstRowIndex, aDamageArea,
                    &colIndex);
       }
       cFrame = cFrame->GetNextSibling();
     }
     newRowIndex++;
   }
   // mark all following rows damaged, they might contain a previously set
   // damage area which we can not shift.
   int32_t firstDamagedRow = aRgFirstRowIndex + startRowIndex;
   SetDamageArea(0, firstDamagedRow, aMap.GetColCount(),
                 aMap.GetRowCount() - firstDamagedRow, aDamageArea);
 }
 void nsCellMap::ExpandWithCells(nsTableCellMap&              aMap,
                                 nsTArray<nsTableCellFrame*>& aCellFrames,
                                 int32_t                      aRowIndex,
                                 int32_t                      aColIndex,
                                 int32_t                      aRowSpan, // same for all cells
                                 bool                         aRowSpanIsZero,
                                 int32_t                      aRgFirstRowIndex,
                                 nsIntRect&                   aDamageArea)
 {
   NS_ASSERTION(!!aMap.mBCInfo == mIsBC, "BC state mismatch");
   int32_t endRowIndex = aRowIndex + aRowSpan - 1;
   int32_t startColIndex = aColIndex;
   int32_t endColIndex = aColIndex;
   int32_t numCells = aCellFrames.Length();
   int32_t totalColSpan = 0;
   // add cellData entries for the space taken up by the new cells
   for (int32_t cellX = 0; cellX < numCells; cellX++) {
     nsTableCellFrame* cellFrame = aCellFrames.ElementAt(cellX);
     CellData* origData = AllocCellData(cellFrame); // the originating cell
     if (!origData) return;
     // set the starting and ending col index for the new cell
     bool zeroColSpan = false;
     int32_t colSpan = GetColSpanForNewCell(*cellFrame, zeroColSpan);
     if (zeroColSpan) {
       aMap.mTableFrame.SetHasZeroColSpans(true);
       aMap.mTableFrame.SetNeedColSpanExpansion(true);
     }
     totalColSpan += colSpan;
     if (cellX == 0) {
       endColIndex = aColIndex + colSpan - 1;
     }
     else {
       startColIndex = endColIndex + 1;
       endColIndex   = startColIndex + colSpan - 1;
     }
     // add the originating cell data and any cell data corresponding to row/col spans
     for (int32_t rowX = aRowIndex; rowX <= endRowIndex; rowX++) {
       CellDataArray& row = mRows[rowX];
       // Pre-allocate all the cells we'll need in this array, setting
       // them to null.
       // Have to have the cast to get the template to do the right thing.
       int32_t insertionIndex = row.Length();
       if (insertionIndex > startColIndex) {
         insertionIndex = startColIndex;
       }
       if (!row.InsertElementsAt(insertionIndex, endColIndex - insertionIndex + 1,
                                 (CellData*)nullptr) &&
           rowX == aRowIndex) {
         // Failed to insert the slots, and this is the very first row.  That
         // means that we need to clean up |origData| before returning, since
         // the cellmap doesn't own it yet.
         DestroyCellData(origData);
         return;
       }
       for (int32_t colX = startColIndex; colX <= endColIndex; colX++) {
         CellData* data = origData;
         if ((rowX != aRowIndex) || (colX != startColIndex)) {
           data = AllocCellData(nullptr);
           if (!data) return;
           if (rowX > aRowIndex) {
             data->SetRowSpanOffset(rowX - aRowIndex);
             if (aRowSpanIsZero) {
               data->SetZeroRowSpan(true);
             }
           }
           if (colX > startColIndex) {
             data->SetColSpanOffset(colX - startColIndex);
             if (zeroColSpan) {
               data->SetZeroColSpan(true);
             }
           }
         }
         SetDataAt(aMap, *data, rowX, colX);
       }
     }
     cellFrame->SetColIndex(startColIndex);
   }
   int32_t damageHeight = std::min(GetRowGroup()->GetRowCount() - aRowIndex,
                                 aRowSpan);
   SetDamageArea(aColIndex, aRgFirstRowIndex + aRowIndex,
 + endColIndex - aColIndex, damageHeight, aDamageArea);
   int32_t rowX;
   // update the row and col info due to shifting
   for (rowX = aRowIndex; rowX <= endRowIndex; rowX++) {
     CellDataArray& row = mRows[rowX];
     uint32_t numCols = row.Length();
     uint32_t colX;
     for (colX = aColIndex + totalColSpan; colX < numCols; colX++) {
       CellData* data = row[colX];
       if (data) {
         // increase the origin and span counts beyond the spanned cols
         if (data->IsOrig()) {
           // a cell that gets moved needs adjustment as well as it new orignating col
           data->GetCellFrame()->SetColIndex(colX);
           nsColInfo* colInfo = aMap.GetColInfoAt(colX);
           colInfo->mNumCellsOrig++;
         }
         if (data->IsColSpan()) {
           nsColInfo* colInfo = aMap.GetColInfoAt(colX);
           colInfo->mNumCellsSpan++;
         }
         // decrease the origin and span counts within the spanned cols
         int32_t colX2 = colX - totalColSpan;
         nsColInfo* colInfo2 = aMap.GetColInfoAt(colX2);
         if (data->IsOrig()) {
           // the old originating col of a moved cell needs adjustment
           colInfo2->mNumCellsOrig--;
         }
         if (data->IsColSpan()) {
           colInfo2->mNumCellsSpan--;
         }
       }
     }
   }
 }
 void nsCellMap::ShrinkWithoutRows(nsTableCellMap& aMap,
                                   int32_t         aStartRowIndex,
                                   int32_t         aNumRowsToRemove,
                                   int32_t         aRgFirstRowIndex,
                                   nsIntRect&      aDamageArea)
 {
   NS_ASSERTION(!!aMap.mBCInfo == mIsBC, "BC state mismatch");
   int32_t endRowIndex = aStartRowIndex + aNumRowsToRemove - 1;
   uint32_t colCount = aMap.GetColCount();
   for (int32_t rowX = endRowIndex; rowX >= aStartRowIndex; --rowX) {
     CellDataArray& row = mRows[rowX];
     uint32_t colX;
     for (colX = 0; colX < colCount; colX++) {
       CellData* data = row.SafeElementAt(colX);
       if (data) {
         // Adjust the column counts.
         if (data->IsOrig()) {
           // Decrement the column count.
           nsColInfo* colInfo = aMap.GetColInfoAt(colX);
           colInfo->mNumCellsOrig--;
         }
         // colspan=0 is only counted as a spanned cell in the 1st col it spans
         else if (data->IsColSpan()) {
           nsColInfo* colInfo = aMap.GetColInfoAt(colX);
           colInfo->mNumCellsSpan--;
         }
       }
     }
     uint32_t rowLength = row.Length();
     // Delete our row information.
     for (colX = 0; colX < rowLength; colX++) {
       DestroyCellData(row[colX]);
     }
     mRows.RemoveElementAt(rowX);
     // Decrement our row and next available index counts.
     mContentRowCount--;
   }
   aMap.RemoveColsAtEnd();
   // mark all following rows damaged, they might contain a previously set
   // damage area which we can not shift.
   int32_t firstDamagedRow = aRgFirstRowIndex + aStartRowIndex;
   SetDamageArea(0, firstDamagedRow, aMap.GetColCount(),
                 aMap.GetRowCount() - firstDamagedRow, aDamageArea);
 }
 int32_t nsCellMap::GetColSpanForNewCell(nsTableCellFrame& aCellFrameToAdd,
                                         bool&           aIsZeroColSpan) const
 {
   aIsZeroColSpan = false;
   int32_t colSpan = aCellFrameToAdd.GetColSpan();
   if (0 == colSpan) {
     colSpan = 1; // set the min colspan it will be expanded later
     aIsZeroColSpan = true;
   }
   return colSpan;
 }
 int32_t nsCellMap::GetEffectiveColSpan(const nsTableCellMap& aMap,
                                        int32_t         aRowIndex,
                                        int32_t         aColIndex,
                                        bool&         aZeroColSpan) const
 {
   int32_t numColsInTable = aMap.GetColCount();
   aZeroColSpan = false;
   int32_t colSpan = 1;
   if (uint32_t(aRowIndex) >= mRows.Length()) {
     return colSpan;
   }
   const CellDataArray& row = mRows[aRowIndex];
   int32_t colX;
   CellData* data;
   int32_t maxCols = numColsInTable;
   bool hitOverlap = false; // XXX this is not ever being set to true
   for (colX = aColIndex + 1; colX < maxCols; colX++) {
     data = row.SafeElementAt(colX);
     if (data) {
       // for an overlapping situation get the colspan from the originating cell and
       // use that as the max number of cols to iterate. Since this is rare, only
       // pay the price of looking up the cell's colspan here.
       if (!hitOverlap && data->IsOverlap()) {
         CellData* origData = row.SafeElementAt(aColIndex);
         if (origData && origData->IsOrig()) {
           nsTableCellFrame* cellFrame = origData->GetCellFrame();
           if (cellFrame) {
             // possible change the number of colums to iterate
             maxCols = std::min(aColIndex + cellFrame->GetColSpan(), maxCols);
             if (colX >= maxCols)
               break;
           }
         }
       }
       if (data->IsColSpan()) {
         colSpan++;
         if (data->IsZeroColSpan()) {
           aZeroColSpan = true;
         }
       }
       else {
         break;
       }
     }
     else break;
   }
   return colSpan;
 }
 int32_t
 nsCellMap::GetRowSpanForNewCell(nsTableCellFrame* aCellFrameToAdd,
                                 int32_t           aRowIndex,
                                 bool&           aIsZeroRowSpan) const
 {
   aIsZeroRowSpan = false;
   int32_t rowSpan = aCellFrameToAdd->GetRowSpan();
   if (0 == rowSpan) {
     // Use a min value of 2 for a zero rowspan to make computations easier
     // elsewhere. Zero rowspans are only content dependent!
     rowSpan = std::max(2, mContentRowCount - aRowIndex);
     aIsZeroRowSpan = true;
   }
   return rowSpan;
 }
 bool nsCellMap::HasMoreThanOneCell(int32_t aRowIndex) const
 {
   const CellDataArray& row = mRows.SafeElementAt(aRowIndex, *sEmptyRow);
   uint32_t maxColIndex = row.Length();
   uint32_t count = 0;
   uint32_t colIndex;
   for (colIndex = 0; colIndex < maxColIndex; colIndex++) {
     CellData* cellData = row[colIndex];
     if (cellData && (cellData->GetCellFrame() || cellData->IsRowSpan()))
       count++;
     if (count > 1)
       return true;
   }
   return false;
 }
 int32_t
 nsCellMap::GetNumCellsOriginatingInRow(int32_t aRowIndex) const
 {
   const CellDataArray& row = mRows.SafeElementAt(aRowIndex, *sEmptyRow);
   uint32_t count = 0;
   uint32_t maxColIndex = row.Length();
   uint32_t colIndex;
   for (colIndex = 0; colIndex < maxColIndex; colIndex++) {
     CellData* cellData = row[colIndex];
     if (cellData && cellData->IsOrig())
       count++;
   }
   return count;
 }
 int32_t nsCellMap::GetRowSpan(int32_t  aRowIndex,
                               int32_t  aColIndex,
                               bool     aGetEffective) const
 {
   int32_t rowSpan = 1;
   int32_t rowCount = (aGetEffective) ? mContentRowCount : mRows.Length();
   int32_t rowX;
   for (rowX = aRowIndex + 1; rowX < rowCount; rowX++) {
     CellData* data = GetDataAt(rowX, aColIndex);
     if (data) {
       if (data->IsRowSpan()) {
         rowSpan++;
       }
       else {
         break;
       }
     }
     else break;
   }
   return rowSpan;
 }
 void nsCellMap::ShrinkWithoutCell(nsTableCellMap&   aMap,
                                   nsTableCellFrame& aCellFrame,
                                   int32_t           aRowIndex,
                                   int32_t           aColIndex,
                                   int32_t           aRgFirstRowIndex,
                                   nsIntRect&        aDamageArea)
 {
   NS_ASSERTION(!!aMap.mBCInfo == mIsBC, "BC state mismatch");
   uint32_t colX, rowX;
   // get the rowspan and colspan from the cell map since the content may have changed
   bool zeroColSpan;
   uint32_t numCols = aMap.GetColCount();
   int32_t rowSpan = GetRowSpan(aRowIndex, aColIndex, true);
   uint32_t colSpan = GetEffectiveColSpan(aMap, aRowIndex, aColIndex, zeroColSpan);
   uint32_t endRowIndex = aRowIndex + rowSpan - 1;
   uint32_t endColIndex = aColIndex + colSpan - 1;
   if (aMap.mTableFrame.HasZeroColSpans()) {
     aMap.mTableFrame.SetNeedColSpanExpansion(true);
   }
   // adjust the col counts due to the deleted cell before removing it
   for (colX = aColIndex; colX <= endColIndex; colX++) {
     nsColInfo* colInfo = aMap.GetColInfoAt(colX);
     if (colX == uint32_t(aColIndex)) {
       colInfo->mNumCellsOrig--;
     }
     else  {
       colInfo->mNumCellsSpan--;
     }
   }
   // remove the deleted cell and cellData entries for it
   for (rowX = aRowIndex; rowX <= endRowIndex; rowX++) {
     CellDataArray& row = mRows[rowX];
     // endIndexForRow points at the first slot we don't want to clean up.  This
     // makes the aColIndex == 0 case work right with our unsigned int colX.
     NS_ASSERTION(endColIndex + 1 <= row.Length(), "span beyond the row size!");
     uint32_t endIndexForRow = std::min(endColIndex + 1, row.Length());
     // Since endIndexForRow <= row.Length(), enough to compare aColIndex to it.
     if (uint32_t(aColIndex) < endIndexForRow) {
       for (colX = endIndexForRow; colX > uint32_t(aColIndex); colX--) {
         DestroyCellData(row[colX-1]);
       }
       row.RemoveElementsAt(aColIndex, endIndexForRow - aColIndex);
     }
   }
   numCols = aMap.GetColCount();
   // update the row and col info due to shifting
   for (rowX = aRowIndex; rowX <= endRowIndex; rowX++) {
     CellDataArray& row = mRows[rowX];
     for (colX = aColIndex; colX < numCols - colSpan; colX++) {
       CellData* data = row.SafeElementAt(colX);
       if (data) {
         if (data->IsOrig()) {
           // a cell that gets moved to the left needs adjustment in its new location
           data->GetCellFrame()->SetColIndex(colX);
           nsColInfo* colInfo = aMap.GetColInfoAt(colX);
           colInfo->mNumCellsOrig++;
           // a cell that gets moved to the left needs adjustment in its old location
           colInfo = aMap.GetColInfoAt(colX + colSpan);
           if (colInfo) {
             colInfo->mNumCellsOrig--;
           }
         }
         else if (data->IsColSpan()) {
           // a cell that gets moved to the left needs adjustment
           // in its new location
           nsColInfo* colInfo = aMap.GetColInfoAt(colX);
           colInfo->mNumCellsSpan++;
           // a cell that gets moved to the left needs adjustment
           // in its old location
           colInfo = aMap.GetColInfoAt(colX + colSpan);
           if (colInfo) {
             colInfo->mNumCellsSpan--;
           }
         }
       }
     }
   }
   aMap.RemoveColsAtEnd();
   SetDamageArea(aColIndex, aRgFirstRowIndex + aRowIndex,
                 std::max(0, aMap.GetColCount() - aColIndex - 1),
 + endRowIndex - aRowIndex, aDamageArea);
 }
 void
 nsCellMap::RebuildConsideringRows(nsTableCellMap&             aMap,
                                   int32_t                     aStartRowIndex,
                                   nsTArray<nsTableRowFrame*>* aRowsToInsert,
                                   int32_t                     aNumRowsToRemove)
 {
   NS_ASSERTION(!!aMap.mBCInfo == mIsBC, "BC state mismatch");
   // copy the old cell map into a new array
   uint32_t numOrigRows = mRows.Length();
   nsTArray<CellDataArray> origRows;
   mRows.SwapElements(origRows);
   int32_t rowNumberChange;
   if (aRowsToInsert) {
     rowNumberChange = aRowsToInsert->Length();
   } else {
     rowNumberChange = -aNumRowsToRemove;
   }
   // adjust mContentRowCount based on the function arguments as they are known to
   // be real rows.
   mContentRowCount += rowNumberChange;
   NS_ASSERTION(mContentRowCount >= 0, "previous mContentRowCount was wrong");
   // mRows is empty now.  Grow it to the size we expect it to have.
   if (mContentRowCount) {
     if (!Grow(aMap, mContentRowCount)) {
       // Bail, I guess...  Not sure what else we can do here.
       return;
     }
   }
   // aStartRowIndex might be after all existing rows so we should limit the
   // copy to the amount of exisiting rows
   uint32_t copyEndRowIndex = std::min(numOrigRows, uint32_t(aStartRowIndex));
   // rowX keeps track of where we are in mRows while setting up the
   // new cellmap.
   uint32_t rowX = 0;
   nsIntRect damageArea;
   // put back the rows before the affected ones just as before.  Note that we
   // can't just copy the old rows in bit-for-bit, because they might be
   // spanning out into the rows we're adding/removing.
   for ( ; rowX < copyEndRowIndex; rowX++) {
     const CellDataArray& row = origRows[rowX];
     uint32_t numCols = row.Length();
     for (uint32_t colX = 0; colX < numCols; colX++) {
       // put in the original cell from the cell map
       const CellData* data = row.ElementAt(colX);
       if (data && data->IsOrig()) {
         AppendCell(aMap, data->GetCellFrame(), rowX, false, 0, damageArea);
       }
     }
   }
   // Now handle the new rows being inserted, if any.
   uint32_t copyStartRowIndex;
   rowX = aStartRowIndex;
   if (aRowsToInsert) {
     // add in the new cells and create rows if necessary
     int32_t numNewRows = aRowsToInsert->Length();
     for (int32_t newRowX = 0; newRowX < numNewRows; newRowX++) {
       nsTableRowFrame* rFrame = aRowsToInsert->ElementAt(newRowX);
       nsIFrame* cFrame = rFrame->GetFirstPrincipalChild();
       while (cFrame) {
         nsTableCellFrame *cellFrame = do_QueryFrame(cFrame);
         if (cellFrame) {
           AppendCell(aMap, cellFrame, rowX, false, 0, damageArea);
         }
         cFrame = cFrame->GetNextSibling();
       }
       rowX++;
     }
     copyStartRowIndex = aStartRowIndex;
   }
   else {
     copyStartRowIndex = aStartRowIndex + aNumRowsToRemove;
   }
   // put back the rows after the affected ones just as before.  Again, we can't
   // just copy the old bits because that would not handle the new rows spanning
   // out or our earlier old rows spanning through the damaged area.
   for (uint32_t copyRowX = copyStartRowIndex; copyRowX < numOrigRows;
        copyRowX++) {
     const CellDataArray& row = origRows[copyRowX];
     uint32_t numCols = row.Length();
     for (uint32_t colX = 0; colX < numCols; colX++) {
       // put in the original cell from the cell map
       CellData* data = row.ElementAt(colX);
       if (data && data->IsOrig()) {
         AppendCell(aMap, data->GetCellFrame(), rowX, false, 0, damageArea);
       }
     }
     rowX++;
   }
   // delete the old cell map.  Now rowX no longer has anything to do with mRows
   for (rowX = 0; rowX < numOrigRows; rowX++) {
     CellDataArray& row = origRows[rowX];
     uint32_t len = row.Length();
     for (uint32_t colX = 0; colX < len; colX++) {
       DestroyCellData(row[colX]);
     }
   }
 }
 void
 nsCellMap::RebuildConsideringCells(nsTableCellMap&              aMap,
                                    int32_t                      aNumOrigCols,
                                    nsTArray<nsTableCellFrame*>* aCellFrames,
                                    int32_t                      aRowIndex,
                                    int32_t                      aColIndex,
                                    bool                         aInsert)
 {
   NS_ASSERTION(!!aMap.mBCInfo == mIsBC, "BC state mismatch");
   // copy the old cell map into a new array
   int32_t numOrigRows  = mRows.Length();
   nsTArray<CellDataArray> origRows;
   mRows.SwapElements(origRows);
   int32_t numNewCells = (aCellFrames) ? aCellFrames->Length() : 0;
   // the new cells might extend the previous column number
   NS_ASSERTION(aNumOrigCols >= aColIndex, "Appending cells far beyond cellmap data?!");
   int32_t numCols = aInsert ? std::max(aNumOrigCols, aColIndex + 1) : aNumOrigCols;
   // build the new cell map.  Hard to say what, if anything, we can preallocate
   // here...  Should come back to that sometime, perhaps.
   int32_t rowX;
   nsIntRect damageArea;
   for (rowX = 0; rowX < numOrigRows; rowX++) {
     const CellDataArray& row = origRows[rowX];
     for (int32_t colX = 0; colX < numCols; colX++) {
       if ((rowX == aRowIndex) && (colX == aColIndex)) {
         if (aInsert) { // put in the new cells
           for (int32_t cellX = 0; cellX < numNewCells; cellX++) {
             nsTableCellFrame* cell = aCellFrames->ElementAt(cellX);
             if (cell) {
               AppendCell(aMap, cell, rowX, false, 0, damageArea);
             }
           }
         }
         else {
           continue; // do not put the deleted cell back
         }
       }
       // put in the original cell from the cell map
       CellData* data = row.SafeElementAt(colX);
       if (data && data->IsOrig()) {
         AppendCell(aMap, data->GetCellFrame(), rowX, false, 0, damageArea);
       }
     }
   }
   if (aInsert && numOrigRows <= aRowIndex) { // append the new cells below the last original row
     NS_ASSERTION (numOrigRows == aRowIndex, "Appending cells far beyond the last row");
     for (int32_t cellX = 0; cellX < numNewCells; cellX++) {
       nsTableCellFrame* cell = aCellFrames->ElementAt(cellX);
       if (cell) {
         AppendCell(aMap, cell, aRowIndex, false, 0, damageArea);
       }
     }
   }
   // delete the old cell map
   for (rowX = 0; rowX < numOrigRows; rowX++) {
     CellDataArray& row = origRows[rowX];
     uint32_t len = row.Length();
     for (uint32_t colX = 0; colX < len; colX++) {
       DestroyCellData(row.SafeElementAt(colX));
     }
   }
   // expand the cellmap to cover empty content rows
   if (mRows.Length() < uint32_t(mContentRowCount)) {
     Grow(aMap, mContentRowCount - mRows.Length());
   }
 }
 void nsCellMap::RemoveCell(nsTableCellMap&   aMap,
                            nsTableCellFrame* aCellFrame,
                            int32_t           aRowIndex,
                            int32_t           aRgFirstRowIndex,
                            nsIntRect&        aDamageArea)
 {
   uint32_t numRows = mRows.Length();
   if (uint32_t(aRowIndex) >= numRows) {
     NS_ERROR("bad arg in nsCellMap::RemoveCell");
     return;
   }
   int32_t numCols = aMap.GetColCount();
   // Now aRowIndex is guaranteed OK.
   // get the starting col index of the cell to remove
   int32_t startColIndex;
   for (startColIndex = 0; startColIndex < numCols; startColIndex++) {
     CellData* data = mRows[aRowIndex].SafeElementAt(startColIndex);
     if (data && (data->IsOrig()) && (aCellFrame == data->GetCellFrame())) {
       break; // we found the col index
     }
   }
   int32_t rowSpan = GetRowSpan(aRowIndex, startColIndex, false);
   // record whether removing the cells is going to cause complications due
   // to existing row spans, col spans or table sizing.
   bool spansCauseRebuild = CellsSpanInOrOut(aRowIndex,
                                               aRowIndex + rowSpan - 1,
                                               startColIndex, numCols - 1);
   // XXX if the cell has a col span to the end of the map, and the end has no originating
   // cells, we need to assume that this the only such cell, and rebuild so that there are
   // no extraneous cols at the end. The same is true for removing rows.
   if (!aCellFrame->GetRowSpan() || !aCellFrame->GetColSpan())
     spansCauseRebuild = true;
   if (spansCauseRebuild) {
     aMap.RebuildConsideringCells(this, nullptr, aRowIndex, startColIndex, false,
                                  aDamageArea);
   }
   else {
     ShrinkWithoutCell(aMap, *aCellFrame, aRowIndex, startColIndex,
                       aRgFirstRowIndex, aDamageArea);
   }
 }
 void nsCellMap::ExpandZeroColSpans(nsTableCellMap& aMap)
 {
   NS_ASSERTION(!!aMap.mBCInfo == mIsBC, "BC state mismatch");
   uint32_t numRows = mRows.Length();
   uint32_t numCols = aMap.GetColCount();
   uint32_t rowIndex, colIndex;
   for (rowIndex = 0; rowIndex < numRows; rowIndex++) {
     for (colIndex = 0; colIndex < numCols; colIndex++) {
       CellData* data = mRows[rowIndex].SafeElementAt(colIndex);
       if (!data || !data->IsOrig())
         continue;
       nsTableCellFrame* cell = data->GetCellFrame();
       NS_ASSERTION(cell, "There has to be a cell");
       int32_t cellRowSpan = cell->GetRowSpan();
       int32_t cellColSpan = cell->GetColSpan();
       bool rowZeroSpan = (0 == cell->GetRowSpan());
       bool colZeroSpan = (0 == cell->GetColSpan());
       if (colZeroSpan) {
         aMap.mTableFrame.SetHasZeroColSpans(true);
         // do the expansion
         NS_ASSERTION(numRows > 0, "Bogus numRows");
         NS_ASSERTION(numCols > 0, "Bogus numCols");
         uint32_t endRowIndex =  rowZeroSpan ? numRows - 1 :
                                               rowIndex + cellRowSpan - 1;
         uint32_t endColIndex =  colZeroSpan ? numCols - 1 :
                                               colIndex + cellColSpan - 1;
         uint32_t colX, rowX;
         colX = colIndex + 1;
         while (colX <= endColIndex) {
           // look at columns from here to our colspan.  For each one, check
           // the rows from here to our rowspan to make sure there is no
           // obstacle to marking that column as a zerospanned column; if there
           // isn't, mark it so
           for (rowX = rowIndex; rowX <= endRowIndex; rowX++) {
             CellData* oldData = GetDataAt(rowX, colX);
             if (oldData) {
               if (oldData->IsOrig()) {
                 break; // something is in the way
               }
               if (oldData->IsRowSpan()) {
                 if ((rowX - rowIndex) != oldData->GetRowSpanOffset()) {
                   break;
                 }
               }
               if (oldData->IsColSpan()) {
                 if ((colX - colIndex) != oldData->GetColSpanOffset()) {
                   break;
                 }
               }
             }
           }
           if (endRowIndex >= rowX)
             break;// we hit something
           for (rowX = rowIndex; rowX <= endRowIndex; rowX++) {
             CellData* newData = AllocCellData(nullptr);
             if (!newData) return;
             newData->SetColSpanOffset(colX - colIndex);
             newData->SetZeroColSpan(true);
             if (rowX > rowIndex) {
               newData->SetRowSpanOffset(rowX - rowIndex);
               if (rowZeroSpan)
                 newData->SetZeroRowSpan(true);
             }
             SetDataAt(aMap, *newData, rowX, colX);
           }
           colX++;
         }  // while (colX <= endColIndex)
       } // if zerocolspan
     }
   }
 }
 #ifdef DEBUG
 void nsCellMap::Dump(bool aIsBorderCollapse) const
 {
   printf("\n  ***** START GROUP CELL MAP DUMP ***** %p\n", (void*)this);
   nsTableRowGroupFrame* rg = GetRowGroup();
   const nsStyleDisplay* display = rg->StyleDisplay();
   switch (display->mDisplay) {
   case NS_STYLE_DISPLAY_TABLE_HEADER_GROUP:
     printf("  thead ");
     break;
   case NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP:
     printf("  tfoot ");
     break;
   case NS_STYLE_DISPLAY_TABLE_ROW_GROUP:
     printf("  tbody ");
     break;
   default:
     printf("HUH? wrong display type on rowgroup");
   }
   uint32_t mapRowCount = mRows.Length();
   printf("mapRowCount=%u tableRowCount=%d\n", mapRowCount, mContentRowCount);
   uint32_t rowIndex, colIndex;
   for (rowIndex = 0; rowIndex < mapRowCount; rowIndex++) {
     const CellDataArray& row = mRows[rowIndex];
     printf("  row %d : ", rowIndex);
     uint32_t colCount = row.Length();
     for (colIndex = 0; colIndex < colCount; colIndex++) {
       CellData* cd = row[colIndex];
       if (cd) {
         if (cd->IsOrig()) {
           printf("C%d,%d  ", rowIndex, colIndex);
         } else {
           if (cd->IsRowSpan()) {
             printf("R ");
           }
           if (cd->IsColSpan()) {
             printf("C ");
           }
           if (!(cd->IsRowSpan() && cd->IsColSpan())) {
             printf("  ");
           }
           printf("  ");
         }
       } else {
         printf("----  ");
       }
     }
     if (aIsBorderCollapse) {
       nscoord       size;
       BCBorderOwner owner;
       mozilla::css::Side side;
       bool          segStart;
       bool          bevel;
       for (int32_t i = 0; i <= 2; i++) {
         printf("\n          ");
         for (colIndex = 0; colIndex < colCount; colIndex++) {
           BCCellData* cd = (BCCellData *)row[colIndex];
           if (cd) {
             if (0 == i) {
               size = cd->mData.GetTopEdge(owner, segStart);
               printf("t=%d%d%d ", int32_t(size), owner, segStart);
             }
             else if (1 == i) {
               size = cd->mData.GetLeftEdge(owner, segStart);
               printf("l=%d%d%d ", int32_t(size), owner, segStart);
             }
             else {
               size = cd->mData.GetCorner(side, bevel);
               printf("c=%d%d%d ", int32_t(size), side, bevel);
             }
           }
         }
       }
     }
     printf("\n");
   }
   // output info mapping Ci,j to cell address
   uint32_t cellCount = 0;
   for (uint32_t rIndex = 0; rIndex < mapRowCount; rIndex++) {
     const CellDataArray& row = mRows[rIndex];
     uint32_t colCount = row.Length();
     printf("  ");
     for (colIndex = 0; colIndex < colCount; colIndex++) {
       CellData* cd = row[colIndex];
       if (cd) {
         if (cd->IsOrig()) {
           nsTableCellFrame* cellFrame = cd->GetCellFrame();
           int32_t cellFrameColIndex;
           cellFrame->GetColIndex(cellFrameColIndex);
           printf("C%d,%d=%p(%d)  ", rIndex, colIndex, (void*)cellFrame,
                  cellFrameColIndex);
           cellCount++;
         }
       }
     }
     printf("\n");
   }
   printf("  ***** END GROUP CELL MAP DUMP *****\n");
 }
 #endif
 CellData*
 nsCellMap::GetDataAt(int32_t         aMapRowIndex,
                      int32_t         aColIndex) const
 {
   return
     mRows.SafeElementAt(aMapRowIndex, *sEmptyRow).SafeElementAt(aColIndex);
 }
 // only called if the cell at aMapRowIndex, aColIndex is null or dead
 // (the latter from ExpandZeroColSpans).
 void nsCellMap::SetDataAt(nsTableCellMap& aMap,
                           CellData&       aNewCell,
                           int32_t         aMapRowIndex,
                           int32_t         aColIndex)
 {
   NS_ASSERTION(!!aMap.mBCInfo == mIsBC, "BC state mismatch");
   if (uint32_t(aMapRowIndex) >= mRows.Length()) {
     NS_ERROR("SetDataAt called with row index > num rows");
     return;
   }
   CellDataArray& row = mRows[aMapRowIndex];
   // the table map may need cols added
   int32_t numColsToAdd = aColIndex + 1 - aMap.GetColCount();
   if (numColsToAdd > 0) {
     aMap.AddColsAtEnd(numColsToAdd);
   }
   // the row may need cols added
   numColsToAdd = aColIndex + 1 - row.Length();
   if (numColsToAdd > 0) {
     // XXXbz need to handle allocation failures.
     GrowRow(row, numColsToAdd);
   }
   DestroyCellData(row[aColIndex]);
   row.ReplaceElementsAt(aColIndex, 1, &aNewCell);
   // update the originating cell counts if cell originates in this row, col
   nsColInfo* colInfo = aMap.GetColInfoAt(aColIndex);
   if (colInfo) {
     if (aNewCell.IsOrig()) {
       colInfo->mNumCellsOrig++;
     }
     else if (aNewCell.IsColSpan()) {
       colInfo->mNumCellsSpan++;
     }
   }
   else NS_ERROR("SetDataAt called with col index > table map num cols");
 }
 nsTableCellFrame*
 nsCellMap::GetCellInfoAt(const nsTableCellMap& aMap,
                          int32_t               aRowX,
                          int32_t               aColX,
                          bool*               aOriginates,
                          int32_t*              aColSpan) const
 {
   if (aOriginates) {
     *aOriginates = false;
   }
   CellData* data = GetDataAt(aRowX, aColX);
   nsTableCellFrame* cellFrame = nullptr;
   if (data) {
     if (data->IsOrig()) {
       cellFrame = data->GetCellFrame();
       if (aOriginates)
         *aOriginates = true;
     }
     else {
       cellFrame = GetCellFrame(aRowX, aColX, *data, true);
     }
     if (cellFrame && aColSpan) {
       int32_t initialColIndex;
       cellFrame->GetColIndex(initialColIndex);
       bool zeroSpan;
       *aColSpan = GetEffectiveColSpan(aMap, aRowX, initialColIndex, zeroSpan);
     }
   }
   return cellFrame;
 }
 bool nsCellMap::RowIsSpannedInto(int32_t         aRowIndex,
                                    int32_t         aNumEffCols) const
 {
   if ((0 > aRowIndex) || (aRowIndex >= mContentRowCount)) {
     return false;
   }
   for (int32_t colIndex = 0; colIndex < aNumEffCols; colIndex++) {
     CellData* cd = GetDataAt(aRowIndex, colIndex);
     if (cd) { // there's really a cell at (aRowIndex, colIndex)
       if (cd->IsSpan()) { // the cell at (aRowIndex, colIndex) is the result of a span
         if (cd->IsRowSpan() && GetCellFrame(aRowIndex, colIndex, *cd, true)) { // XXX why the last check
           return true;
         }
       }
     }
   }
   return false;
 }
 bool nsCellMap::RowHasSpanningCells(int32_t aRowIndex,
                                       int32_t aNumEffCols) const
 {
   if ((0 > aRowIndex) || (aRowIndex >= mContentRowCount)) {
     return false;
   }
   if (aRowIndex != mContentRowCount - 1) {
     // aRowIndex is not the last row, so we check the next row after aRowIndex for spanners
     for (int32_t colIndex = 0; colIndex < aNumEffCols; colIndex++) {
       CellData* cd = GetDataAt(aRowIndex, colIndex);
       if (cd && (cd->IsOrig())) { // cell originates
         CellData* cd2 = GetDataAt(aRowIndex + 1, colIndex);
         if (cd2 && cd2->IsRowSpan()) { // cd2 is spanned by a row
           if (cd->GetCellFrame() == GetCellFrame(aRowIndex + 1, colIndex, *cd2, true)) {
             return true;
           }
         }
       }
     }
   }
   return false;
 }
 void nsCellMap::DestroyCellData(CellData* aData)
 {
   if (!aData) {
     return;
   }
   if (mIsBC) {
     BCCellData* bcData = static_cast<BCCellData*>(aData);
     bcData->~BCCellData();
     mPresContext->FreeToShell(sizeof(BCCellData), bcData);
   } else {
     aData->~CellData();
     mPresContext->FreeToShell(sizeof(CellData), aData);
   }
 }
 CellData* nsCellMap::AllocCellData(nsTableCellFrame* aOrigCell)
 {
   if (mIsBC) {
     BCCellData* data = (BCCellData*)
       mPresContext->AllocateFromShell(sizeof(BCCellData));
     if (data) {
       new (data) BCCellData(aOrigCell);
     }
     return data;
   }
   CellData* data = (CellData*)
     mPresContext->AllocateFromShell(sizeof(CellData));
   if (data) {
     new (data) CellData(aOrigCell);
   }
   return data;
 }
 void
 nsCellMapColumnIterator::AdvanceRowGroup()
 {
   do {
     mCurMapStart += mCurMapContentRowCount;
     mCurMap = mCurMap->GetNextSibling();
     if (!mCurMap) {
       // Set mCurMapContentRowCount and mCurMapRelevantRowCount to 0 in case
       // mCurMap has no next sibling.  This can happen if we just handled the
       // last originating cell.  Future calls will end up with mFoundCells ==
       // mOrigCells, but for this one mFoundCells was definitely not big enough
       // if we got here.
       mCurMapContentRowCount = 0;
       mCurMapRelevantRowCount = 0;
       break;
     }
     mCurMapContentRowCount = mCurMap->GetRowCount();
     uint32_t rowArrayLength = mCurMap->mRows.Length();
     mCurMapRelevantRowCount = std::min(mCurMapContentRowCount, rowArrayLength);
   } while (0 == mCurMapRelevantRowCount);
   NS_ASSERTION(mCurMapRelevantRowCount != 0 || !mCurMap,
                "How did that happen?");
   // Set mCurMapRow to 0, since cells can't span across table row groups.
   mCurMapRow = 0;
 }
 void
 nsCellMapColumnIterator::IncrementRow(int32_t aIncrement)
 {
   NS_PRECONDITION(aIncrement >= 0, "Bogus increment");
   NS_PRECONDITION(mCurMap, "Bogus mOrigCells?");
   if (aIncrement == 0) {
     AdvanceRowGroup();
   }
   else {
     mCurMapRow += aIncrement;
     if (mCurMapRow >= mCurMapRelevantRowCount) {
       AdvanceRowGroup();
     }
   }
 }
 nsTableCellFrame*
 nsCellMapColumnIterator::GetNextFrame(int32_t* aRow, int32_t* aColSpan)
 {
   // Fast-path for the case when we don't have anything left in the column and
   // we know it.
   if (mFoundCells == mOrigCells) {
     *aRow = 0;
     *aColSpan = 1;
     return nullptr;
   }
   while (1) {
     NS_ASSERTION(mCurMapRow < mCurMapRelevantRowCount, "Bogus mOrigCells?");
     // Safe to just get the row (which is faster than calling GetDataAt(), but
     // there may not be that many cells in it, so have to use SafeElementAt for
     // the mCol.
     const nsCellMap::CellDataArray& row = mCurMap->mRows[mCurMapRow];
     CellData* cellData = row.SafeElementAt(mCol);
     if (!cellData || cellData->IsDead()) {
       // Could hit this if there are fewer cells in this row than others, for
       // example.
       IncrementRow(1);
       continue;
     }
     if (cellData->IsColSpan()) {
       // Look up the originating data for this cell, advance by its relative rowspan.
       int32_t rowspanOffset = cellData->GetRowSpanOffset();
       nsTableCellFrame* cellFrame = mCurMap->GetCellFrame(mCurMapRow, mCol, *cellData, false);
       NS_ASSERTION(cellFrame,"Must have usable originating data here");
       int32_t rowSpan = cellFrame->GetRowSpan();
       if (rowSpan == 0) {
         AdvanceRowGroup();
       }
       else {
         IncrementRow(rowSpan - rowspanOffset);
       }
       continue;
     }
     NS_ASSERTION(cellData->IsOrig(),
                  "Must have originating cellData by this point.  "
                  "See comment on mCurMapRow in header.");
     nsTableCellFrame* cellFrame = cellData->GetCellFrame();
     NS_ASSERTION(cellFrame, "Orig data without cellframe?");
     *aRow = mCurMapStart + mCurMapRow;
     bool ignoredZeroSpan;
     *aColSpan = mCurMap->GetEffectiveColSpan(*mMap, mCurMapRow, mCol,
                                              ignoredZeroSpan);
     IncrementRow(cellFrame->GetRowSpan());
     ++mFoundCells;
     NS_ABORT_IF_FALSE(cellData == mMap->GetDataAt(*aRow, mCol),
                       "Giving caller bogus row?");
     return cellFrame;
   }
   NS_NOTREACHED("Can't get here");
   return nullptr;
 }

The Tor Browser / annotate

layout/tables/nsCellMap.cpp@97036ab72558 (annotated)

layout/tables/nsCellMap.cpp