wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-10-08 16:27:31 +09:00
Code Issues Projects Releases Packages Wiki Activity

Issue #1355 - Make nsTableCellFrame::GetColIndex/GetRowIndex faster

Browse source 
We can devirtualize it, remove some branches.
This commit is contained in:
win7-7 2020-02-16 16:06:53 +02:00 • committed by Roy Tam
commit e8bb5560f7
12 changed files with 106 additions and 152 deletions
Download patch file Download diff file Expand all files Collapse all files

48
accessible/html/HTMLTableAccessible.cpp
View file

@ -175,23 +175,17 @@ HTMLTableCellAccessible::Table() const
uint32_t uint32_t
HTMLTableCellAccessible::ColIdx() const HTMLTableCellAccessible::ColIdx() const
{ {
nsITableCellLayout* cellLayout = GetCellLayout(); nsTableCellFrame* cellFrame = GetCellFrame();
NS_ENSURE_TRUE(cellLayout, 0); NS_ENSURE_TRUE(cellFrame, 0);
return cellFrame->ColIndex();
int32_t colIdx = 0;
cellLayout->GetColIndex(colIdx);
return colIdx > 0 ? static_cast<uint32_t>(colIdx) : 0;
} }
uint32_t uint32_t
HTMLTableCellAccessible::RowIdx() const HTMLTableCellAccessible::RowIdx() const
{ {
nsITableCellLayout* cellLayout = GetCellLayout(); nsTableCellFrame* cellFrame = GetCellFrame();
NS_ENSURE_TRUE(cellLayout, 0); NS_ENSURE_TRUE(cellFrame, 0);
return cellFrame->RowIndex();
int32_t rowIdx = 0;
cellLayout->GetRowIndex(rowIdx);
return rowIdx > 0 ? static_cast<uint32_t>(rowIdx) : 0;
} }
uint32_t uint32_t
@ -285,6 +279,12 @@ HTMLTableCellAccessible::GetCellLayout() const
return do_QueryFrame(mContent->GetPrimaryFrame()); return do_QueryFrame(mContent->GetPrimaryFrame());
} }
nsTableCellFrame*
HTMLTableCellAccessible::GetCellFrame() const
{
return do_QueryFrame(mContent->GetPrimaryFrame());
}
nsresult nsresult
HTMLTableCellAccessible::GetCellIndexes(int32_t& aRowIdx, int32_t& aColIdx) const HTMLTableCellAccessible::GetCellIndexes(int32_t& aRowIdx, int32_t& aColIdx) const
{ {
@ -520,11 +520,9 @@ HTMLTableAccessible::SelectedCellCount()
if (!cellFrame || !cellFrame->IsSelected()) if (!cellFrame || !cellFrame->IsSelected())
continue; continue;
int32_t startRow = -1, startCol = -1; uint32_t startRow = cellFrame->RowIndex();
cellFrame->GetRowIndex(startRow); uint32_t startCol = cellFrame->ColIndex();
cellFrame->GetColIndex(startCol); if (startRow == rowIdx && startCol == colIdx)
if (startRow >= 0 && (uint32_t)startRow == rowIdx &&
startCol >= 0 && (uint32_t)startCol == colIdx)
count++; count++;
} }
} }
@ -570,11 +568,9 @@ HTMLTableAccessible::SelectedCells(nsTArray<Accessible*>* aCells)
if (!cellFrame || !cellFrame->IsSelected()) if (!cellFrame || !cellFrame->IsSelected())
continue; continue;
int32_t startCol = -1, startRow = -1; uint32_t startRow = cellFrame->RowIndex();
cellFrame->GetRowIndex(startRow); uint32_t startCol = cellFrame->ColIndex();
cellFrame->GetColIndex(startCol); if (startRow != rowIdx || startCol != colIdx)
if ((startRow >= 0 && (uint32_t)startRow != rowIdx) ||
(startCol >= 0 && (uint32_t)startCol != colIdx))
continue; continue;
Accessible* cell = mDoc->GetAccessible(cellFrame->GetContent()); Accessible* cell = mDoc->GetAccessible(cellFrame->GetContent());
@ -597,11 +593,9 @@ HTMLTableAccessible::SelectedCellIndices(nsTArray<uint32_t>* aCells)
if (!cellFrame || !cellFrame->IsSelected()) if (!cellFrame || !cellFrame->IsSelected())
continue; continue;
int32_t startRow = -1, startCol = -1; uint32_t startCol = cellFrame->ColIndex();
cellFrame->GetColIndex(startCol); uint32_t startRow = cellFrame->RowIndex();
cellFrame->GetRowIndex(startRow); if (startRow == rowIdx && startCol == colIdx)
if (startRow >= 0 && (uint32_t)startRow == rowIdx &&
startCol >= 0 && (uint32_t)startCol == colIdx)
aCells->AppendElement(CellIndexAt(rowIdx, colIdx)); aCells->AppendElement(CellIndexAt(rowIdx, colIdx));
} }
} }

6
accessible/html/HTMLTableAccessible.h
View file

@ -11,6 +11,7 @@
#include "TableCellAccessible.h" #include "TableCellAccessible.h"
class nsITableCellLayout; class nsITableCellLayout;
class nsTableCellFrame;
namespace mozilla { namespace mozilla {
namespace a11y { namespace a11y {
@ -53,6 +54,11 @@ protected:
*/ */
nsITableCellLayout* GetCellLayout() const; nsITableCellLayout* GetCellLayout() const;
/**
* Return the table cell frame.
*/
nsTableCellFrame* GetCellFrame() const;
/** /**
* Return row and column indices of the cell. * Return row and column indices of the cell.
*/ */

4
editor/libeditor/HTMLTableEditor.cpp
View file

@ -2730,8 +2730,8 @@ HTMLEditor::GetCellDataAt(nsIDOMElement* aTable,
} }
*aIsSelected = cellFrame->IsSelected(); *aIsSelected = cellFrame->IsSelected();
cellFrame->GetRowIndex(*aStartRowIndex); *aStartRowIndex = cellFrame->RowIndex();
cellFrame->GetColIndex(*aStartColIndex); *aStartColIndex = cellFrame->ColIndex();
*aRowSpan = cellFrame->GetRowSpan(); *aRowSpan = cellFrame->GetRowSpan();
*aColSpan = cellFrame->GetColSpan(); *aColSpan = cellFrame->GetColSpan();
*aActualRowSpan = tableFrame->GetEffectiveRowSpanAt(aRowIndex, aColIndex); *aActualRowSpan = tableFrame->GetEffectiveRowSpanAt(aRowIndex, aColIndex);

22
layout/generic/nsSelection.cpp
View file

@ -2882,16 +2882,15 @@ nsFrameSelection::UnselectCells(nsIContent *aTableContent,
nsTableCellFrame* cellFrame = nsTableCellFrame* cellFrame =
tableFrame->GetCellFrameAt(curRowIndex, curColIndex); tableFrame->GetCellFrameAt(curRowIndex, curColIndex);
int32_t origRowIndex, origColIndex; uint32_t origRowIndex = cellFrame->RowIndex();
cellFrame->GetRowIndex(origRowIndex); uint32_t origColIndex = cellFrame->ColIndex();
cellFrame->GetColIndex(origColIndex);
uint32_t actualRowSpan = uint32_t actualRowSpan =
tableFrame->GetEffectiveRowSpanAt(origRowIndex, origColIndex); tableFrame->GetEffectiveRowSpanAt(origRowIndex, origColIndex);
uint32_t actualColSpan = uint32_t actualColSpan =
tableFrame->GetEffectiveColSpanAt(curRowIndex, curColIndex); tableFrame->GetEffectiveColSpanAt(curRowIndex, curColIndex);
if (origRowIndex <= maxRowIndex && maxRowIndex >= 0 && if (origRowIndex <= static_cast<uint32_t>(maxRowIndex) && maxRowIndex >= 0 &&
origRowIndex + actualRowSpan - 1 >= static_cast<uint32_t>(minRowIndex) && origRowIndex + actualRowSpan - 1 >= static_cast<uint32_t>(minRowIndex) &&
origColIndex <= maxColIndex && maxColIndex >= 0 && origColIndex <= static_cast<uint32_t>(maxColIndex) && maxColIndex >= 0 &&
origColIndex + actualColSpan - 1 >= static_cast<uint32_t>(minColIndex)) { origColIndex + actualColSpan - 1 >= static_cast<uint32_t>(minColIndex)) {
mDomSelections[index]->RemoveRange(range); mDomSelections[index]->RemoveRange(range);
@ -2925,33 +2924,32 @@ nsFrameSelection::AddCellsToSelection(nsIContent *aTableContent,
return NS_ERROR_FAILURE; return NS_ERROR_FAILURE;
nsresult result = NS_OK; nsresult result = NS_OK;
int32_t row = aStartRowIndex; uint32_t row = aStartRowIndex;
while(true) while(true)
{ {
int32_t col = aStartColumnIndex; uint32_t col = aStartColumnIndex;
while(true) while(true)
{ {
nsTableCellFrame* cellFrame = tableFrame->GetCellFrameAt(row, col); nsTableCellFrame* cellFrame = tableFrame->GetCellFrameAt(row, col);
// Skip cells that are spanned from previous locations or are already selected // Skip cells that are spanned from previous locations or are already selected
if (cellFrame) { if (cellFrame) {
int32_t origRow, origCol; uint32_t origRow = cellFrame->RowIndex();
cellFrame->GetRowIndex(origRow); uint32_t origCol = cellFrame->ColIndex();
cellFrame->GetColIndex(origCol);
if (origRow == row && origCol == col && !cellFrame->IsSelected()) { if (origRow == row && origCol == col && !cellFrame->IsSelected()) {
result = SelectCellElement(cellFrame->GetContent()); result = SelectCellElement(cellFrame->GetContent());
if (NS_FAILED(result)) return result; if (NS_FAILED(result)) return result;
} }
} }
// Done when we reach end column // Done when we reach end column
if (col == aEndColumnIndex) break; if (col == static_cast<uint32_t>(aEndColumnIndex)) break;
if (aStartColumnIndex < aEndColumnIndex) if (aStartColumnIndex < aEndColumnIndex)
col ++; col ++;
else else
col--; col--;
} }
if (row == aEndRowIndex) break; if (row == static_cast<uint32_t>(aEndRowIndex)) break;
if (aStartRowIndex < aEndRowIndex) if (aStartRowIndex < aEndRowIndex)
row++; row++;

20
layout/mathml/nsMathMLmtableFrame.cpp
View file

@ -183,10 +183,8 @@ static void
ApplyBorderToStyle(const nsMathMLmtdFrame* aFrame, ApplyBorderToStyle(const nsMathMLmtdFrame* aFrame,
nsStyleBorder& aStyleBorder) nsStyleBorder& aStyleBorder)
{ {
int32_t rowIndex; uint32_t rowIndex = aFrame->RowIndex();
int32_t columnIndex; uint32_t columnIndex = aFrame->ColIndex();
aFrame->GetRowIndex(rowIndex);
aFrame->GetColIndex(columnIndex);
nscoord borderWidth = nscoord borderWidth =
aFrame->PresContext()->GetBorderWidthTable()[NS_STYLE_BORDER_WIDTH_THIN]; aFrame->PresContext()->GetBorderWidthTable()[NS_STYLE_BORDER_WIDTH_THIN];
@ -201,7 +199,7 @@ ApplyBorderToStyle(const nsMathMLmtdFrame* aFrame,
if (rowIndex > 0 && rowLinesList) { if (rowIndex > 0 && rowLinesList) {
// If the row number is greater than the number of provided rowline // If the row number is greater than the number of provided rowline
// values, we simply repeat the last value. // values, we simply repeat the last value.
int32_t listLength = rowLinesList->Length(); uint32_t listLength = rowLinesList->Length();
if (rowIndex < listLength) { if (rowIndex < listLength) {
aStyleBorder.SetBorderStyle(NS_SIDE_TOP, aStyleBorder.SetBorderStyle(NS_SIDE_TOP,
rowLinesList->ElementAt(rowIndex - 1)); rowLinesList->ElementAt(rowIndex - 1));
@ -216,7 +214,7 @@ ApplyBorderToStyle(const nsMathMLmtdFrame* aFrame,
if (columnIndex > 0 && columnLinesList) { if (columnIndex > 0 && columnLinesList) {
// If the column number is greater than the number of provided columline // If the column number is greater than the number of provided columline
// values, we simply repeat the last value. // values, we simply repeat the last value.
int32_t listLength = columnLinesList->Length(); uint32_t listLength = columnLinesList->Length();
if (columnIndex < listLength) { if (columnIndex < listLength) {
aStyleBorder.SetBorderStyle(NS_SIDE_LEFT, aStyleBorder.SetBorderStyle(NS_SIDE_LEFT,
columnLinesList->ElementAt(columnIndex - 1)); columnLinesList->ElementAt(columnIndex - 1));
@ -1202,12 +1200,11 @@ nsMathMLmtdFrame::GetVerticalAlign() const
nsTArray<int8_t>* alignmentList = FindCellProperty(this, RowAlignProperty()); nsTArray<int8_t>* alignmentList = FindCellProperty(this, RowAlignProperty());
if (alignmentList) { if (alignmentList) {
int32_t rowIndex; uint32_t rowIndex = RowIndex();
GetRowIndex(rowIndex);
// If the row number is greater than the number of provided rowalign values, // If the row number is greater than the number of provided rowalign values,
// we simply repeat the last value. // we simply repeat the last value.
if (rowIndex < (int32_t)alignmentList->Length()) if (rowIndex < alignmentList->Length())
alignment = alignmentList->ElementAt(rowIndex); alignment = alignmentList->ElementAt(rowIndex);
else else
alignment = alignmentList->ElementAt(alignmentList->Length() - 1); alignment = alignmentList->ElementAt(alignmentList->Length() - 1);
@ -1294,12 +1291,11 @@ nsStyleText* nsMathMLmtdInnerFrame::StyleTextForLineLayout()
if (alignmentList) { if (alignmentList) {
nsMathMLmtdFrame* cellFrame = (nsMathMLmtdFrame*)GetParent(); nsMathMLmtdFrame* cellFrame = (nsMathMLmtdFrame*)GetParent();
int32_t columnIndex; uint32_t columnIndex = cellFrame->ColIndex();
cellFrame->GetColIndex(columnIndex);
// If the column number is greater than the number of provided columalign // If the column number is greater than the number of provided columalign
// values, we simply repeat the last value. // values, we simply repeat the last value.
if (columnIndex < (int32_t)alignmentList->Length()) if (columnIndex < alignmentList->Length())
alignment = alignmentList->ElementAt(columnIndex); alignment = alignmentList->ElementAt(columnIndex);
else else
alignment = alignmentList->ElementAt(alignmentList->Length() - 1); alignment = alignmentList->ElementAt(alignmentList->Length() - 1);

8
layout/tables/nsCellMap.cpp
View file

@ -2431,9 +2431,8 @@ void nsCellMap::Dump(bool aIsBorderCollapse) const
if (cd) { if (cd) {
if (cd->IsOrig()) { if (cd->IsOrig()) {
nsTableCellFrame* cellFrame = cd->GetCellFrame(); nsTableCellFrame* cellFrame = cd->GetCellFrame();
int32_t cellFrameColIndex; uint32_t cellFrameColIndex = cellFrame->ColIndex();
cellFrame->GetColIndex(cellFrameColIndex); printf("C%d,%d=%p(%u) ", rIndex, colIndex, (void*)cellFrame,
printf("C%d,%d=%p(%d) ", rIndex, colIndex, (void*)cellFrame,
cellFrameColIndex); cellFrameColIndex);
cellCount++; cellCount++;
} }
@ -2520,8 +2519,7 @@ nsCellMap::GetCellInfoAt(const nsTableCellMap& aMap,
cellFrame = GetCellFrame(aRowX, aColX, *data, true); cellFrame = GetCellFrame(aRowX, aColX, *data, true);
} }
if (cellFrame && aColSpan) { if (cellFrame && aColSpan) {
int32_t initialColIndex; uint32_t initialColIndex = cellFrame->ColIndex();
cellFrame->GetColIndex(initialColIndex);
*aColSpan = GetEffectiveColSpan(aMap, aRowX, initialColIndex); *aColSpan = GetEffectiveColSpan(aMap, aRowX, initialColIndex);
} }
} }

6
layout/tables/nsITableCellLayout.h
View file

@ -14,6 +14,7 @@
/** /**
* nsITableCellLayout * nsITableCellLayout
* interface for layout objects that act like table cells. * interface for layout objects that act like table cells.
* XXX: This interface should really go away...
* *
* @author sclark * @author sclark
*/ */
@ -26,11 +27,6 @@ public:
/** return the mapped cell's row and column indexes (starting at 0 for each) */ /** return the mapped cell's row and column indexes (starting at 0 for each) */
NS_IMETHOD GetCellIndexes(int32_t &aRowIndex, int32_t &aColIndex)=0; NS_IMETHOD GetCellIndexes(int32_t &aRowIndex, int32_t &aColIndex)=0;
/** return the mapped cell's row index (starting at 0 for the first row) */
virtual nsresult GetRowIndex(int32_t &aRowIndex) const = 0;
/** return the mapped cell's column index (starting at 0 for the first column) */
virtual nsresult GetColIndex(int32_t &aColIndex) const = 0;
}; };
#endif #endif

51
layout/tables/nsTableCellFrame.cpp
View file

@ -74,8 +74,7 @@ nsTableCellFrame::Init(nsIContent* aContent,
if (aPrevInFlow) { if (aPrevInFlow) {
// Set the column index // Set the column index
nsTableCellFrame* cellFrame = (nsTableCellFrame*)aPrevInFlow; nsTableCellFrame* cellFrame = (nsTableCellFrame*)aPrevInFlow;
int32_t colIndex; uint32_t colIndex = cellFrame->ColIndex();
cellFrame->GetColIndex(colIndex);
SetColIndex(colIndex); SetColIndex(colIndex);
} }
} }
@ -168,34 +167,6 @@ nsTableCellFrame::NeedsToObserve(const ReflowInput& aReflowInput)
fType == nsGkAtoms::tableWrapperFrame); fType == nsGkAtoms::tableWrapperFrame);
} }
nsresult
nsTableCellFrame::GetRowIndex(int32_t &aRowIndex) const
{
nsresult result;
nsTableRowFrame* row = static_cast<nsTableRowFrame*>(GetParent());
if (row) {
aRowIndex = row->GetRowIndex();
result = NS_OK;
}
else {
aRowIndex = 0;
result = NS_ERROR_NOT_INITIALIZED;
}
return result;
}
nsresult
nsTableCellFrame::GetColIndex(int32_t &aColIndex) const
{
if (GetPrevInFlow()) {
return static_cast<nsTableCellFrame*>(FirstInFlow())->GetColIndex(aColIndex);
}
else {
aColIndex = mColIndex;
return NS_OK;
}
}
nsresult nsresult
nsTableCellFrame::AttributeChanged(int32_t aNameSpaceID, nsTableCellFrame::AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute, nsIAtom* aAttribute,
@ -224,13 +195,13 @@ nsTableCellFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)
nsTableFrame* tableFrame = GetTableFrame(); nsTableFrame* tableFrame = GetTableFrame();
if (tableFrame->IsBorderCollapse() && if (tableFrame->IsBorderCollapse() &&
tableFrame->BCRecalcNeeded(aOldStyleContext, StyleContext())) { tableFrame->BCRecalcNeeded(aOldStyleContext, StyleContext())) {
int32_t colIndex, rowIndex; uint32_t colIndex = ColIndex();
GetColIndex(colIndex); uint32_t rowIndex = RowIndex();
GetRowIndex(rowIndex);
// row span needs to be clamped as we do not create rows in the cellmap // row span needs to be clamped as we do not create rows in the cellmap
// which do not have cells originating in them // which do not have cells originating in them
TableArea damageArea(colIndex, rowIndex, GetColSpan(), TableArea damageArea(colIndex, rowIndex, GetColSpan(),
std::min(GetRowSpan(), tableFrame->GetRowCount() - rowIndex)); std::min(static_cast<uint32_t>(GetRowSpan()),
tableFrame->GetRowCount() - rowIndex));
tableFrame->AddBCDamageArea(damageArea); tableFrame->AddBCDamageArea(damageArea);
} }
} }
@ -820,14 +791,13 @@ CalcUnpaginatedBSize(nsTableCellFrame& aCellFrame,
nsTableRowGroupFrame* firstRGInFlow = nsTableRowGroupFrame* firstRGInFlow =
static_cast<nsTableRowGroupFrame*>(row->GetParent()); static_cast<nsTableRowGroupFrame*>(row->GetParent());
int32_t rowIndex; uint32_t rowIndex = firstCellInFlow->RowIndex();
firstCellInFlow->GetRowIndex(rowIndex);
int32_t rowSpan = aTableFrame.GetEffectiveRowSpan(*firstCellInFlow); int32_t rowSpan = aTableFrame.GetEffectiveRowSpan(*firstCellInFlow);
nscoord computedBSize = firstTableInFlow->GetRowSpacing(rowIndex, nscoord computedBSize = firstTableInFlow->GetRowSpacing(rowIndex,
rowIndex + rowSpan - 1); rowIndex + rowSpan - 1);
computedBSize -= aBlockDirBorderPadding; computedBSize -= aBlockDirBorderPadding;
int32_t rowX; uint32_t rowX;
for (row = firstRGInFlow->GetFirstRow(), rowX = 0; row; row = row->GetNextRow(), rowX++) { for (row = firstRGInFlow->GetFirstRow(), rowX = 0; row; row = row->GetNextRow(), rowX++) {
if (rowX > rowIndex + rowSpan - 1) { if (rowX > rowIndex + rowSpan - 1) {
break; break;
@ -1042,12 +1012,7 @@ nsTableCellFrame::AccessibleType()
NS_IMETHODIMP NS_IMETHODIMP
nsTableCellFrame::GetCellIndexes(int32_t &aRowIndex, int32_t &aColIndex) nsTableCellFrame::GetCellIndexes(int32_t &aRowIndex, int32_t &aColIndex)
{ {
nsresult res = GetRowIndex(aRowIndex); aRowIndex = RowIndex();
if (NS_FAILED(res))
{
aColIndex = 0;
return res;
}
aColIndex = mColIndex; aColIndex = mColIndex;
return NS_OK; return NS_OK;
} }

20
layout/tables/nsTableCellFrame.h
View file

@ -183,7 +183,10 @@ public:
NS_IMETHOD GetCellIndexes(int32_t &aRowIndex, int32_t &aColIndex) override; NS_IMETHOD GetCellIndexes(int32_t &aRowIndex, int32_t &aColIndex) override;
/** return the mapped cell's row index (starting at 0 for the first row) */ /** return the mapped cell's row index (starting at 0 for the first row) */
virtual nsresult GetRowIndex(int32_t &aRowIndex) const override; uint32_t RowIndex() const
{
return static_cast<nsTableRowFrame*>(GetParent())->GetRowIndex();
}
/** /**
* return the cell's specified col span. this is what was specified in the * return the cell's specified col span. this is what was specified in the
@ -194,7 +197,16 @@ public:
int32_t GetColSpan(); int32_t GetColSpan();
/** return the cell's column index (starting at 0 for the first column) */ /** return the cell's column index (starting at 0 for the first column) */
virtual nsresult GetColIndex(int32_t &aColIndex) const override; uint32_t ColIndex() const
{
// NOTE: We copy this from previous continuations, and we don't ever have
// dynamic updates when tables split, so our mColIndex always matches our
// first continuation's.
MOZ_ASSERT(static_cast<nsTableCellFrame*>(FirstContinuation())->mColIndex ==
mColIndex,
"mColIndex out of sync with first continuation");
return mColIndex;
}
void SetColIndex(int32_t aColIndex); void SetColIndex(int32_t aColIndex);
/** return the available isize given to this frame during its last reflow */ /** return the available isize given to this frame during its last reflow */
@ -246,9 +258,9 @@ public:
virtual void InvalidateFrame(uint32_t aDisplayItemKey = 0) override; virtual void InvalidateFrame(uint32_t aDisplayItemKey = 0) override;
virtual void InvalidateFrameWithRect(const nsRect& aRect, uint32_t aDisplayItemKey = 0) override; virtual void InvalidateFrameWithRect(const nsRect& aRect, uint32_t aDisplayItemKey = 0) override;
virtual void InvalidateFrameForRemoval() override { InvalidateFrameSubtree(); } virtual void InvalidateFrameForRemoval() override { InvalidateFrameSubtree(); }
bool ShouldPaintBordersAndBackgrounds() const; bool ShouldPaintBordersAndBackgrounds() const;
bool ShouldPaintBackground(nsDisplayListBuilder* aBuilder); bool ShouldPaintBackground(nsDisplayListBuilder* aBuilder);
protected: protected:

41
layout/tables/nsTableFrame.cpp
View file

@ -368,9 +368,8 @@ nsTableFrame::AttributeChangedFor(nsIFrame* aFrame,
nsTableCellMap* cellMap = GetCellMap(); nsTableCellMap* cellMap = GetCellMap();
if (cellMap) { if (cellMap) {
// for now just remove the cell from the map and reinsert it // for now just remove the cell from the map and reinsert it
int32_t rowIndex, colIndex; uint32_t rowIndex = cellFrame->RowIndex();
cellFrame->GetRowIndex(rowIndex); uint32_t colIndex = cellFrame->ColIndex();
cellFrame->GetColIndex(colIndex);
RemoveCell(cellFrame, rowIndex); RemoveCell(cellFrame, rowIndex);
AutoTArray<nsTableCellFrame*, 1> cells; AutoTArray<nsTableCellFrame*, 1> cells;
cells.AppendElement(cellFrame); cells.AppendElement(cellFrame);
@ -447,9 +446,7 @@ nsTableFrame::GetEffectiveRowSpan(int32_t aRowIndex,
nsTableCellMap* cellMap = GetCellMap(); nsTableCellMap* cellMap = GetCellMap();
NS_PRECONDITION (nullptr != cellMap, "bad call, cellMap not yet allocated."); NS_PRECONDITION (nullptr != cellMap, "bad call, cellMap not yet allocated.");
int32_t colIndex; return cellMap->GetEffectiveRowSpan(aRowIndex, aCell.ColIndex());
aCell.GetColIndex(colIndex);
return cellMap->GetEffectiveRowSpan(aRowIndex, colIndex);
} }
int32_t int32_t
@ -458,9 +455,8 @@ nsTableFrame::GetEffectiveRowSpan(const nsTableCellFrame& aCell,
{ {
nsTableCellMap* tableCellMap = GetCellMap(); if (!tableCellMap) ABORT1(1); nsTableCellMap* tableCellMap = GetCellMap(); if (!tableCellMap) ABORT1(1);
int32_t colIndex, rowIndex; uint32_t colIndex = aCell.ColIndex();
aCell.GetColIndex(colIndex); uint32_t rowIndex = aCell.RowIndex();
aCell.GetRowIndex(rowIndex);
if (aCellMap) if (aCellMap)
return aCellMap->GetRowSpan(rowIndex, colIndex, true); return aCellMap->GetRowSpan(rowIndex, colIndex, true);
@ -474,9 +470,8 @@ nsTableFrame::GetEffectiveColSpan(const nsTableCellFrame& aCell,
{ {
nsTableCellMap* tableCellMap = GetCellMap(); if (!tableCellMap) ABORT1(1); nsTableCellMap* tableCellMap = GetCellMap(); if (!tableCellMap) ABORT1(1);
int32_t colIndex, rowIndex; uint32_t colIndex = aCell.ColIndex();
aCell.GetColIndex(colIndex); uint32_t rowIndex = aCell.RowIndex();
aCell.GetRowIndex(rowIndex);
if (aCellMap) if (aCellMap)
return aCellMap->GetEffectiveColSpan(*tableCellMap, rowIndex, colIndex); return aCellMap->GetEffectiveColSpan(*tableCellMap, rowIndex, colIndex);
@ -1221,9 +1216,9 @@ PaintRowGroupBackground(nsTableRowGroupFrame* aRowGroup,
const nsRect& aDirtyRect) const nsRect& aDirtyRect)
{ {
for (nsTableRowFrame* row = aRowGroup->GetFirstRow(); row; row = row->GetNextRow()) { for (nsTableRowFrame* row = aRowGroup->GetFirstRow(); row; row = row->GetNextRow()) {
if (!aDirtyRect.Intersects(nsRect(row->GetNormalPosition(), row->GetSize()))) { if (!aDirtyRect.Intersects(nsRect(row->GetNormalPosition(), row->GetSize()))) {
continue; continue;
} }
PaintRowBackground(row, aFrame, aBuilder, aLists, aDirtyRect, row->GetNormalPosition()); PaintRowBackground(row, aFrame, aBuilder, aLists, aDirtyRect, row->GetNormalPosition());
} }
} }
@ -1234,7 +1229,7 @@ PaintRowGroupBackgroundByColIdx(nsTableRowGroupFrame* aRowGroup,
nsDisplayListBuilder* aBuilder, nsDisplayListBuilder* aBuilder,
const nsDisplayListSet& aLists, const nsDisplayListSet& aLists,
const nsRect& aDirtyRect, const nsRect& aDirtyRect,
const nsTArray<int32_t>& aColIdx, const nsTArray<uint32_t>& aColIdx,
const nsPoint& aOffset) const nsPoint& aOffset)
{ {
MOZ_DIAGNOSTIC_ASSERT(!aColIdx.IsEmpty(), MOZ_DIAGNOSTIC_ASSERT(!aColIdx.IsEmpty(),
@ -1246,8 +1241,7 @@ PaintRowGroupBackgroundByColIdx(nsTableRowGroupFrame* aRowGroup,
} }
for (nsTableCellFrame* cell = row->GetFirstCell(); cell; cell = cell->GetNextCell()) { for (nsTableCellFrame* cell = row->GetFirstCell(); cell; cell = cell->GetNextCell()) {
int32_t curColIdx; uint32_t curColIdx = cell->ColIndex();
cell->GetColIndex(curColIdx);
if (!aColIdx.Contains(curColIdx)) { if (!aColIdx.Contains(curColIdx)) {
if (curColIdx > aColIdx.LastElement()) { if (curColIdx > aColIdx.LastElement()) {
// We can just stop looking at this row. // We can just stop looking at this row.
@ -1318,10 +1312,10 @@ nsTableFrame::DisplayGenericTablePart(nsDisplayListBuilder* aBuilder,
// Compute background rect by iterating all cell frame. // Compute background rect by iterating all cell frame.
nsTableColGroupFrame* colGroup = static_cast<nsTableColGroupFrame*>(aFrame); nsTableColGroupFrame* colGroup = static_cast<nsTableColGroupFrame*>(aFrame);
// Collecting column index. // Collecting column index.
AutoTArray<int32_t, 1> colIdx; AutoTArray<uint32_t, 1> colIdx;
for (nsTableColFrame* col = colGroup->GetFirstColumn(); col; col = col->GetNextCol()) { for (nsTableColFrame* col = colGroup->GetFirstColumn(); col; col = col->GetNextCol()) {
MOZ_ASSERT(colIdx.IsEmpty() || MOZ_ASSERT(colIdx.IsEmpty() ||
col->GetColIndex() > colIdx.LastElement()); static_cast<uint32_t>(col->GetColIndex()) > colIdx.LastElement());
colIdx.AppendElement(col->GetColIndex()); colIdx.AppendElement(col->GetColIndex());
} }
@ -1341,7 +1335,7 @@ nsTableFrame::DisplayGenericTablePart(nsDisplayListBuilder* aBuilder,
} else if (aFrame->GetType() == nsGkAtoms::tableColFrame) { } else if (aFrame->GetType() == nsGkAtoms::tableColFrame) {
// Compute background rect by iterating all cell frame. // Compute background rect by iterating all cell frame.
nsTableColFrame* col = static_cast<nsTableColFrame*>(aFrame); nsTableColFrame* col = static_cast<nsTableColFrame*>(aFrame);
AutoTArray<int32_t, 1> colIdx; AutoTArray<uint32_t, 1> colIdx;
colIdx.AppendElement(col->GetColIndex()); colIdx.AppendElement(col->GetColIndex());
nsTableFrame* table = col->GetTableFrame(); nsTableFrame* table = col->GetTableFrame();
@ -3973,9 +3967,8 @@ nsTableFrame::DumpRowGroup(nsIFrame* aKidFrame)
for (nsIFrame* childFrame : cFrame->PrincipalChildList()) { for (nsIFrame* childFrame : cFrame->PrincipalChildList()) {
nsTableCellFrame *cellFrame = do_QueryFrame(childFrame); nsTableCellFrame *cellFrame = do_QueryFrame(childFrame);
if (cellFrame) { if (cellFrame) {
int32_t colIndex; uint32_t colIndex = cellFrame->ColIndex();
cellFrame->GetColIndex(colIndex); printf("cell(%u)=%p ", colIndex, static_cast<void*>(childFrame));
printf("cell(%d)=%p ", colIndex, static_cast<void*>(childFrame));
} }
} }
printf("\n"); printf("\n");

26
layout/tables/nsTableRowFrame.cpp
View file

@ -235,7 +235,7 @@ nsTableRowFrame::InsertFrames(ChildListID aListID,
// insert the cells into the cell map // insert the cells into the cell map
int32_t colIndex = -1; int32_t colIndex = -1;
if (prevCellFrame) { if (prevCellFrame) {
prevCellFrame->GetColIndex(colIndex); colIndex = prevCellFrame->ColIndex();
} }
tableFrame->InsertCells(cellChildren, GetRowIndex(), colIndex); tableFrame->InsertCells(cellChildren, GetRowIndex(), colIndex);
@ -647,8 +647,7 @@ CalcAvailISize(nsTableFrame& aTableFrame,
nsTableCellFrame& aCellFrame) nsTableCellFrame& aCellFrame)
{ {
nscoord cellAvailISize = 0; nscoord cellAvailISize = 0;
int32_t colIndex; uint32_t colIndex = aCellFrame.ColIndex();
aCellFrame.GetColIndex(colIndex);
int32_t colspan = aTableFrame.GetEffectiveColSpan(aCellFrame); int32_t colspan = aTableFrame.GetEffectiveColSpan(aCellFrame);
NS_ASSERTION(colspan > 0, "effective colspan should be positive"); NS_ASSERTION(colspan > 0, "effective colspan should be positive");
nsTableFrame* fifTable = nsTableFrame* fifTable =
@ -787,12 +786,12 @@ nsTableRowFrame::ReflowChildren(nsPresContext* aPresContext,
} }
} }
int32_t cellColIndex; uint32_t cellColIndex = cellFrame->ColIndex();
cellFrame->GetColIndex(cellColIndex);
cellColSpan = aTableFrame.GetEffectiveColSpan(*cellFrame); cellColSpan = aTableFrame.GetEffectiveColSpan(*cellFrame);
// If the adjacent cell is in a prior row (because of a rowspan) add in the space // If the adjacent cell is in a prior row (because of a rowspan) add in the space
if (prevColIndex != (cellColIndex - 1)) { // NOTE: prevColIndex can be -1 here.
if (prevColIndex != (static_cast<int32_t>(cellColIndex) - 1)) {
iCoord += GetSpaceBetween(prevColIndex, cellColIndex, cellColSpan, aTableFrame, iCoord += GetSpaceBetween(prevColIndex, cellColIndex, cellColSpan, aTableFrame,
false); false);
} }
@ -1160,8 +1159,7 @@ nsTableRowFrame::CollapseRowIfNecessary(nscoord aRowOffset,
shift = rowRect.BSize(wm); shift = rowRect.BSize(wm);
nsTableCellFrame* cellFrame = GetFirstCell(); nsTableCellFrame* cellFrame = GetFirstCell();
if (cellFrame) { if (cellFrame) {
int32_t rowIndex; uint32_t rowIndex = cellFrame->RowIndex();
cellFrame->GetRowIndex(rowIndex);
shift += tableFrame->GetRowSpacing(rowIndex); shift += tableFrame->GetRowSpacing(rowIndex);
while (cellFrame) { while (cellFrame) {
LogicalRect cRect = cellFrame->GetLogicalRect(wm, containerSize); LogicalRect cRect = cellFrame->GetLogicalRect(wm, containerSize);
@ -1192,13 +1190,13 @@ nsTableRowFrame::CollapseRowIfNecessary(nscoord aRowOffset,
for (nsIFrame* kidFrame : mFrames) { for (nsIFrame* kidFrame : mFrames) {
nsTableCellFrame *cellFrame = do_QueryFrame(kidFrame); nsTableCellFrame *cellFrame = do_QueryFrame(kidFrame);
if (cellFrame) { if (cellFrame) {
int32_t cellColIndex; uint32_t cellColIndex = cellFrame->ColIndex();
cellFrame->GetColIndex(cellColIndex);
int32_t cellColSpan = tableFrame->GetEffectiveColSpan(*cellFrame); int32_t cellColSpan = tableFrame->GetEffectiveColSpan(*cellFrame);
// If the adjacent cell is in a prior row (because of a rowspan) add in // If the adjacent cell is in a prior row (because of a rowspan) add in
// the space // the space
if (prevColIndex != (cellColIndex - 1)) { // NOTE: prevColIndex can be -1 here.
if (prevColIndex != (static_cast<int32_t>(cellColIndex) - 1)) {
iPos += GetSpaceBetween(prevColIndex, cellColIndex, cellColSpan, iPos += GetSpaceBetween(prevColIndex, cellColIndex, cellColSpan,
*tableFrame, true); *tableFrame, true);
} }
@ -1311,9 +1309,9 @@ nsTableRowFrame::InsertCellFrame(nsTableCellFrame* aFrame,
for (nsIFrame* child : mFrames) { for (nsIFrame* child : mFrames) {
nsTableCellFrame *cellFrame = do_QueryFrame(child); nsTableCellFrame *cellFrame = do_QueryFrame(child);
if (cellFrame) { if (cellFrame) {
int32_t colIndex; uint32_t colIndex = cellFrame->ColIndex();
cellFrame->GetColIndex(colIndex); // Can aColIndex be -1 here? Let's assume it can for now.
if (colIndex < aColIndex) { if (static_cast<int32_t>(colIndex) < aColIndex) {
priorCell = cellFrame; priorCell = cellFrame;
} }
else break; else break;

6
layout/tables/nsTableRowGroupFrame.cpp
View file

@ -137,8 +137,7 @@ nsTableRowGroupFrame::InitRepeatedFrame(nsTableRowGroupFrame* aHeaderFooterFrame
while (copyCellFrame && originalCellFrame) { while (copyCellFrame && originalCellFrame) {
NS_ASSERTION(originalCellFrame->GetContent() == copyCellFrame->GetContent(), NS_ASSERTION(originalCellFrame->GetContent() == copyCellFrame->GetContent(),
"cell frames have different content"); "cell frames have different content");
int32_t colIndex; uint32_t colIndex = originalCellFrame->ColIndex();
originalCellFrame->GetColIndex(colIndex);
copyCellFrame->SetColIndex(colIndex); copyCellFrame->SetColIndex(colIndex);
// Move to the next cell frame // Move to the next cell frame
@ -998,8 +997,7 @@ nsTableRowGroupFrame::SplitSpanningCells(nsPresContext& aPresContext,
nsTableCellFrame* contCell = static_cast<nsTableCellFrame*>( nsTableCellFrame* contCell = static_cast<nsTableCellFrame*>(
aPresContext.PresShell()->FrameConstructor()-> aPresContext.PresShell()->FrameConstructor()->
CreateContinuingFrame(&aPresContext, cell, &aLastRow)); CreateContinuingFrame(&aPresContext, cell, &aLastRow));
int32_t colIndex; uint32_t colIndex = cell->ColIndex();
cell->GetColIndex(colIndex);
aContRow->InsertCellFrame(contCell, colIndex); aContRow->InsertCellFrame(contCell, colIndex);
} }
} }