Add m-esr52 at 52.6.0

1 files changed, 3458 insertions, 0 deletions

diff --git a/editor/libeditor/HTMLTableEditor.cpp b/editor/libeditor/HTMLTableEditor.cpp
new file mode 100644
index 000000000..3da0cfe0c
--- /dev/null
+++ b/editor/libeditor/HTMLTableEditor.cpp
@@ -0,0 +1,3458 @@
+/* -*- 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 <stdio.h>
+
+#include "mozilla/HTMLEditor.h"
+
+#include "HTMLEditUtils.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/EditorUtils.h"
+#include "mozilla/dom/Selection.h"
+#include "mozilla/dom/Element.h"
+#include "nsAString.h"
+#include "nsAlgorithm.h"
+#include "nsCOMPtr.h"
+#include "nsDebug.h"
+#include "nsError.h"
+#include "nsGkAtoms.h"
+#include "nsIAtom.h"
+#include "nsIContent.h"
+#include "nsIDOMElement.h"
+#include "nsIDOMNode.h"
+#include "nsIEditor.h"
+#include "nsIFrame.h"
+#include "nsINode.h"
+#include "nsIPresShell.h"
+#include "nsISupportsUtils.h"
+#include "nsITableCellLayout.h" // For efficient access to table cell
+#include "nsITableEditor.h"
+#include "nsLiteralString.h"
+#include "nsQueryFrame.h"
+#include "nsRange.h"
+#include "nsString.h"
+#include "nsTArray.h"
+#include "nsTableCellFrame.h"
+#include "nsTableWrapperFrame.h"
+#include "nscore.h"
+#include <algorithm>
+
+namespace mozilla {
+
+using namespace dom;
+
+/**
+ * Stack based helper class for restoring selection after table edit.
+ */
+class MOZ_STACK_CLASS AutoSelectionSetterAfterTableEdit final
+{
+private:
+  nsCOMPtr<nsITableEditor> mTableEditor;
+  nsCOMPtr<nsIDOMElement> mTable;
+  int32_t mCol, mRow, mDirection, mSelected;
+
+public:
+  AutoSelectionSetterAfterTableEdit(nsITableEditor* aTableEditor,
+                                    nsIDOMElement* aTable,
+                                    int32_t aRow,
+                                    int32_t aCol,
+                                    int32_t aDirection,
+                                    bool aSelected)
+    : mTableEditor(aTableEditor)
+    , mTable(aTable)
+    , mCol(aCol)
+    , mRow(aRow)
+    , mDirection(aDirection)
+    , mSelected(aSelected)
+  {
+  }
+
+  ~AutoSelectionSetterAfterTableEdit()
+  {
+    if (mTableEditor) {
+      mTableEditor->SetSelectionAfterTableEdit(mTable, mRow, mCol, mDirection,
+                                               mSelected);
+    }
+  }
+
+  // This is needed to abort the caret reset in the destructor
+  //  when one method yields control to another
+  void CancelSetCaret()
+  {
+    mTableEditor = nullptr;
+    mTable = nullptr;
+  }
+};
+
+NS_IMETHODIMP
+HTMLEditor::InsertCell(nsIDOMElement* aCell,
+                       int32_t aRowSpan,
+                       int32_t aColSpan,
+                       bool aAfter,
+                       bool aIsHeader,
+                       nsIDOMElement** aNewCell)
+{
+  NS_ENSURE_TRUE(aCell, NS_ERROR_NULL_POINTER);
+  if (aNewCell) {
+    *aNewCell = nullptr;
+  }
+
+  // And the parent and offsets needed to do an insert
+  nsCOMPtr<nsIDOMNode> cellParent;
+  nsresult rv = aCell->GetParentNode(getter_AddRefs(cellParent));
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(cellParent, NS_ERROR_NULL_POINTER);
+
+  int32_t cellOffset = GetChildOffset(aCell, cellParent);
+
+  nsCOMPtr<nsIDOMElement> newCell;
+  rv = CreateElementWithDefaults(aIsHeader ? NS_LITERAL_STRING("th") :
+                                             NS_LITERAL_STRING("tb"),
+                                 getter_AddRefs(newCell));
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+  if (!newCell) {
+    return NS_ERROR_FAILURE;
+  }
+
+  //Optional: return new cell created
+  if (aNewCell) {
+    *aNewCell = newCell.get();
+    NS_ADDREF(*aNewCell);
+  }
+
+  if (aRowSpan > 1) {
+    // Note: Do NOT use editor transaction for this
+    nsAutoString newRowSpan;
+    newRowSpan.AppendInt(aRowSpan, 10);
+    newCell->SetAttribute(NS_LITERAL_STRING("rowspan"), newRowSpan);
+  }
+  if (aColSpan > 1) {
+    // Note: Do NOT use editor transaction for this
+    nsAutoString newColSpan;
+    newColSpan.AppendInt(aColSpan, 10);
+    newCell->SetAttribute(NS_LITERAL_STRING("colspan"), newColSpan);
+  }
+  if (aAfter) {
+    cellOffset++;
+  }
+
+  //Don't let Rules System change the selection
+  AutoTransactionsConserveSelection dontChangeSelection(this);
+  return InsertNode(newCell, cellParent, cellOffset);
+}
+
+NS_IMETHODIMP
+HTMLEditor::SetColSpan(nsIDOMElement* aCell,
+                       int32_t aColSpan)
+{
+  NS_ENSURE_TRUE(aCell, NS_ERROR_NULL_POINTER);
+  nsAutoString newSpan;
+  newSpan.AppendInt(aColSpan, 10);
+  return SetAttribute(aCell, NS_LITERAL_STRING("colspan"), newSpan);
+}
+
+NS_IMETHODIMP
+HTMLEditor::SetRowSpan(nsIDOMElement* aCell,
+                       int32_t aRowSpan)
+{
+  NS_ENSURE_TRUE(aCell, NS_ERROR_NULL_POINTER);
+  nsAutoString newSpan;
+  newSpan.AppendInt(aRowSpan, 10);
+  return SetAttribute(aCell, NS_LITERAL_STRING("rowspan"), newSpan);
+}
+
+NS_IMETHODIMP
+HTMLEditor::InsertTableCell(int32_t aNumber,
+                            bool aAfter)
+{
+  nsCOMPtr<nsIDOMElement> table;
+  nsCOMPtr<nsIDOMElement> curCell;
+  nsCOMPtr<nsIDOMNode> cellParent;
+  int32_t cellOffset, startRowIndex, startColIndex;
+  nsresult rv = GetCellContext(nullptr,
+                               getter_AddRefs(table),
+                               getter_AddRefs(curCell),
+                               getter_AddRefs(cellParent), &cellOffset,
+                               &startRowIndex, &startColIndex);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Don't fail if no cell found
+  NS_ENSURE_TRUE(curCell, NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND);
+
+  // Get more data for current cell in row we are inserting at (we need COLSPAN)
+  int32_t curStartRowIndex, curStartColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
+  bool    isSelected;
+  rv = GetCellDataAt(table, startRowIndex, startColIndex,
+                     getter_AddRefs(curCell),
+                     &curStartRowIndex, &curStartColIndex, &rowSpan, &colSpan,
+                     &actualRowSpan, &actualColSpan, &isSelected);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(curCell, NS_ERROR_FAILURE);
+  int32_t newCellIndex = aAfter ? (startColIndex+colSpan) : startColIndex;
+  //We control selection resetting after the insert...
+  AutoSelectionSetterAfterTableEdit setCaret(this, table, startRowIndex,
+                                             newCellIndex, ePreviousColumn,
+                                             false);
+  //...so suppress Rules System selection munging
+  AutoTransactionsConserveSelection dontChangeSelection(this);
+
+  for (int32_t i = 0; i < aNumber; i++) {
+    nsCOMPtr<nsIDOMElement> newCell;
+    rv = CreateElementWithDefaults(NS_LITERAL_STRING("td"),
+                                   getter_AddRefs(newCell));
+    if (NS_SUCCEEDED(rv) && newCell) {
+      if (aAfter) {
+        cellOffset++;
+      }
+      rv = InsertNode(newCell, cellParent, cellOffset);
+      if (NS_FAILED(rv)) {
+        break;
+      }
+    }
+  }
+  // XXX This is perhaps the result of the last call of InsertNode() or
+  //     CreateElementWithDefaults().
+  return rv;
+}
+
+NS_IMETHODIMP
+HTMLEditor::GetFirstRow(nsIDOMElement* aTableElement,
+                        nsIDOMNode** aRowNode)
+{
+  NS_ENSURE_TRUE(aRowNode, NS_ERROR_NULL_POINTER);
+
+  *aRowNode = nullptr;
+
+  NS_ENSURE_TRUE(aTableElement, NS_ERROR_NULL_POINTER);
+
+  nsCOMPtr<nsIDOMElement> tableElement;
+  nsresult rv = GetElementOrParentByTagName(NS_LITERAL_STRING("table"),
+                                            aTableElement,
+                                            getter_AddRefs(tableElement));
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(tableElement, NS_ERROR_NULL_POINTER);
+
+  nsCOMPtr<nsIDOMNode> tableChild;
+  rv = tableElement->GetFirstChild(getter_AddRefs(tableChild));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  while (tableChild) {
+    nsCOMPtr<nsIContent> content = do_QueryInterface(tableChild);
+    if (content) {
+      if (content->IsHTMLElement(nsGkAtoms::tr)) {
+        // Found a row directly under <table>
+        *aRowNode = tableChild;
+        NS_ADDREF(*aRowNode);
+        return NS_OK;
+      }
+      // Look for row in one of the row container elements
+      if (content->IsAnyOfHTMLElements(nsGkAtoms::tbody,
+                                       nsGkAtoms::thead,
+                                       nsGkAtoms::tfoot)) {
+        nsCOMPtr<nsIDOMNode> rowNode;
+        rv = tableChild->GetFirstChild(getter_AddRefs(rowNode));
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        // We can encounter textnodes here -- must find a row
+        while (rowNode && !HTMLEditUtils::IsTableRow(rowNode)) {
+          nsCOMPtr<nsIDOMNode> nextNode;
+          rv = rowNode->GetNextSibling(getter_AddRefs(nextNode));
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          rowNode = nextNode;
+        }
+        if (rowNode) {
+          *aRowNode = rowNode.get();
+          NS_ADDREF(*aRowNode);
+          return NS_OK;
+        }
+      }
+    }
+    // Here if table child was a CAPTION or COLGROUP
+    //  or child of a row parent wasn't a row (bad HTML?),
+    //  or first child was a textnode
+    // Look in next table child
+    nsCOMPtr<nsIDOMNode> nextChild;
+    rv = tableChild->GetNextSibling(getter_AddRefs(nextChild));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    tableChild = nextChild;
+  }
+  // If here, row was not found
+  return NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND;
+}
+
+NS_IMETHODIMP
+HTMLEditor::GetNextRow(nsIDOMNode* aCurrentRowNode,
+                       nsIDOMNode** aRowNode)
+{
+  NS_ENSURE_TRUE(aRowNode, NS_ERROR_NULL_POINTER);
+
+  *aRowNode = nullptr;
+
+  NS_ENSURE_TRUE(aCurrentRowNode, NS_ERROR_NULL_POINTER);
+
+  if (!HTMLEditUtils::IsTableRow(aCurrentRowNode)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIDOMNode> nextRow;
+  nsresult rv = aCurrentRowNode->GetNextSibling(getter_AddRefs(nextRow));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDOMNode> nextNode;
+
+  // Skip over any textnodes here
+  while (nextRow && !HTMLEditUtils::IsTableRow(nextRow)) {
+    rv = nextRow->GetNextSibling(getter_AddRefs(nextNode));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nextRow = nextNode;
+  }
+  if (nextRow) {
+    *aRowNode = nextRow.get();
+    NS_ADDREF(*aRowNode);
+    return NS_OK;
+  }
+
+  // No row found, search for rows in other table sections
+  nsCOMPtr<nsIDOMNode> rowParent;
+  rv = aCurrentRowNode->GetParentNode(getter_AddRefs(rowParent));
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(rowParent, NS_ERROR_NULL_POINTER);
+
+  nsCOMPtr<nsIDOMNode> parentSibling;
+  rv = rowParent->GetNextSibling(getter_AddRefs(parentSibling));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  while (parentSibling) {
+    rv = parentSibling->GetFirstChild(getter_AddRefs(nextRow));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // We can encounter textnodes here -- must find a row
+    while (nextRow && !HTMLEditUtils::IsTableRow(nextRow)) {
+      rv = nextRow->GetNextSibling(getter_AddRefs(nextNode));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nextRow = nextNode;
+    }
+    if (nextRow) {
+      *aRowNode = nextRow.get();
+      NS_ADDREF(*aRowNode);
+      return NS_OK;
+    }
+
+    // We arrive here only if a table section has no children
+    //  or first child of section is not a row (bad HTML or more "_moz_text" nodes!)
+    // So look for another section sibling
+    rv = parentSibling->GetNextSibling(getter_AddRefs(nextNode));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    parentSibling = nextNode;
+  }
+  // If here, row was not found
+  return NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND;
+}
+
+nsresult
+HTMLEditor::GetLastCellInRow(nsIDOMNode* aRowNode,
+                             nsIDOMNode** aCellNode)
+{
+  NS_ENSURE_TRUE(aCellNode, NS_ERROR_NULL_POINTER);
+
+  *aCellNode = nullptr;
+
+  NS_ENSURE_TRUE(aRowNode, NS_ERROR_NULL_POINTER);
+
+  nsCOMPtr<nsIDOMNode> rowChild;
+  nsresult rv = aRowNode->GetLastChild(getter_AddRefs(rowChild));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  while (rowChild && !HTMLEditUtils::IsTableCell(rowChild)) {
+    // Skip over textnodes
+    nsCOMPtr<nsIDOMNode> previousChild;
+    rv = rowChild->GetPreviousSibling(getter_AddRefs(previousChild));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rowChild = previousChild;
+  }
+  if (rowChild) {
+    *aCellNode = rowChild.get();
+    NS_ADDREF(*aCellNode);
+    return NS_OK;
+  }
+  // If here, cell was not found
+  return NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND;
+}
+
+NS_IMETHODIMP
+HTMLEditor::InsertTableColumn(int32_t aNumber,
+                              bool aAfter)
+{
+  RefPtr<Selection> selection;
+  nsCOMPtr<nsIDOMElement> table;
+  nsCOMPtr<nsIDOMElement> curCell;
+  int32_t startRowIndex, startColIndex;
+  nsresult rv = GetCellContext(getter_AddRefs(selection),
+                               getter_AddRefs(table),
+                               getter_AddRefs(curCell),
+                               nullptr, nullptr,
+                               &startRowIndex, &startColIndex);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Don't fail if no cell found
+  NS_ENSURE_TRUE(curCell, NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND);
+
+  // Get more data for current cell (we need ROWSPAN)
+  int32_t curStartRowIndex, curStartColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
+  bool    isSelected;
+  rv = GetCellDataAt(table, startRowIndex, startColIndex,
+                     getter_AddRefs(curCell),
+                     &curStartRowIndex, &curStartColIndex,
+                     &rowSpan, &colSpan,
+                     &actualRowSpan, &actualColSpan, &isSelected);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(curCell, NS_ERROR_FAILURE);
+
+  AutoEditBatch beginBatching(this);
+  // Prevent auto insertion of BR in new cell until we're done
+  AutoRules beginRulesSniffing(this, EditAction::insertNode, nsIEditor::eNext);
+
+  // Use column after current cell if requested
+  if (aAfter) {
+    startColIndex += actualColSpan;
+    //Detect when user is adding after a COLSPAN=0 case
+    // Assume they want to stop the "0" behavior and
+    // really add a new column. Thus we set the
+    // colspan to its true value
+    if (!colSpan) {
+      SetColSpan(curCell, actualColSpan);
+    }
+  }
+
+  int32_t rowCount, colCount, rowIndex;
+  rv = GetTableSize(table, &rowCount, &colCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  //We reset caret in destructor...
+  AutoSelectionSetterAfterTableEdit setCaret(this, table, startRowIndex,
+                                             startColIndex, ePreviousRow,
+                                             false);
+  //.. so suppress Rules System selection munging
+  AutoTransactionsConserveSelection dontChangeSelection(this);
+
+  // If we are inserting after all existing columns
+  // Make sure table is "well formed"
+  //  before appending new column
+  if (startColIndex >= colCount) {
+    NormalizeTable(table);
+  }
+
+  nsCOMPtr<nsIDOMNode> rowNode;
+  for (rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+    if (startColIndex < colCount) {
+      // We are inserting before an existing column
+      rv = GetCellDataAt(table, rowIndex, startColIndex,
+                         getter_AddRefs(curCell),
+                         &curStartRowIndex, &curStartColIndex,
+                         &rowSpan, &colSpan,
+                         &actualRowSpan, &actualColSpan, &isSelected);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Don't fail entire process if we fail to find a cell
+      //  (may fail just in particular rows with < adequate cells per row)
+      if (curCell) {
+        if (curStartColIndex < startColIndex) {
+          // We have a cell spanning this location
+          // Simply increase its colspan to keep table rectangular
+          // Note: we do nothing if colsSpan=0,
+          //  since it should automatically span the new column
+          if (colSpan > 0) {
+            SetColSpan(curCell, colSpan+aNumber);
+          }
+        } else {
+          // Simply set selection to the current cell
+          //  so we can let InsertTableCell() do the work
+          // Insert a new cell before current one
+          selection->Collapse(curCell, 0);
+          rv = InsertTableCell(aNumber, false);
+        }
+      }
+    } else {
+      // Get current row and append new cells after last cell in row
+      if (!rowIndex) {
+        rv = GetFirstRow(table.get(), getter_AddRefs(rowNode));
+        if (NS_WARN_IF(NS_FAILED(rv))) {
+          return rv;
+        }
+      } else {
+        nsCOMPtr<nsIDOMNode> nextRow;
+        rv = GetNextRow(rowNode.get(), getter_AddRefs(nextRow));
+        if (NS_WARN_IF(NS_FAILED(rv))) {
+          return rv;
+        }
+        rowNode = nextRow;
+      }
+
+      if (rowNode) {
+        nsCOMPtr<nsIDOMNode> lastCell;
+        rv = GetLastCellInRow(rowNode, getter_AddRefs(lastCell));
+        NS_ENSURE_SUCCESS(rv, rv);
+        NS_ENSURE_TRUE(lastCell, NS_ERROR_FAILURE);
+
+        curCell = do_QueryInterface(lastCell);
+        if (curCell) {
+          // Simply add same number of cells to each row
+          // Although tempted to check cell indexes for curCell,
+          //  the effects of COLSPAN>1 in some cells makes this futile!
+          // We must use NormalizeTable first to assure
+          //  that there are cells in each cellmap location
+          selection->Collapse(curCell, 0);
+          rv = InsertTableCell(aNumber, true);
+        }
+      }
+    }
+  }
+  // XXX This is perhaps the result of the last call of InsertTableCell().
+  return rv;
+}
+
+NS_IMETHODIMP
+HTMLEditor::InsertTableRow(int32_t aNumber,
+                           bool aAfter)
+{
+  nsCOMPtr<nsIDOMElement> table;
+  nsCOMPtr<nsIDOMElement> curCell;
+
+  int32_t startRowIndex, startColIndex;
+  nsresult rv = GetCellContext(nullptr,
+                               getter_AddRefs(table),
+                               getter_AddRefs(curCell),
+                               nullptr, nullptr,
+                               &startRowIndex, &startColIndex);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Don't fail if no cell found
+  NS_ENSURE_TRUE(curCell, NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND);
+
+  // Get more data for current cell in row we are inserting at (we need COLSPAN)
+  int32_t curStartRowIndex, curStartColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
+  bool    isSelected;
+  rv = GetCellDataAt(table, startRowIndex, startColIndex,
+                     getter_AddRefs(curCell),
+                     &curStartRowIndex, &curStartColIndex,
+                     &rowSpan, &colSpan,
+                     &actualRowSpan, &actualColSpan, &isSelected);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(curCell, NS_ERROR_FAILURE);
+
+  int32_t rowCount, colCount;
+  rv = GetTableSize(table, &rowCount, &colCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  AutoEditBatch beginBatching(this);
+  // Prevent auto insertion of BR in new cell until we're done
+  AutoRules beginRulesSniffing(this, EditAction::insertNode, nsIEditor::eNext);
+
+  if (aAfter) {
+    // Use row after current cell
+    startRowIndex += actualRowSpan;
+
+    //Detect when user is adding after a ROWSPAN=0 case
+    // Assume they want to stop the "0" behavior and
+    // really add a new row. Thus we set the
+    // rowspan to its true value
+    if (!rowSpan) {
+      SetRowSpan(curCell, actualRowSpan);
+    }
+  }
+
+  //We control selection resetting after the insert...
+  AutoSelectionSetterAfterTableEdit setCaret(this, table, startRowIndex,
+                                             startColIndex, ePreviousColumn,
+                                             false);
+  //...so suppress Rules System selection munging
+  AutoTransactionsConserveSelection dontChangeSelection(this);
+
+  nsCOMPtr<nsIDOMElement> cellForRowParent;
+  int32_t cellsInRow = 0;
+  if (startRowIndex < rowCount) {
+    // We are inserting above an existing row
+    // Get each cell in the insert row to adjust for COLSPAN effects while we
+    //   count how many cells are needed
+    int32_t colIndex = 0;
+    while (NS_SUCCEEDED(GetCellDataAt(table, startRowIndex, colIndex,
+                                      getter_AddRefs(curCell),
+                                      &curStartRowIndex, &curStartColIndex,
+                                      &rowSpan, &colSpan,
+                                      &actualRowSpan, &actualColSpan,
+                                      &isSelected))) {
+      if (curCell) {
+        if (curStartRowIndex < startRowIndex) {
+          // We have a cell spanning this location
+          // Simply increase its rowspan
+          //Note that if rowSpan == 0, we do nothing,
+          //  since that cell should automatically extend into the new row
+          if (rowSpan > 0) {
+            SetRowSpan(curCell, rowSpan+aNumber);
+          }
+        } else {
+          // We have a cell in the insert row
+
+          // Count the number of cells we need to add to the new row
+          cellsInRow += actualColSpan;
+
+          // Save cell we will use below
+          if (!cellForRowParent) {
+            cellForRowParent = curCell;
+          }
+        }
+        // Next cell in row
+        colIndex += actualColSpan;
+      } else {
+        colIndex++;
+      }
+    }
+  } else {
+    // We are adding a new row after all others
+    // If it weren't for colspan=0 effect,
+    // we could simply use colCount for number of new cells...
+    // XXX colspan=0 support has now been removed in table layout so maybe this can be cleaned up now? (bug 1243183)
+    cellsInRow = colCount;
+
+    // ...but we must compensate for all cells with rowSpan = 0 in the last row
+    int32_t lastRow = rowCount-1;
+    int32_t tempColIndex = 0;
+    while (NS_SUCCEEDED(GetCellDataAt(table, lastRow, tempColIndex,
+                                      getter_AddRefs(curCell),
+                                      &curStartRowIndex, &curStartColIndex,
+                                      &rowSpan, &colSpan,
+                                      &actualRowSpan, &actualColSpan,
+                                      &isSelected))) {
+      if (!rowSpan) {
+        cellsInRow -= actualColSpan;
+      }
+
+      tempColIndex += actualColSpan;
+
+      // Save cell from the last row that we will use below
+      if (!cellForRowParent && curStartRowIndex == lastRow) {
+        cellForRowParent = curCell;
+      }
+    }
+  }
+
+  if (cellsInRow > 0) {
+    // The row parent and offset where we will insert new row
+    nsCOMPtr<nsIDOMNode> parentOfRow;
+    int32_t newRowOffset;
+
+    NS_NAMED_LITERAL_STRING(trStr, "tr");
+    if (!cellForRowParent) {
+      return NS_ERROR_FAILURE;
+    }
+
+    nsCOMPtr<nsIDOMElement> parentRow;
+    rv = GetElementOrParentByTagName(trStr, cellForRowParent,
+                                     getter_AddRefs(parentRow));
+    NS_ENSURE_SUCCESS(rv, rv);
+    NS_ENSURE_TRUE(parentRow, NS_ERROR_NULL_POINTER);
+
+    parentRow->GetParentNode(getter_AddRefs(parentOfRow));
+    NS_ENSURE_TRUE(parentOfRow, NS_ERROR_NULL_POINTER);
+
+    newRowOffset = GetChildOffset(parentRow, parentOfRow);
+
+    // Adjust for when adding past the end
+    if (aAfter && startRowIndex >= rowCount) {
+      newRowOffset++;
+    }
+
+    for (int32_t row = 0; row < aNumber; row++) {
+      // Create a new row
+      nsCOMPtr<nsIDOMElement> newRow;
+      rv = CreateElementWithDefaults(trStr, getter_AddRefs(newRow));
+      if (NS_SUCCEEDED(rv)) {
+        NS_ENSURE_TRUE(newRow, NS_ERROR_FAILURE);
+
+        for (int32_t i = 0; i < cellsInRow; i++) {
+          nsCOMPtr<nsIDOMElement> newCell;
+          rv = CreateElementWithDefaults(NS_LITERAL_STRING("td"),
+                                         getter_AddRefs(newCell));
+          NS_ENSURE_SUCCESS(rv, rv);
+          NS_ENSURE_TRUE(newCell, NS_ERROR_FAILURE);
+
+          // Don't use transaction system yet! (not until entire row is inserted)
+          nsCOMPtr<nsIDOMNode>resultNode;
+          rv = newRow->AppendChild(newCell, getter_AddRefs(resultNode));
+          NS_ENSURE_SUCCESS(rv, rv);
+        }
+        // Use transaction system to insert the entire row+cells
+        // (Note that rows are inserted at same childoffset each time)
+        rv = InsertNode(newRow, parentOfRow, newRowOffset);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+    }
+  }
+  // XXX This might be the result of the last call of
+  //     CreateElementWithDefaults(), otherwise, NS_OK.
+  return rv;
+}
+
+// Editor helper only
+// XXX Code changed for bug 217717 and now we don't need aSelection param
+//     TODO: Remove aSelection param
+nsresult
+HTMLEditor::DeleteTable2(nsIDOMElement* aTable,
+                         Selection* aSelection)
+{
+  NS_ENSURE_TRUE(aTable, NS_ERROR_NULL_POINTER);
+
+  // Select the table
+  nsresult rv = ClearSelection();
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+  rv = AppendNodeToSelectionAsRange(aTable);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return DeleteSelection(nsIEditor::eNext, nsIEditor::eStrip);
+}
+
+NS_IMETHODIMP
+HTMLEditor::DeleteTable()
+{
+  RefPtr<Selection> selection;
+  nsCOMPtr<nsIDOMElement> table;
+  nsresult rv = GetCellContext(getter_AddRefs(selection),
+                               getter_AddRefs(table),
+                               nullptr, nullptr, nullptr, nullptr, nullptr);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  AutoEditBatch beginBatching(this);
+  return DeleteTable2(table, selection);
+}
+
+NS_IMETHODIMP
+HTMLEditor::DeleteTableCell(int32_t aNumber)
+{
+  RefPtr<Selection> selection;
+  nsCOMPtr<nsIDOMElement> table;
+  nsCOMPtr<nsIDOMElement> cell;
+  int32_t startRowIndex, startColIndex;
+
+
+  nsresult rv = GetCellContext(getter_AddRefs(selection),
+                               getter_AddRefs(table),
+                               getter_AddRefs(cell),
+                               nullptr, nullptr,
+                               &startRowIndex, &startColIndex);
+
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Don't fail if we didn't find a table or cell
+  NS_ENSURE_TRUE(table && cell, NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND);
+
+  AutoEditBatch beginBatching(this);
+  // Prevent rules testing until we're done
+  AutoRules beginRulesSniffing(this, EditAction::deleteNode, nsIEditor::eNext);
+
+  nsCOMPtr<nsIDOMElement> firstCell;
+  nsCOMPtr<nsIDOMRange> range;
+  rv = GetFirstSelectedCell(getter_AddRefs(range), getter_AddRefs(firstCell));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t rangeCount;
+  rv = selection->GetRangeCount(&rangeCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (firstCell && rangeCount > 1) {
+    // When > 1 selected cell,
+    //  ignore aNumber and use selected cells
+    cell = firstCell;
+
+    int32_t rowCount, colCount;
+    rv = GetTableSize(table, &rowCount, &colCount);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Get indexes -- may be different than original cell
+    rv = GetCellIndexes(cell, &startRowIndex, &startColIndex);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // The setCaret object will call AutoSelectionSetterAfterTableEdit in its
+    // destructor
+    AutoSelectionSetterAfterTableEdit setCaret(this, table, startRowIndex,
+                                               startColIndex, ePreviousColumn,
+                                               false);
+    AutoTransactionsConserveSelection dontChangeSelection(this);
+
+    bool    checkToDeleteRow = true;
+    bool    checkToDeleteColumn = true;
+    while (cell) {
+      bool deleteRow = false;
+      bool deleteCol = false;
+
+      if (checkToDeleteRow) {
+        // Optimize to delete an entire row
+        // Clear so we don't repeat AllCellsInRowSelected within the same row
+        checkToDeleteRow = false;
+
+        deleteRow = AllCellsInRowSelected(table, startRowIndex, colCount);
+        if (deleteRow) {
+          // First, find the next cell in a different row
+          //   to continue after we delete this row
+          int32_t nextRow = startRowIndex;
+          while (nextRow == startRowIndex) {
+            rv = GetNextSelectedCell(nullptr, getter_AddRefs(cell));
+            NS_ENSURE_SUCCESS(rv, rv);
+            if (!cell) {
+              break;
+            }
+            rv = GetCellIndexes(cell, &nextRow, &startColIndex);
+            NS_ENSURE_SUCCESS(rv, rv);
+          }
+          // Delete entire row
+          rv = DeleteRow(table, startRowIndex);
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          if (cell) {
+            // For the next cell: Subtract 1 for row we deleted
+            startRowIndex = nextRow - 1;
+            // Set true since we know we will look at a new row next
+            checkToDeleteRow = true;
+          }
+        }
+      }
+      if (!deleteRow) {
+        if (checkToDeleteColumn) {
+          // Optimize to delete an entire column
+          // Clear this so we don't repeat AllCellsInColSelected within the same Col
+          checkToDeleteColumn = false;
+
+          deleteCol = AllCellsInColumnSelected(table, startColIndex, colCount);
+          if (deleteCol) {
+            // First, find the next cell in a different column
+            //   to continue after we delete this column
+            int32_t nextCol = startColIndex;
+            while (nextCol == startColIndex) {
+              rv = GetNextSelectedCell(nullptr, getter_AddRefs(cell));
+              NS_ENSURE_SUCCESS(rv, rv);
+              if (!cell) {
+                break;
+              }
+              rv = GetCellIndexes(cell, &startRowIndex, &nextCol);
+              NS_ENSURE_SUCCESS(rv, rv);
+            }
+            // Delete entire Col
+            rv = DeleteColumn(table, startColIndex);
+            NS_ENSURE_SUCCESS(rv, rv);
+            if (cell) {
+              // For the next cell, subtract 1 for col. deleted
+              startColIndex = nextCol - 1;
+              // Set true since we know we will look at a new column next
+              checkToDeleteColumn = true;
+            }
+          }
+        }
+        if (!deleteCol) {
+          // First get the next cell to delete
+          nsCOMPtr<nsIDOMElement> nextCell;
+          rv = GetNextSelectedCell(getter_AddRefs(range),
+                                   getter_AddRefs(nextCell));
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          // Then delete the cell
+          rv = DeleteNode(cell);
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          // The next cell to delete
+          cell = nextCell;
+          if (cell) {
+            rv = GetCellIndexes(cell, &startRowIndex, &startColIndex);
+            NS_ENSURE_SUCCESS(rv, rv);
+          }
+        }
+      }
+    }
+  } else {
+    for (int32_t i = 0; i < aNumber; i++) {
+      rv = GetCellContext(getter_AddRefs(selection),
+                          getter_AddRefs(table),
+                          getter_AddRefs(cell),
+                          nullptr, nullptr,
+                          &startRowIndex, &startColIndex);
+      NS_ENSURE_SUCCESS(rv, rv);
+      // Don't fail if no cell found
+      NS_ENSURE_TRUE(cell, NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND);
+
+      if (GetNumberOfCellsInRow(table, startRowIndex) == 1) {
+        nsCOMPtr<nsIDOMElement> parentRow;
+        rv = GetElementOrParentByTagName(NS_LITERAL_STRING("tr"), cell,
+                                         getter_AddRefs(parentRow));
+        NS_ENSURE_SUCCESS(rv, rv);
+        NS_ENSURE_TRUE(parentRow, NS_ERROR_NULL_POINTER);
+
+        // We should delete the row instead,
+        //  but first check if its the only row left
+        //  so we can delete the entire table
+        int32_t rowCount, colCount;
+        rv = GetTableSize(table, &rowCount, &colCount);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        if (rowCount == 1) {
+          return DeleteTable2(table, selection);
+        }
+
+        // We need to call DeleteTableRow to handle cells with rowspan
+        rv = DeleteTableRow(1);
+        NS_ENSURE_SUCCESS(rv, rv);
+      } else {
+        // More than 1 cell in the row
+
+        // The setCaret object will call AutoSelectionSetterAfterTableEdit in its
+        // destructor
+        AutoSelectionSetterAfterTableEdit setCaret(this, table, startRowIndex,
+                                                   startColIndex, ePreviousColumn,
+                                                   false);
+        AutoTransactionsConserveSelection dontChangeSelection(this);
+
+        rv = DeleteNode(cell);
+        // If we fail, don't try to delete any more cells???
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::DeleteTableCellContents()
+{
+  RefPtr<Selection> selection;
+  nsCOMPtr<nsIDOMElement> table;
+  nsCOMPtr<nsIDOMElement> cell;
+  int32_t startRowIndex, startColIndex;
+  nsresult rv = GetCellContext(getter_AddRefs(selection),
+                               getter_AddRefs(table),
+                               getter_AddRefs(cell),
+                               nullptr, nullptr,
+                               &startRowIndex, &startColIndex);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Don't fail if no cell found
+  NS_ENSURE_TRUE(cell, NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND);
+
+
+  AutoEditBatch beginBatching(this);
+  // Prevent rules testing until we're done
+  AutoRules beginRulesSniffing(this, EditAction::deleteNode, nsIEditor::eNext);
+  //Don't let Rules System change the selection
+  AutoTransactionsConserveSelection dontChangeSelection(this);
+
+
+  nsCOMPtr<nsIDOMElement> firstCell;
+  nsCOMPtr<nsIDOMRange> range;
+  rv = GetFirstSelectedCell(getter_AddRefs(range), getter_AddRefs(firstCell));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+
+  if (firstCell) {
+    cell = firstCell;
+    rv = GetCellIndexes(cell, &startRowIndex, &startColIndex);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  AutoSelectionSetterAfterTableEdit setCaret(this, table, startRowIndex,
+                                             startColIndex, ePreviousColumn,
+                                             false);
+
+  while (cell) {
+    DeleteCellContents(cell);
+    if (firstCell) {
+      // We doing a selected cells, so do all of them
+      rv = GetNextSelectedCell(nullptr, getter_AddRefs(cell));
+      NS_ENSURE_SUCCESS(rv, rv);
+    } else {
+      cell = nullptr;
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::DeleteCellContents(nsIDOMElement* aCell)
+{
+  NS_ENSURE_TRUE(aCell, NS_ERROR_NULL_POINTER);
+
+  // Prevent rules testing until we're done
+  AutoRules beginRulesSniffing(this, EditAction::deleteNode, nsIEditor::eNext);
+
+  nsCOMPtr<nsIDOMNode> child;
+  bool hasChild;
+  aCell->HasChildNodes(&hasChild);
+
+  while (hasChild) {
+    aCell->GetLastChild(getter_AddRefs(child));
+    nsresult rv = DeleteNode(child);
+    NS_ENSURE_SUCCESS(rv, rv);
+    aCell->HasChildNodes(&hasChild);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::DeleteTableColumn(int32_t aNumber)
+{
+  RefPtr<Selection> selection;
+  nsCOMPtr<nsIDOMElement> table;
+  nsCOMPtr<nsIDOMElement> cell;
+  int32_t startRowIndex, startColIndex, rowCount, colCount;
+  nsresult rv = GetCellContext(getter_AddRefs(selection),
+                               getter_AddRefs(table),
+                               getter_AddRefs(cell),
+                               nullptr, nullptr,
+                               &startRowIndex, &startColIndex);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Don't fail if no cell found
+  NS_ENSURE_TRUE(table && cell, NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND);
+
+  rv = GetTableSize(table, &rowCount, &colCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Shortcut the case of deleting all columns in table
+  if (!startColIndex && aNumber >= colCount) {
+    return DeleteTable2(table, selection);
+  }
+
+  // Check for counts too high
+  aNumber = std::min(aNumber,(colCount-startColIndex));
+
+  AutoEditBatch beginBatching(this);
+  // Prevent rules testing until we're done
+  AutoRules beginRulesSniffing(this, EditAction::deleteNode, nsIEditor::eNext);
+
+  // Test if deletion is controlled by selected cells
+  nsCOMPtr<nsIDOMElement> firstCell;
+  nsCOMPtr<nsIDOMRange> range;
+  rv = GetFirstSelectedCell(getter_AddRefs(range), getter_AddRefs(firstCell));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t rangeCount;
+  rv = selection->GetRangeCount(&rangeCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (firstCell && rangeCount > 1) {
+    // Fetch indexes again - may be different for selected cells
+    rv = GetCellIndexes(firstCell, &startRowIndex, &startColIndex);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  //We control selection resetting after the insert...
+  AutoSelectionSetterAfterTableEdit setCaret(this, table, startRowIndex,
+                                             startColIndex, ePreviousRow,
+                                             false);
+
+  if (firstCell && rangeCount > 1) {
+    // Use selected cells to determine what rows to delete
+    cell = firstCell;
+
+    while (cell) {
+      if (cell != firstCell) {
+        rv = GetCellIndexes(cell, &startRowIndex, &startColIndex);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+      // Find the next cell in a different column
+      // to continue after we delete this column
+      int32_t nextCol = startColIndex;
+      while (nextCol == startColIndex) {
+        rv = GetNextSelectedCell(getter_AddRefs(range), getter_AddRefs(cell));
+        NS_ENSURE_SUCCESS(rv, rv);
+        if (!cell) {
+          break;
+        }
+        rv = GetCellIndexes(cell, &startRowIndex, &nextCol);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+      rv = DeleteColumn(table, startColIndex);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  } else {
+    for (int32_t i = 0; i < aNumber; i++) {
+      rv = DeleteColumn(table, startColIndex);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::DeleteColumn(nsIDOMElement* aTable,
+                         int32_t aColIndex)
+{
+  NS_ENSURE_TRUE(aTable, NS_ERROR_NULL_POINTER);
+
+  nsCOMPtr<nsIDOMElement> cell;
+  int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
+  bool    isSelected;
+  int32_t rowIndex = 0;
+
+  do {
+    nsresult rv =
+      GetCellDataAt(aTable, rowIndex, aColIndex, getter_AddRefs(cell),
+                    &startRowIndex, &startColIndex, &rowSpan, &colSpan,
+                    &actualRowSpan, &actualColSpan, &isSelected);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (cell) {
+      // Find cells that don't start in column we are deleting
+      if (startColIndex < aColIndex || colSpan > 1 || !colSpan) {
+        // We have a cell spanning this location
+        // Decrease its colspan to keep table rectangular,
+        // but if colSpan=0, it will adjust automatically
+        if (colSpan > 0) {
+          NS_ASSERTION((colSpan > 1),"Bad COLSPAN in DeleteTableColumn");
+          SetColSpan(cell, colSpan-1);
+        }
+        if (startColIndex == aColIndex) {
+          // Cell is in column to be deleted, but must have colspan > 1,
+          // so delete contents of cell instead of cell itself
+          // (We must have reset colspan above)
+          DeleteCellContents(cell);
+        }
+        // To next cell in column
+        rowIndex += actualRowSpan;
+      } else {
+        // Delete the cell
+        if (GetNumberOfCellsInRow(aTable, rowIndex) == 1) {
+          // Only 1 cell in row - delete the row
+          nsCOMPtr<nsIDOMElement> parentRow;
+          rv = GetElementOrParentByTagName(NS_LITERAL_STRING("tr"), cell,
+                                           getter_AddRefs(parentRow));
+          NS_ENSURE_SUCCESS(rv, rv);
+          if (!parentRow) {
+            return NS_ERROR_NULL_POINTER;
+          }
+
+          //  But first check if its the only row left
+          //  so we can delete the entire table
+          //  (This should never happen but it's the safe thing to do)
+          int32_t rowCount, colCount;
+          rv = GetTableSize(aTable, &rowCount, &colCount);
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          if (rowCount == 1) {
+            RefPtr<Selection> selection = GetSelection();
+            NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
+            return DeleteTable2(aTable, selection);
+          }
+
+          // Delete the row by placing caret in cell we were to delete
+          // We need to call DeleteTableRow to handle cells with rowspan
+          rv = DeleteRow(aTable, startRowIndex);
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          // Note that we don't incremenet rowIndex
+          // since a row was deleted and "next"
+          // row now has current rowIndex
+        } else {
+          // A more "normal" deletion
+          rv = DeleteNode(cell);
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          //Skip over any rows spanned by this cell
+          rowIndex += actualRowSpan;
+        }
+      }
+    }
+  } while (cell);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::DeleteTableRow(int32_t aNumber)
+{
+  RefPtr<Selection> selection;
+  nsCOMPtr<nsIDOMElement> table;
+  nsCOMPtr<nsIDOMElement> cell;
+  int32_t startRowIndex, startColIndex;
+  int32_t rowCount, colCount;
+  nsresult rv =  GetCellContext(getter_AddRefs(selection),
+                                getter_AddRefs(table),
+                                getter_AddRefs(cell),
+                                nullptr, nullptr,
+                                &startRowIndex, &startColIndex);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Don't fail if no cell found
+  NS_ENSURE_TRUE(cell, NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND);
+
+  rv = GetTableSize(table, &rowCount, &colCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Shortcut the case of deleting all rows in table
+  if (!startRowIndex && aNumber >= rowCount) {
+    return DeleteTable2(table, selection);
+  }
+
+  AutoEditBatch beginBatching(this);
+  // Prevent rules testing until we're done
+  AutoRules beginRulesSniffing(this, EditAction::deleteNode, nsIEditor::eNext);
+
+  nsCOMPtr<nsIDOMElement> firstCell;
+  nsCOMPtr<nsIDOMRange> range;
+  rv = GetFirstSelectedCell(getter_AddRefs(range), getter_AddRefs(firstCell));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t rangeCount;
+  rv = selection->GetRangeCount(&rangeCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (firstCell && rangeCount > 1) {
+    // Fetch indexes again - may be different for selected cells
+    rv = GetCellIndexes(firstCell, &startRowIndex, &startColIndex);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  //We control selection resetting after the insert...
+  AutoSelectionSetterAfterTableEdit setCaret(this, table, startRowIndex,
+                                             startColIndex, ePreviousRow,
+                                             false);
+  // Don't change selection during deletions
+  AutoTransactionsConserveSelection dontChangeSelection(this);
+
+  if (firstCell && rangeCount > 1) {
+    // Use selected cells to determine what rows to delete
+    cell = firstCell;
+
+    while (cell) {
+      if (cell != firstCell) {
+        rv = GetCellIndexes(cell, &startRowIndex, &startColIndex);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+      // Find the next cell in a different row
+      // to continue after we delete this row
+      int32_t nextRow = startRowIndex;
+      while (nextRow == startRowIndex) {
+        rv = GetNextSelectedCell(getter_AddRefs(range), getter_AddRefs(cell));
+        NS_ENSURE_SUCCESS(rv, rv);
+        if (!cell) break;
+        rv = GetCellIndexes(cell, &nextRow, &startColIndex);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+      // Delete entire row
+      rv = DeleteRow(table, startRowIndex);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  } else {
+    // Check for counts too high
+    aNumber = std::min(aNumber,(rowCount-startRowIndex));
+    for (int32_t i = 0; i < aNumber; i++) {
+      rv = DeleteRow(table, startRowIndex);
+      // If failed in current row, try the next
+      if (NS_FAILED(rv)) {
+        startRowIndex++;
+      }
+
+      // Check if there's a cell in the "next" row
+      rv = GetCellAt(table, startRowIndex, startColIndex, getter_AddRefs(cell));
+      NS_ENSURE_SUCCESS(rv, rv);
+      if (!cell) {
+        break;
+      }
+    }
+  }
+  return NS_OK;
+}
+
+// Helper that doesn't batch or change the selection
+NS_IMETHODIMP
+HTMLEditor::DeleteRow(nsIDOMElement* aTable,
+                      int32_t aRowIndex)
+{
+  NS_ENSURE_TRUE(aTable, NS_ERROR_NULL_POINTER);
+
+  nsCOMPtr<nsIDOMElement> cell;
+  nsCOMPtr<nsIDOMElement> cellInDeleteRow;
+  int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
+  bool    isSelected;
+  int32_t colIndex = 0;
+
+  // Prevent rules testing until we're done
+  AutoRules beginRulesSniffing(this, EditAction::deleteNode, nsIEditor::eNext);
+
+  // The list of cells we will change rowspan in
+  //  and the new rowspan values for each
+  nsTArray<nsCOMPtr<nsIDOMElement> > spanCellList;
+  nsTArray<int32_t> newSpanList;
+
+  int32_t rowCount, colCount;
+  nsresult rv = GetTableSize(aTable, &rowCount, &colCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Scan through cells in row to do rowspan adjustments
+  // Note that after we delete row, startRowIndex will point to the
+  //   cells in the next row to be deleted
+  do {
+    if (aRowIndex >= rowCount || colIndex >= colCount) {
+      break;
+    }
+
+    rv = GetCellDataAt(aTable, aRowIndex, colIndex, getter_AddRefs(cell),
+                       &startRowIndex, &startColIndex, &rowSpan, &colSpan,
+                       &actualRowSpan, &actualColSpan, &isSelected);
+    // We don't fail if we don't find a cell, so this must be real bad
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+
+    // Compensate for cells that don't start or extend below the row we are deleting
+    if (cell) {
+      if (startRowIndex < aRowIndex) {
+        // Cell starts in row above us
+        // Decrease its rowspan to keep table rectangular
+        //  but we don't need to do this if rowspan=0,
+        //  since it will automatically adjust
+        if (rowSpan > 0) {
+          // Build list of cells to change rowspan
+          // We can't do it now since it upsets cell map,
+          //  so we will do it after deleting the row
+          spanCellList.AppendElement(cell);
+          newSpanList.AppendElement(std::max((aRowIndex - startRowIndex), actualRowSpan-1));
+        }
+      } else {
+        if (rowSpan > 1) {
+          // Cell spans below row to delete, so we must insert new cells to
+          // keep rows below.  Note that we test "rowSpan" so we don't do this
+          // if rowSpan = 0 (automatic readjustment).
+          int32_t aboveRowToInsertNewCellInto = aRowIndex - startRowIndex + 1;
+          int32_t numOfRawSpanRemainingBelow = actualRowSpan - 1;
+          rv = SplitCellIntoRows(aTable, startRowIndex, startColIndex,
+                                 aboveRowToInsertNewCellInto,
+                                 numOfRawSpanRemainingBelow, nullptr);
+          NS_ENSURE_SUCCESS(rv, rv);
+        }
+        if (!cellInDeleteRow) {
+          cellInDeleteRow = cell; // Reference cell to find row to delete
+        }
+      }
+      // Skip over other columns spanned by this cell
+      colIndex += actualColSpan;
+    }
+  } while (cell);
+
+  // Things are messed up if we didn't find a cell in the row!
+  NS_ENSURE_TRUE(cellInDeleteRow, NS_ERROR_FAILURE);
+
+  // Delete the entire row
+  nsCOMPtr<nsIDOMElement> parentRow;
+  rv = GetElementOrParentByTagName(NS_LITERAL_STRING("tr"), cellInDeleteRow,
+                                   getter_AddRefs(parentRow));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (parentRow) {
+    rv = DeleteNode(parentRow);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // Now we can set new rowspans for cells stored above
+  for (uint32_t i = 0, n = spanCellList.Length(); i < n; i++) {
+    nsIDOMElement *cellPtr = spanCellList[i];
+    if (cellPtr) {
+      rv = SetRowSpan(cellPtr, newSpanList[i]);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+HTMLEditor::SelectTable()
+{
+  nsCOMPtr<nsIDOMElement> table;
+  nsresult rv = GetElementOrParentByTagName(NS_LITERAL_STRING("table"), nullptr,
+                                            getter_AddRefs(table));
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Don't fail if we didn't find a table
+  NS_ENSURE_TRUE(table, NS_OK);
+
+  rv = ClearSelection();
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+  return AppendNodeToSelectionAsRange(table);
+}
+
+NS_IMETHODIMP
+HTMLEditor::SelectTableCell()
+{
+  nsCOMPtr<nsIDOMElement> cell;
+  nsresult rv = GetElementOrParentByTagName(NS_LITERAL_STRING("td"), nullptr,
+                                            getter_AddRefs(cell));
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(cell, NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND);
+
+  rv = ClearSelection();
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+  return AppendNodeToSelectionAsRange(cell);
+}
+
+NS_IMETHODIMP
+HTMLEditor::SelectBlockOfCells(nsIDOMElement* aStartCell,
+                               nsIDOMElement* aEndCell)
+{
+  NS_ENSURE_TRUE(aStartCell && aEndCell, NS_ERROR_NULL_POINTER);
+
+  RefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
+
+  NS_NAMED_LITERAL_STRING(tableStr, "table");
+  nsCOMPtr<nsIDOMElement> table;
+  nsresult rv = GetElementOrParentByTagName(tableStr, aStartCell,
+                                            getter_AddRefs(table));
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(table, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsIDOMElement> endTable;
+  rv = GetElementOrParentByTagName(tableStr, aEndCell,
+                                   getter_AddRefs(endTable));
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(endTable, NS_ERROR_FAILURE);
+
+  // We can only select a block if within the same table,
+  //  so do nothing if not within one table
+  if (table != endTable) {
+    return NS_OK;
+  }
+
+  int32_t startRowIndex, startColIndex, endRowIndex, endColIndex;
+
+  // Get starting and ending cells' location in the cellmap
+  rv = GetCellIndexes(aStartCell, &startRowIndex, &startColIndex);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  rv = GetCellIndexes(aEndCell, &endRowIndex, &endColIndex);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  // Suppress nsISelectionListener notification
+  //  until all selection changes are finished
+  SelectionBatcher selectionBatcher(selection);
+
+  // Examine all cell nodes in current selection and
+  //  remove those outside the new block cell region
+  int32_t minColumn = std::min(startColIndex, endColIndex);
+  int32_t minRow    = std::min(startRowIndex, endRowIndex);
+  int32_t maxColumn   = std::max(startColIndex, endColIndex);
+  int32_t maxRow      = std::max(startRowIndex, endRowIndex);
+
+  nsCOMPtr<nsIDOMElement> cell;
+  int32_t currentRowIndex, currentColIndex;
+  nsCOMPtr<nsIDOMRange> range;
+  rv = GetFirstSelectedCell(getter_AddRefs(range), getter_AddRefs(cell));
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (rv == NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND) {
+    return NS_OK;
+  }
+
+  while (cell) {
+    rv = GetCellIndexes(cell, &currentRowIndex, &currentColIndex);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (currentRowIndex < maxRow || currentRowIndex > maxRow ||
+        currentColIndex < maxColumn || currentColIndex > maxColumn) {
+      selection->RemoveRange(range);
+      // Since we've removed the range, decrement pointer to next range
+      mSelectedCellIndex--;
+    }
+    rv = GetNextSelectedCell(getter_AddRefs(range), getter_AddRefs(cell));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  int32_t rowSpan, colSpan, actualRowSpan, actualColSpan;
+  bool    isSelected;
+  for (int32_t row = minRow; row <= maxRow; row++) {
+    for (int32_t col = minColumn; col <= maxColumn;
+        col += std::max(actualColSpan, 1)) {
+      rv = GetCellDataAt(table, row, col, getter_AddRefs(cell),
+                         &currentRowIndex, &currentColIndex,
+                         &rowSpan, &colSpan,
+                         &actualRowSpan, &actualColSpan, &isSelected);
+      if (NS_FAILED(rv)) {
+        break;
+      }
+      // Skip cells that already selected or are spanned from previous locations
+      if (!isSelected && cell &&
+          row == currentRowIndex && col == currentColIndex) {
+        rv = AppendNodeToSelectionAsRange(cell);
+        if (NS_FAILED(rv)) {
+          break;
+        }
+      }
+    }
+  }
+  // NS_OK, otherwise, the last failure of GetCellDataAt() or
+  // AppendNodeToSelectionAsRange().
+  return rv;
+}
+
+NS_IMETHODIMP
+HTMLEditor::SelectAllTableCells()
+{
+  nsCOMPtr<nsIDOMElement> cell;
+  nsresult rv = GetElementOrParentByTagName(NS_LITERAL_STRING("td"), nullptr,
+                                            getter_AddRefs(cell));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Don't fail if we didn't find a cell
+  NS_ENSURE_TRUE(cell, NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND);
+
+  nsCOMPtr<nsIDOMElement> startCell = cell;
+
+  // Get parent table
+  nsCOMPtr<nsIDOMElement> table;
+  rv = GetElementOrParentByTagName(NS_LITERAL_STRING("table"), cell,
+                                   getter_AddRefs(table));
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!table) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  int32_t rowCount, colCount;
+  rv = GetTableSize(table, &rowCount, &colCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  RefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
+
+  // Suppress nsISelectionListener notification
+  //  until all selection changes are finished
+  SelectionBatcher selectionBatcher(selection);
+
+  // It is now safe to clear the selection
+  // BE SURE TO RESET IT BEFORE LEAVING!
+  rv = ClearSelection();
+
+  // Select all cells in the same column as current cell
+  bool cellSelected = false;
+  int32_t rowSpan, colSpan, actualRowSpan, actualColSpan, currentRowIndex, currentColIndex;
+  bool    isSelected;
+  for (int32_t row = 0; row < rowCount; row++) {
+    for (int32_t col = 0; col < colCount; col += std::max(actualColSpan, 1)) {
+      rv = GetCellDataAt(table, row, col, getter_AddRefs(cell),
+                         &currentRowIndex, &currentColIndex,
+                         &rowSpan, &colSpan,
+                         &actualRowSpan, &actualColSpan, &isSelected);
+      if (NS_FAILED(rv)) {
+        break;
+      }
+      // Skip cells that are spanned from previous rows or columns
+      if (cell && row == currentRowIndex && col == currentColIndex) {
+        rv =  AppendNodeToSelectionAsRange(cell);
+        if (NS_FAILED(rv)) {
+          break;
+        }
+        cellSelected = true;
+      }
+    }
+  }
+  // Safety code to select starting cell if nothing else was selected
+  if (!cellSelected) {
+    return AppendNodeToSelectionAsRange(startCell);
+  }
+  // NS_OK, otherwise, the error of ClearSelection() when there is no column or
+  // the last failure of GetCellDataAt() or AppendNodeToSelectionAsRange().
+  return rv;
+}
+
+NS_IMETHODIMP
+HTMLEditor::SelectTableRow()
+{
+  nsCOMPtr<nsIDOMElement> cell;
+  nsresult rv = GetElementOrParentByTagName(NS_LITERAL_STRING("td"), nullptr,
+                                            getter_AddRefs(cell));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Don't fail if we didn't find a cell
+  NS_ENSURE_TRUE(cell, NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND);
+  nsCOMPtr<nsIDOMElement> startCell = cell;
+
+  // Get table and location of cell:
+  RefPtr<Selection> selection;
+  nsCOMPtr<nsIDOMElement> table;
+  int32_t startRowIndex, startColIndex;
+
+  rv = GetCellContext(getter_AddRefs(selection),
+                      getter_AddRefs(table),
+                      getter_AddRefs(cell),
+                      nullptr, nullptr,
+                      &startRowIndex, &startColIndex);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(table, NS_ERROR_FAILURE);
+
+  int32_t rowCount, colCount;
+  rv = GetTableSize(table, &rowCount, &colCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  //Note: At this point, we could get first and last cells in row,
+  //  then call SelectBlockOfCells, but that would take just
+  //  a little less code, so the following is more efficient
+
+  // Suppress nsISelectionListener notification
+  //  until all selection changes are finished
+  SelectionBatcher selectionBatcher(selection);
+
+  // It is now safe to clear the selection
+  // BE SURE TO RESET IT BEFORE LEAVING!
+  rv = ClearSelection();
+
+  // Select all cells in the same row as current cell
+  bool cellSelected = false;
+  int32_t rowSpan, colSpan, actualRowSpan, actualColSpan, currentRowIndex, currentColIndex;
+  bool    isSelected;
+  for (int32_t col = 0; col < colCount; col += std::max(actualColSpan, 1)) {
+    rv = GetCellDataAt(table, startRowIndex, col, getter_AddRefs(cell),
+                       &currentRowIndex, &currentColIndex, &rowSpan, &colSpan,
+                       &actualRowSpan, &actualColSpan, &isSelected);
+    if (NS_FAILED(rv)) {
+      break;
+    }
+    // Skip cells that are spanned from previous rows or columns
+    if (cell && currentRowIndex == startRowIndex && currentColIndex == col) {
+      rv = AppendNodeToSelectionAsRange(cell);
+      if (NS_FAILED(rv)) {
+        break;
+      }
+      cellSelected = true;
+    }
+  }
+  // Safety code to select starting cell if nothing else was selected
+  if (!cellSelected) {
+    return AppendNodeToSelectionAsRange(startCell);
+  }
+  // NS_OK, otherwise, the error of ClearSelection() when there is no column or
+  // the last failure of GetCellDataAt() or AppendNodeToSelectionAsRange().
+  return rv;
+}
+
+NS_IMETHODIMP
+HTMLEditor::SelectTableColumn()
+{
+  nsCOMPtr<nsIDOMElement> cell;
+  nsresult rv = GetElementOrParentByTagName(NS_LITERAL_STRING("td"), nullptr,
+                                            getter_AddRefs(cell));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Don't fail if we didn't find a cell
+  NS_ENSURE_TRUE(cell, NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND);
+
+  nsCOMPtr<nsIDOMElement> startCell = cell;
+
+  // Get location of cell:
+  RefPtr<Selection> selection;
+  nsCOMPtr<nsIDOMElement> table;
+  int32_t startRowIndex, startColIndex;
+
+  rv = GetCellContext(getter_AddRefs(selection),
+                      getter_AddRefs(table),
+                      getter_AddRefs(cell),
+                      nullptr, nullptr,
+                      &startRowIndex, &startColIndex);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(table, NS_ERROR_FAILURE);
+
+  int32_t rowCount, colCount;
+  rv = GetTableSize(table, &rowCount, &colCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Suppress nsISelectionListener notification
+  //  until all selection changes are finished
+  SelectionBatcher selectionBatcher(selection);
+
+  // It is now safe to clear the selection
+  // BE SURE TO RESET IT BEFORE LEAVING!
+  rv = ClearSelection();
+
+  // Select all cells in the same column as current cell
+  bool cellSelected = false;
+  int32_t rowSpan, colSpan, actualRowSpan, actualColSpan, currentRowIndex, currentColIndex;
+  bool    isSelected;
+  for (int32_t row = 0; row < rowCount; row += std::max(actualRowSpan, 1)) {
+    rv = GetCellDataAt(table, row, startColIndex, getter_AddRefs(cell),
+                       &currentRowIndex, &currentColIndex, &rowSpan, &colSpan,
+                       &actualRowSpan, &actualColSpan, &isSelected);
+    if (NS_FAILED(rv)) {
+      break;
+    }
+    // Skip cells that are spanned from previous rows or columns
+    if (cell && currentRowIndex == row && currentColIndex == startColIndex) {
+      rv = AppendNodeToSelectionAsRange(cell);
+      if (NS_FAILED(rv)) {
+        break;
+      }
+      cellSelected = true;
+    }
+  }
+  // Safety code to select starting cell if nothing else was selected
+  if (!cellSelected) {
+    return AppendNodeToSelectionAsRange(startCell);
+  }
+  // NS_OK, otherwise, the error of ClearSelection() when there is no row or
+  // the last failure of GetCellDataAt() or AppendNodeToSelectionAsRange().
+  return rv;
+}
+
+NS_IMETHODIMP
+HTMLEditor::SplitTableCell()
+{
+  nsCOMPtr<nsIDOMElement> table;
+  nsCOMPtr<nsIDOMElement> cell;
+  int32_t startRowIndex, startColIndex, actualRowSpan, actualColSpan;
+  // Get cell, table, etc. at selection anchor node
+  nsresult rv = GetCellContext(nullptr,
+                               getter_AddRefs(table),
+                               getter_AddRefs(cell),
+                               nullptr, nullptr,
+                               &startRowIndex, &startColIndex);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!table || !cell) {
+    return NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND;
+  }
+
+  // We need rowspan and colspan data
+  rv = GetCellSpansAt(table, startRowIndex, startColIndex,
+                      actualRowSpan, actualColSpan);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Must have some span to split
+  if (actualRowSpan <= 1 && actualColSpan <= 1) {
+    return NS_OK;
+  }
+
+  AutoEditBatch beginBatching(this);
+  // Prevent auto insertion of BR in new cell until we're done
+  AutoRules beginRulesSniffing(this, EditAction::insertNode, nsIEditor::eNext);
+
+  // We reset selection
+  AutoSelectionSetterAfterTableEdit setCaret(this, table, startRowIndex,
+                                             startColIndex, ePreviousColumn,
+                                             false);
+  //...so suppress Rules System selection munging
+  AutoTransactionsConserveSelection dontChangeSelection(this);
+
+  nsCOMPtr<nsIDOMElement> newCell;
+  int32_t rowIndex = startRowIndex;
+  int32_t rowSpanBelow, colSpanAfter;
+
+  // Split up cell row-wise first into rowspan=1 above, and the rest below,
+  //  whittling away at the cell below until no more extra span
+  for (rowSpanBelow = actualRowSpan-1; rowSpanBelow >= 0; rowSpanBelow--) {
+    // We really split row-wise only if we had rowspan > 1
+    if (rowSpanBelow > 0) {
+      rv = SplitCellIntoRows(table, rowIndex, startColIndex, 1, rowSpanBelow,
+                             getter_AddRefs(newCell));
+      NS_ENSURE_SUCCESS(rv, rv);
+      CopyCellBackgroundColor(newCell, cell);
+    }
+    int32_t colIndex = startColIndex;
+    // Now split the cell with rowspan = 1 into cells if it has colSpan > 1
+    for (colSpanAfter = actualColSpan-1; colSpanAfter > 0; colSpanAfter--) {
+      rv = SplitCellIntoColumns(table, rowIndex, colIndex, 1, colSpanAfter,
+                                getter_AddRefs(newCell));
+      NS_ENSURE_SUCCESS(rv, rv);
+      CopyCellBackgroundColor(newCell, cell);
+      colIndex++;
+    }
+    // Point to the new cell and repeat
+    rowIndex++;
+  }
+  return NS_OK;
+}
+
+nsresult
+HTMLEditor::CopyCellBackgroundColor(nsIDOMElement* destCell,
+                                    nsIDOMElement* sourceCell)
+{
+  NS_ENSURE_TRUE(destCell && sourceCell, NS_ERROR_NULL_POINTER);
+
+  // Copy backgournd color to new cell
+  NS_NAMED_LITERAL_STRING(bgcolor, "bgcolor");
+  nsAutoString color;
+  bool isSet;
+  nsresult rv = GetAttributeValue(sourceCell, bgcolor, color, &isSet);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+  if (!isSet) {
+    return NS_OK;
+  }
+  return SetAttribute(destCell, bgcolor, color);
+}
+
+NS_IMETHODIMP
+HTMLEditor::SplitCellIntoColumns(nsIDOMElement* aTable,
+                                 int32_t aRowIndex,
+                                 int32_t aColIndex,
+                                 int32_t aColSpanLeft,
+                                 int32_t aColSpanRight,
+                                 nsIDOMElement** aNewCell)
+{
+  NS_ENSURE_TRUE(aTable, NS_ERROR_NULL_POINTER);
+  if (aNewCell) {
+    *aNewCell = nullptr;
+  }
+
+  nsCOMPtr<nsIDOMElement> cell;
+  int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
+  bool    isSelected;
+  nsresult rv =
+    GetCellDataAt(aTable, aRowIndex, aColIndex, getter_AddRefs(cell),
+                  &startRowIndex, &startColIndex,
+                  &rowSpan, &colSpan,
+                  &actualRowSpan, &actualColSpan, &isSelected);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(cell, NS_ERROR_NULL_POINTER);
+
+  // We can't split!
+  if (actualColSpan <= 1 || (aColSpanLeft + aColSpanRight) > actualColSpan) {
+    return NS_OK;
+  }
+
+  // Reduce colspan of cell to split
+  rv = SetColSpan(cell, aColSpanLeft);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Insert new cell after using the remaining span
+  //  and always get the new cell so we can copy the background color;
+  nsCOMPtr<nsIDOMElement> newCell;
+  rv = InsertCell(cell, actualRowSpan, aColSpanRight, true, false,
+                  getter_AddRefs(newCell));
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!newCell) {
+    return NS_OK;
+  }
+  if (aNewCell) {
+    NS_ADDREF(*aNewCell = newCell.get());
+  }
+  return CopyCellBackgroundColor(newCell, cell);
+}
+
+NS_IMETHODIMP
+HTMLEditor::SplitCellIntoRows(nsIDOMElement* aTable,
+                              int32_t aRowIndex,
+                              int32_t aColIndex,
+                              int32_t aRowSpanAbove,
+                              int32_t aRowSpanBelow,
+                              nsIDOMElement** aNewCell)
+{
+  NS_ENSURE_TRUE(aTable, NS_ERROR_NULL_POINTER);
+  if (aNewCell) *aNewCell = nullptr;
+
+  nsCOMPtr<nsIDOMElement> cell;
+  int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
+  bool    isSelected;
+  nsresult rv =
+    GetCellDataAt(aTable, aRowIndex, aColIndex, getter_AddRefs(cell),
+                  &startRowIndex, &startColIndex,
+                  &rowSpan, &colSpan,
+                  &actualRowSpan, &actualColSpan, &isSelected);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(cell, NS_ERROR_NULL_POINTER);
+
+  // We can't split!
+  if (actualRowSpan <= 1 || (aRowSpanAbove + aRowSpanBelow) > actualRowSpan) {
+    return NS_OK;
+  }
+
+  int32_t rowCount, colCount;
+  rv = GetTableSize(aTable, &rowCount, &colCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDOMElement> cell2;
+  nsCOMPtr<nsIDOMElement> lastCellFound;
+  int32_t startRowIndex2, startColIndex2, rowSpan2, colSpan2, actualRowSpan2, actualColSpan2;
+  bool    isSelected2;
+  int32_t colIndex = 0;
+  bool insertAfter = (startColIndex > 0);
+  // This is the row we will insert new cell into
+  int32_t rowBelowIndex = startRowIndex+aRowSpanAbove;
+
+  // Find a cell to insert before or after
+  for (;;) {
+    // Search for a cell to insert before
+    rv = GetCellDataAt(aTable, rowBelowIndex,
+                       colIndex, getter_AddRefs(cell2),
+                       &startRowIndex2, &startColIndex2, &rowSpan2, &colSpan2,
+                       &actualRowSpan2, &actualColSpan2, &isSelected2);
+    // If we fail here, it could be because row has bad rowspan values,
+    //   such as all cells having rowspan > 1 (Call FixRowSpan first!)
+    if (NS_FAILED(rv) || !cell) {
+      return NS_ERROR_FAILURE;
+    }
+
+    // Skip over cells spanned from above (like the one we are splitting!)
+    if (cell2 && startRowIndex2 == rowBelowIndex) {
+      if (!insertAfter) {
+        // Inserting before, so stop at first cell in row we want to insert
+        // into.
+        break;
+      }
+      // New cell isn't first in row,
+      // so stop after we find the cell just before new cell's column
+      if (startColIndex2 + actualColSpan2 == startColIndex) {
+        break;
+      }
+      // If cell found is AFTER desired new cell colum,
+      //  we have multiple cells with rowspan > 1 that
+      //  prevented us from finding a cell to insert after...
+      if (startColIndex2 > startColIndex) {
+        // ... so instead insert before the cell we found
+        insertAfter = false;
+        break;
+      }
+      lastCellFound = cell2;
+    }
+    // Skip to next available cellmap location
+    colIndex += std::max(actualColSpan2, 1);
+
+    // Done when past end of total number of columns
+    if (colIndex > colCount) {
+      break;
+    }
+  }
+
+  if (!cell2 && lastCellFound) {
+    // Edge case where we didn't find a cell to insert after
+    //  or before because column(s) before desired column
+    //  and all columns after it are spanned from above.
+    //  We can insert after the last cell we found
+    cell2 = lastCellFound;
+    insertAfter = true; // Should always be true, but let's be sure
+  }
+
+  // Reduce rowspan of cell to split
+  rv = SetRowSpan(cell, aRowSpanAbove);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+
+  // Insert new cell after using the remaining span
+  //  and always get the new cell so we can copy the background color;
+  nsCOMPtr<nsIDOMElement> newCell;
+  rv = InsertCell(cell2, aRowSpanBelow, actualColSpan, insertAfter, false,
+                  getter_AddRefs(newCell));
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!newCell) {
+    return NS_OK;
+  }
+  if (aNewCell) {
+    NS_ADDREF(*aNewCell = newCell.get());
+  }
+  return CopyCellBackgroundColor(newCell, cell2);
+}
+
+NS_IMETHODIMP
+HTMLEditor::SwitchTableCellHeaderType(nsIDOMElement* aSourceCell,
+                                      nsIDOMElement** aNewCell)
+{
+  nsCOMPtr<Element> sourceCell = do_QueryInterface(aSourceCell);
+  NS_ENSURE_TRUE(sourceCell, NS_ERROR_NULL_POINTER);
+
+  AutoEditBatch beginBatching(this);
+  // Prevent auto insertion of BR in new cell created by ReplaceContainer
+  AutoRules beginRulesSniffing(this, EditAction::insertNode, nsIEditor::eNext);
+
+  // Save current selection to restore when done
+  // This is needed so ReplaceContainer can monitor selection
+  //  when replacing nodes
+  RefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
+  AutoSelectionRestorer selectionRestorer(selection, this);
+
+  // Set to the opposite of current type
+  nsCOMPtr<nsIAtom> atom = EditorBase::GetTag(aSourceCell);
+  nsIAtom* newCellType = atom == nsGkAtoms::td ? nsGkAtoms::th : nsGkAtoms::td;
+
+  // This creates new node, moves children, copies attributes (true)
+  //   and manages the selection!
+  nsCOMPtr<Element> newNode = ReplaceContainer(sourceCell, newCellType,
+      nullptr, nullptr, EditorBase::eCloneAttributes);
+  NS_ENSURE_TRUE(newNode, NS_ERROR_FAILURE);
+
+  // Return the new cell
+  if (aNewCell) {
+    nsCOMPtr<nsIDOMElement> newElement = do_QueryInterface(newNode);
+    *aNewCell = newElement.get();
+    NS_ADDREF(*aNewCell);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::JoinTableCells(bool aMergeNonContiguousContents)
+{
+  nsCOMPtr<nsIDOMElement> table;
+  nsCOMPtr<nsIDOMElement> targetCell;
+  int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
+  bool    isSelected;
+  nsCOMPtr<nsIDOMElement> cell2;
+  int32_t startRowIndex2, startColIndex2, rowSpan2, colSpan2, actualRowSpan2, actualColSpan2;
+  bool    isSelected2;
+
+  // Get cell, table, etc. at selection anchor node
+  nsresult rv = GetCellContext(nullptr,
+                               getter_AddRefs(table),
+                               getter_AddRefs(targetCell),
+                               nullptr, nullptr,
+                               &startRowIndex, &startColIndex);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!table || !targetCell) {
+    return NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND;
+  }
+
+  AutoEditBatch beginBatching(this);
+  //Don't let Rules System change the selection
+  AutoTransactionsConserveSelection dontChangeSelection(this);
+
+  // Note: We dont' use AutoSelectionSetterAfterTableEdit here so the selection
+  //  is retained after joining. This leaves the target cell selected
+  //  as well as the "non-contiguous" cells, so user can see what happened.
+
+  nsCOMPtr<nsIDOMElement> firstCell;
+  int32_t firstRowIndex, firstColIndex;
+  rv = GetFirstSelectedCellInTable(&firstRowIndex, &firstColIndex,
+                                   getter_AddRefs(firstCell));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool joinSelectedCells = false;
+  if (firstCell) {
+    nsCOMPtr<nsIDOMElement> secondCell;
+    rv = GetNextSelectedCell(nullptr, getter_AddRefs(secondCell));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // If only one cell is selected, join with cell to the right
+    joinSelectedCells = (secondCell != nullptr);
+  }
+
+  if (joinSelectedCells) {
+    // We have selected cells: Join just contiguous cells
+    //  and just merge contents if not contiguous
+
+    int32_t rowCount, colCount;
+    rv = GetTableSize(table, &rowCount, &colCount);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Get spans for cell we will merge into
+    int32_t firstRowSpan, firstColSpan;
+    rv = GetCellSpansAt(table, firstRowIndex, firstColIndex,
+                        firstRowSpan, firstColSpan);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // This defines the last indexes along the "edges"
+    //  of the contiguous block of cells, telling us
+    //  that we can join adjacent cells to the block
+    // Start with same as the first values,
+    //  then expand as we find adjacent selected cells
+    int32_t lastRowIndex = firstRowIndex;
+    int32_t lastColIndex = firstColIndex;
+    int32_t rowIndex, colIndex;
+
+    // First pass: Determine boundaries of contiguous rectangular block
+    //  that we will join into one cell,
+    //  favoring adjacent cells in the same row
+    for (rowIndex = firstRowIndex; rowIndex <= lastRowIndex; rowIndex++) {
+      int32_t currentRowCount = rowCount;
+      // Be sure each row doesn't have rowspan errors
+      rv = FixBadRowSpan(table, rowIndex, rowCount);
+      NS_ENSURE_SUCCESS(rv, rv);
+      // Adjust rowcount by number of rows we removed
+      lastRowIndex -= (currentRowCount-rowCount);
+
+      bool cellFoundInRow = false;
+      bool lastRowIsSet = false;
+      int32_t lastColInRow = 0;
+      int32_t firstColInRow = firstColIndex;
+      for (colIndex = firstColIndex; colIndex < colCount;
+           colIndex += std::max(actualColSpan2, 1)) {
+        rv = GetCellDataAt(table, rowIndex, colIndex, getter_AddRefs(cell2),
+                           &startRowIndex2, &startColIndex2,
+                           &rowSpan2, &colSpan2,
+                           &actualRowSpan2, &actualColSpan2, &isSelected2);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        if (isSelected2) {
+          if (!cellFoundInRow) {
+            // We've just found the first selected cell in this row
+            firstColInRow = colIndex;
+          }
+          if (rowIndex > firstRowIndex && firstColInRow != firstColIndex) {
+            // We're in at least the second row,
+            // but left boundary is "ragged" (not the same as 1st row's start)
+            //Let's just end block on previous row
+            // and keep previous lastColIndex
+            //TODO: We could try to find the Maximum firstColInRow
+            //      so our block can still extend down more rows?
+            lastRowIndex = std::max(0,rowIndex - 1);
+            lastRowIsSet = true;
+            break;
+          }
+          // Save max selected column in this row, including extra colspan
+          lastColInRow = colIndex + (actualColSpan2-1);
+          cellFoundInRow = true;
+        } else if (cellFoundInRow) {
+          // No cell or not selected, but at least one cell in row was found
+          if (rowIndex > (firstRowIndex + 1) && colIndex <= lastColIndex) {
+            // Cell is in a column less than current right border in
+            //  the third or higher selected row, so stop block at the previous row
+            lastRowIndex = std::max(0,rowIndex - 1);
+            lastRowIsSet = true;
+          }
+          // We're done with this row
+          break;
+        }
+      } // End of column loop
+
+      // Done with this row
+      if (cellFoundInRow) {
+        if (rowIndex == firstRowIndex) {
+          // First row always initializes the right boundary
+          lastColIndex = lastColInRow;
+        }
+
+        // If we didn't determine last row above...
+        if (!lastRowIsSet) {
+          if (colIndex < lastColIndex) {
+            // (don't think we ever get here?)
+            // Cell is in a column less than current right boundary,
+            //  so stop block at the previous row
+            lastRowIndex = std::max(0,rowIndex - 1);
+          } else {
+            // Go on to examine next row
+            lastRowIndex = rowIndex+1;
+          }
+        }
+        // Use the minimum col we found so far for right boundary
+        lastColIndex = std::min(lastColIndex, lastColInRow);
+      } else {
+        // No selected cells in this row -- stop at row above
+        //  and leave last column at its previous value
+        lastRowIndex = std::max(0,rowIndex - 1);
+      }
+    }
+
+    // The list of cells we will delete after joining
+    nsTArray<nsCOMPtr<nsIDOMElement> > deleteList;
+
+    // 2nd pass: Do the joining and merging
+    for (rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+      for (colIndex = 0; colIndex < colCount;
+           colIndex += std::max(actualColSpan2, 1)) {
+        rv = GetCellDataAt(table, rowIndex, colIndex, getter_AddRefs(cell2),
+                           &startRowIndex2, &startColIndex2,
+                           &rowSpan2, &colSpan2,
+                           &actualRowSpan2, &actualColSpan2, &isSelected2);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        // If this is 0, we are past last cell in row, so exit the loop
+        if (!actualColSpan2) {
+          break;
+        }
+
+        // Merge only selected cells (skip cell we're merging into, of course)
+        if (isSelected2 && cell2 != firstCell) {
+          if (rowIndex >= firstRowIndex && rowIndex <= lastRowIndex &&
+              colIndex >= firstColIndex && colIndex <= lastColIndex) {
+            // We are within the join region
+            // Problem: It is very tricky to delete cells as we merge,
+            //  since that will upset the cellmap
+            //  Instead, build a list of cells to delete and do it later
+            NS_ASSERTION(startRowIndex2 == rowIndex, "JoinTableCells: StartRowIndex is in row above");
+
+            if (actualColSpan2 > 1) {
+              //Check if cell "hangs" off the boundary because of colspan > 1
+              //  Use split methods to chop off excess
+              int32_t extraColSpan = (startColIndex2 + actualColSpan2) - (lastColIndex+1);
+              if ( extraColSpan > 0) {
+                rv = SplitCellIntoColumns(table, startRowIndex2, startColIndex2,
+                                          actualColSpan2 - extraColSpan,
+                                          extraColSpan, nullptr);
+                NS_ENSURE_SUCCESS(rv, rv);
+              }
+            }
+
+            rv = MergeCells(firstCell, cell2, false);
+            NS_ENSURE_SUCCESS(rv, rv);
+
+            // Add cell to list to delete
+            deleteList.AppendElement(cell2.get());
+          } else if (aMergeNonContiguousContents) {
+            // Cell is outside join region -- just merge the contents
+            rv = MergeCells(firstCell, cell2, false);
+            NS_ENSURE_SUCCESS(rv, rv);
+          }
+        }
+      }
+    }
+
+    // All cell contents are merged. Delete the empty cells we accumulated
+    // Prevent rules testing until we're done
+    AutoRules beginRulesSniffing(this, EditAction::deleteNode,
+                                 nsIEditor::eNext);
+
+    for (uint32_t i = 0, n = deleteList.Length(); i < n; i++) {
+      nsIDOMElement *elementPtr = deleteList[i];
+      if (elementPtr) {
+        nsCOMPtr<nsIDOMNode> node = do_QueryInterface(elementPtr);
+        rv = DeleteNode(node);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+    }
+    // Cleanup selection: remove ranges where cells were deleted
+    RefPtr<Selection> selection = GetSelection();
+    NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
+
+    int32_t rangeCount;
+    rv = selection->GetRangeCount(&rangeCount);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    RefPtr<nsRange> range;
+    for (int32_t i = 0; i < rangeCount; i++) {
+      range = selection->GetRangeAt(i);
+      NS_ENSURE_TRUE(range, NS_ERROR_FAILURE);
+
+      nsCOMPtr<nsIDOMElement> deletedCell;
+      GetCellFromRange(range, getter_AddRefs(deletedCell));
+      if (!deletedCell) {
+        selection->RemoveRange(range);
+        rangeCount--;
+        i--;
+      }
+    }
+
+    // Set spans for the cell everthing merged into
+    rv = SetRowSpan(firstCell, lastRowIndex-firstRowIndex+1);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = SetColSpan(firstCell, lastColIndex-firstColIndex+1);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+
+    // Fixup disturbances in table layout
+    NormalizeTable(table);
+  } else {
+    // Joining with cell to the right -- get rowspan and colspan data of target cell
+    rv = GetCellDataAt(table, startRowIndex, startColIndex,
+                       getter_AddRefs(targetCell),
+                       &startRowIndex, &startColIndex, &rowSpan, &colSpan,
+                       &actualRowSpan, &actualColSpan, &isSelected);
+    NS_ENSURE_SUCCESS(rv, rv);
+    NS_ENSURE_TRUE(targetCell, NS_ERROR_NULL_POINTER);
+
+    // Get data for cell to the right
+    rv = GetCellDataAt(table, startRowIndex, startColIndex + actualColSpan,
+                       getter_AddRefs(cell2),
+                       &startRowIndex2, &startColIndex2, &rowSpan2, &colSpan2,
+                       &actualRowSpan2, &actualColSpan2, &isSelected2);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!cell2) {
+      return NS_OK; // Don't fail if there's no cell
+    }
+
+    // sanity check
+    NS_ASSERTION((startRowIndex >= startRowIndex2),"JoinCells: startRowIndex < startRowIndex2");
+
+    // Figure out span of merged cell starting from target's starting row
+    // to handle case of merged cell starting in a row above
+    int32_t spanAboveMergedCell = startRowIndex - startRowIndex2;
+    int32_t effectiveRowSpan2 = actualRowSpan2 - spanAboveMergedCell;
+
+    if (effectiveRowSpan2 > actualRowSpan) {
+      // Cell to the right spans into row below target
+      // Split off portion below target cell's bottom-most row
+      rv = SplitCellIntoRows(table, startRowIndex2, startColIndex2,
+                             spanAboveMergedCell+actualRowSpan,
+                             effectiveRowSpan2-actualRowSpan, nullptr);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    // Move contents from cell to the right
+    // Delete the cell now only if it starts in the same row
+    //   and has enough row "height"
+    rv = MergeCells(targetCell, cell2,
+                    (startRowIndex2 == startRowIndex) &&
+                    (effectiveRowSpan2 >= actualRowSpan));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (effectiveRowSpan2 < actualRowSpan) {
+      // Merged cell is "shorter"
+      // (there are cells(s) below it that are row-spanned by target cell)
+      // We could try splitting those cells, but that's REAL messy,
+      //  so the safest thing to do is NOT really join the cells
+      return NS_OK;
+    }
+
+    if (spanAboveMergedCell > 0) {
+      // Cell we merged started in a row above the target cell
+      // Reduce rowspan to give room where target cell will extend its colspan
+      rv = SetRowSpan(cell2, spanAboveMergedCell);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    // Reset target cell's colspan to encompass cell to the right
+    rv = SetColSpan(targetCell, actualColSpan+actualColSpan2);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::MergeCells(nsCOMPtr<nsIDOMElement> aTargetCell,
+                       nsCOMPtr<nsIDOMElement> aCellToMerge,
+                       bool aDeleteCellToMerge)
+{
+  nsCOMPtr<dom::Element> targetCell = do_QueryInterface(aTargetCell);
+  nsCOMPtr<dom::Element> cellToMerge = do_QueryInterface(aCellToMerge);
+  NS_ENSURE_TRUE(targetCell && cellToMerge, NS_ERROR_NULL_POINTER);
+
+  // Prevent rules testing until we're done
+  AutoRules beginRulesSniffing(this, EditAction::deleteNode, nsIEditor::eNext);
+
+  // Don't need to merge if cell is empty
+  if (!IsEmptyCell(cellToMerge)) {
+    // Get index of last child in target cell
+    // If we fail or don't have children,
+    //  we insert at index 0
+    int32_t insertIndex = 0;
+
+    // Start inserting just after last child
+    uint32_t len = targetCell->GetChildCount();
+    if (len == 1 && IsEmptyCell(targetCell)) {
+      // Delete the empty node
+      nsIContent* cellChild = targetCell->GetFirstChild();
+      nsresult rv = DeleteNode(cellChild->AsDOMNode());
+      NS_ENSURE_SUCCESS(rv, rv);
+      insertIndex = 0;
+    } else {
+      insertIndex = (int32_t)len;
+    }
+
+    // Move the contents
+    while (cellToMerge->HasChildren()) {
+      nsCOMPtr<nsIDOMNode> cellChild = cellToMerge->GetLastChild()->AsDOMNode();
+      nsresult rv = DeleteNode(cellChild);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = InsertNode(cellChild, aTargetCell, insertIndex);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+
+  // Delete cells whose contents were moved
+  if (aDeleteCellToMerge) {
+    return DeleteNode(aCellToMerge);
+  }
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+HTMLEditor::FixBadRowSpan(nsIDOMElement* aTable,
+                          int32_t aRowIndex,
+                          int32_t& aNewRowCount)
+{
+  NS_ENSURE_TRUE(aTable, NS_ERROR_NULL_POINTER);
+
+  int32_t rowCount, colCount;
+  nsresult rv = GetTableSize(aTable, &rowCount, &colCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDOMElement>cell;
+  int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
+  bool    isSelected;
+
+  int32_t minRowSpan = -1;
+  int32_t colIndex;
+
+  for (colIndex = 0; colIndex < colCount;
+       colIndex += std::max(actualColSpan, 1)) {
+    rv = GetCellDataAt(aTable, aRowIndex, colIndex, getter_AddRefs(cell),
+                       &startRowIndex, &startColIndex, &rowSpan, &colSpan,
+                       &actualRowSpan, &actualColSpan, &isSelected);
+    // NOTE: This is a *real* failure.
+    // GetCellDataAt passes if cell is missing from cellmap
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+    if (!cell) {
+      break;
+    }
+    if (rowSpan > 0 &&
+        startRowIndex == aRowIndex &&
+        (rowSpan < minRowSpan || minRowSpan == -1)) {
+      minRowSpan = rowSpan;
+    }
+    NS_ASSERTION((actualColSpan > 0),"ActualColSpan = 0 in FixBadRowSpan");
+  }
+  if (minRowSpan > 1) {
+    // The amount to reduce everyone's rowspan
+    // so at least one cell has rowspan = 1
+    int32_t rowsReduced = minRowSpan - 1;
+    for (colIndex = 0; colIndex < colCount;
+         colIndex += std::max(actualColSpan, 1)) {
+      rv = GetCellDataAt(aTable, aRowIndex, colIndex, getter_AddRefs(cell),
+                         &startRowIndex, &startColIndex, &rowSpan, &colSpan,
+                         &actualRowSpan, &actualColSpan, &isSelected);
+      if (NS_FAILED(rv)) {
+        return rv;
+      }
+      // Fixup rowspans only for cells starting in current row
+      if (cell && rowSpan > 0 &&
+          startRowIndex == aRowIndex &&
+          startColIndex ==  colIndex ) {
+        rv = SetRowSpan(cell, rowSpan-rowsReduced);
+        if (NS_FAILED(rv)) {
+          return rv;
+        }
+      }
+      NS_ASSERTION((actualColSpan > 0),"ActualColSpan = 0 in FixBadRowSpan");
+    }
+  }
+  return GetTableSize(aTable, &aNewRowCount, &colCount);
+}
+
+NS_IMETHODIMP
+HTMLEditor::FixBadColSpan(nsIDOMElement* aTable,
+                          int32_t aColIndex,
+                          int32_t& aNewColCount)
+{
+  NS_ENSURE_TRUE(aTable, NS_ERROR_NULL_POINTER);
+
+  int32_t rowCount, colCount;
+  nsresult rv = GetTableSize(aTable, &rowCount, &colCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDOMElement> cell;
+  int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
+  bool    isSelected;
+
+  int32_t minColSpan = -1;
+  int32_t rowIndex;
+
+  for (rowIndex = 0; rowIndex < rowCount;
+       rowIndex += std::max(actualRowSpan, 1)) {
+    rv = GetCellDataAt(aTable, rowIndex, aColIndex, getter_AddRefs(cell),
+                       &startRowIndex, &startColIndex, &rowSpan, &colSpan,
+                       &actualRowSpan, &actualColSpan, &isSelected);
+    // NOTE: This is a *real* failure.
+    // GetCellDataAt passes if cell is missing from cellmap
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+    if (!cell) {
+      break;
+    }
+    if (colSpan > 0 &&
+        startColIndex == aColIndex &&
+        (colSpan < minColSpan || minColSpan == -1)) {
+      minColSpan = colSpan;
+    }
+    NS_ASSERTION((actualRowSpan > 0),"ActualRowSpan = 0 in FixBadColSpan");
+  }
+  if (minColSpan > 1) {
+    // The amount to reduce everyone's colspan
+    // so at least one cell has colspan = 1
+    int32_t colsReduced = minColSpan - 1;
+    for (rowIndex = 0; rowIndex < rowCount;
+         rowIndex += std::max(actualRowSpan, 1)) {
+      rv = GetCellDataAt(aTable, rowIndex, aColIndex, getter_AddRefs(cell),
+                         &startRowIndex, &startColIndex, &rowSpan, &colSpan,
+                         &actualRowSpan, &actualColSpan, &isSelected);
+      if (NS_FAILED(rv)) {
+        return rv;
+      }
+      // Fixup colspans only for cells starting in current column
+      if (cell && colSpan > 0 &&
+          startColIndex == aColIndex &&
+          startRowIndex ==  rowIndex) {
+        rv = SetColSpan(cell, colSpan-colsReduced);
+        if (NS_FAILED(rv)) {
+          return rv;
+        }
+      }
+      NS_ASSERTION((actualRowSpan > 0),"ActualRowSpan = 0 in FixBadColSpan");
+    }
+  }
+  return GetTableSize(aTable, &rowCount, &aNewColCount);
+}
+
+NS_IMETHODIMP
+HTMLEditor::NormalizeTable(nsIDOMElement* aTable)
+{
+  RefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsIDOMElement> table;
+  nsresult rv = GetElementOrParentByTagName(NS_LITERAL_STRING("table"),
+                                            aTable, getter_AddRefs(table));
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Don't fail if we didn't find a table
+  NS_ENSURE_TRUE(table, NS_OK);
+
+  int32_t rowCount, colCount, rowIndex, colIndex;
+  rv = GetTableSize(table, &rowCount, &colCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Save current selection
+  AutoSelectionRestorer selectionRestorer(selection, this);
+
+  AutoEditBatch beginBatching(this);
+  // Prevent auto insertion of BR in new cell until we're done
+  AutoRules beginRulesSniffing(this, EditAction::insertNode, nsIEditor::eNext);
+
+  nsCOMPtr<nsIDOMElement> cell;
+  int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
+  bool    isSelected;
+
+  // Scan all cells in each row to detect bad rowspan values
+  for (rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+    rv = FixBadRowSpan(table, rowIndex, rowCount);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  // and same for colspans
+  for (colIndex = 0; colIndex < colCount; colIndex++) {
+    rv = FixBadColSpan(table, colIndex, colCount);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // Fill in missing cellmap locations with empty cells
+  for (rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+    nsCOMPtr<nsIDOMElement> previousCellInRow;
+    for (colIndex = 0; colIndex < colCount; colIndex++) {
+      rv = GetCellDataAt(table, rowIndex, colIndex, getter_AddRefs(cell),
+                         &startRowIndex, &startColIndex, &rowSpan, &colSpan,
+                         &actualRowSpan, &actualColSpan, &isSelected);
+      // NOTE: This is a *real* failure.
+      // GetCellDataAt passes if cell is missing from cellmap
+      if (NS_FAILED(rv)) {
+        return rv;
+      }
+      if (!cell) {
+        //We are missing a cell at a cellmap location
+#ifdef DEBUG
+        printf("NormalizeTable found missing cell at row=%d, col=%d\n",
+               rowIndex, colIndex);
+#endif
+        // Add a cell after the previous Cell in the current row
+        if (!previousCellInRow) {
+          // We don't have any cells in this row -- We are really messed up!
+#ifdef DEBUG
+          printf("NormalizeTable found no cells in row=%d, col=%d\n",
+                 rowIndex, colIndex);
+#endif
+          return NS_ERROR_FAILURE;
+        }
+
+        // Insert a new cell after (true), and return the new cell to us
+        rv = InsertCell(previousCellInRow, 1, 1, true, false,
+                        getter_AddRefs(cell));
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        // Set this so we use returned new "cell" to set previousCellInRow below
+        if (cell) {
+          startRowIndex = rowIndex;
+        }
+      }
+      // Save the last cell found in the same row we are scanning
+      if (startRowIndex == rowIndex) {
+        previousCellInRow = cell;
+      }
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::GetCellIndexes(nsIDOMElement* aCell,
+                           int32_t* aRowIndex,
+                           int32_t* aColIndex)
+{
+  NS_ENSURE_ARG_POINTER(aRowIndex);
+  *aColIndex=0; // initialize out params
+  NS_ENSURE_ARG_POINTER(aColIndex);
+  *aRowIndex=0;
+  if (!aCell) {
+    // Get the selected cell or the cell enclosing the selection anchor
+    nsCOMPtr<nsIDOMElement> cell;
+    nsresult rv = GetElementOrParentByTagName(NS_LITERAL_STRING("td"), nullptr,
+                                              getter_AddRefs(cell));
+    if (NS_FAILED(rv) || !cell) {
+      return NS_ERROR_FAILURE;
+    }
+    aCell = cell;
+  }
+
+  NS_ENSURE_TRUE(mDocWeak, NS_ERROR_NOT_INITIALIZED);
+  nsCOMPtr<nsIPresShell> ps = GetPresShell();
+  NS_ENSURE_TRUE(ps, NS_ERROR_NOT_INITIALIZED);
+
+  nsCOMPtr<nsIContent> nodeAsContent( do_QueryInterface(aCell) );
+  NS_ENSURE_TRUE(nodeAsContent, NS_ERROR_FAILURE);
+  // frames are not ref counted, so don't use an nsCOMPtr
+  nsIFrame *layoutObject = nodeAsContent->GetPrimaryFrame();
+  NS_ENSURE_TRUE(layoutObject, NS_ERROR_FAILURE);
+
+  nsITableCellLayout *cellLayoutObject = do_QueryFrame(layoutObject);
+  NS_ENSURE_TRUE(cellLayoutObject, NS_ERROR_FAILURE);
+  return cellLayoutObject->GetCellIndexes(*aRowIndex, *aColIndex);
+}
+
+nsTableWrapperFrame*
+HTMLEditor::GetTableFrame(nsIDOMElement* aTable)
+{
+  NS_ENSURE_TRUE(aTable, nullptr);
+
+  nsCOMPtr<nsIContent> nodeAsContent( do_QueryInterface(aTable) );
+  NS_ENSURE_TRUE(nodeAsContent, nullptr);
+  return do_QueryFrame(nodeAsContent->GetPrimaryFrame());
+}
+
+//Return actual number of cells (a cell with colspan > 1 counts as just 1)
+int32_t
+HTMLEditor::GetNumberOfCellsInRow(nsIDOMElement* aTable,
+                                  int32_t rowIndex)
+{
+  int32_t cellCount = 0;
+  nsCOMPtr<nsIDOMElement> cell;
+  int32_t colIndex = 0;
+  do {
+    int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
+    bool    isSelected;
+    nsresult rv =
+      GetCellDataAt(aTable, rowIndex, colIndex, getter_AddRefs(cell),
+                    &startRowIndex, &startColIndex, &rowSpan, &colSpan,
+                    &actualRowSpan, &actualColSpan, &isSelected);
+    NS_ENSURE_SUCCESS(rv, 0);
+    if (cell) {
+      // Only count cells that start in row we are working with
+      if (startRowIndex == rowIndex) {
+        cellCount++;
+      }
+      //Next possible location for a cell
+      colIndex += actualColSpan;
+    } else {
+      colIndex++;
+    }
+  } while (cell);
+
+  return cellCount;
+}
+
+NS_IMETHODIMP
+HTMLEditor::GetTableSize(nsIDOMElement* aTable,
+                         int32_t* aRowCount,
+                         int32_t* aColCount)
+{
+  NS_ENSURE_ARG_POINTER(aRowCount);
+  NS_ENSURE_ARG_POINTER(aColCount);
+  *aRowCount = 0;
+  *aColCount = 0;
+  nsCOMPtr<nsIDOMElement> table;
+  // Get the selected talbe or the table enclosing the selection anchor
+  nsresult rv = GetElementOrParentByTagName(NS_LITERAL_STRING("table"), aTable,
+                                            getter_AddRefs(table));
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(table, NS_ERROR_FAILURE);
+
+  nsTableWrapperFrame* tableFrame = GetTableFrame(table.get());
+  NS_ENSURE_TRUE(tableFrame, NS_ERROR_FAILURE);
+
+  *aRowCount = tableFrame->GetRowCount();
+  *aColCount = tableFrame->GetColCount();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::GetCellDataAt(nsIDOMElement* aTable,
+                          int32_t aRowIndex,
+                          int32_t aColIndex,
+                          nsIDOMElement** aCell,
+                          int32_t* aStartRowIndex,
+                          int32_t* aStartColIndex,
+                          int32_t* aRowSpan,
+                          int32_t* aColSpan,
+                          int32_t* aActualRowSpan,
+                          int32_t* aActualColSpan,
+                          bool* aIsSelected)
+{
+  NS_ENSURE_ARG_POINTER(aStartRowIndex);
+  NS_ENSURE_ARG_POINTER(aStartColIndex);
+  NS_ENSURE_ARG_POINTER(aRowSpan);
+  NS_ENSURE_ARG_POINTER(aColSpan);
+  NS_ENSURE_ARG_POINTER(aActualRowSpan);
+  NS_ENSURE_ARG_POINTER(aActualColSpan);
+  NS_ENSURE_ARG_POINTER(aIsSelected);
+  NS_ENSURE_TRUE(aCell, NS_ERROR_NULL_POINTER);
+
+  *aStartRowIndex = 0;
+  *aStartColIndex = 0;
+  *aRowSpan = 0;
+  *aColSpan = 0;
+  *aActualRowSpan = 0;
+  *aActualColSpan = 0;
+  *aIsSelected = false;
+
+  *aCell = nullptr;
+
+  if (!aTable) {
+    // Get the selected table or the table enclosing the selection anchor
+    nsCOMPtr<nsIDOMElement> table;
+    nsresult rv =
+      GetElementOrParentByTagName(NS_LITERAL_STRING("table"), nullptr,
+                                  getter_AddRefs(table));
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!table) {
+      return NS_ERROR_FAILURE;
+    }
+    aTable = table;
+  }
+
+  nsTableWrapperFrame* tableFrame = GetTableFrame(aTable);
+  NS_ENSURE_TRUE(tableFrame, NS_ERROR_FAILURE);
+
+  nsTableCellFrame* cellFrame =
+    tableFrame->GetCellFrameAt(aRowIndex, aColIndex);
+  if (!cellFrame) {
+    return NS_ERROR_FAILURE;
+  }
+
+  *aIsSelected = cellFrame->IsSelected();
+  cellFrame->GetRowIndex(*aStartRowIndex);
+  cellFrame->GetColIndex(*aStartColIndex);
+  *aRowSpan = cellFrame->GetRowSpan();
+  *aColSpan = cellFrame->GetColSpan();
+  *aActualRowSpan = tableFrame->GetEffectiveRowSpanAt(aRowIndex, aColIndex);
+  *aActualColSpan = tableFrame->GetEffectiveColSpanAt(aRowIndex, aColIndex);
+  nsCOMPtr<nsIDOMElement> domCell = do_QueryInterface(cellFrame->GetContent());
+  domCell.forget(aCell);
+
+  return NS_OK;
+}
+
+// When all you want is the cell
+NS_IMETHODIMP
+HTMLEditor::GetCellAt(nsIDOMElement* aTable,
+                      int32_t aRowIndex,
+                      int32_t aColIndex,
+                      nsIDOMElement** aCell)
+{
+  NS_ENSURE_ARG_POINTER(aCell);
+  *aCell = nullptr;
+
+  if (!aTable) {
+    // Get the selected table or the table enclosing the selection anchor
+    nsCOMPtr<nsIDOMElement> table;
+    nsresult rv =
+      GetElementOrParentByTagName(NS_LITERAL_STRING("table"), nullptr,
+                                  getter_AddRefs(table));
+    NS_ENSURE_SUCCESS(rv, rv);
+    NS_ENSURE_TRUE(table, NS_ERROR_FAILURE);
+    aTable = table;
+  }
+
+  nsTableWrapperFrame* tableFrame = GetTableFrame(aTable);
+  if (!tableFrame) {
+    *aCell = nullptr;
+    return NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND;
+  }
+
+  nsCOMPtr<nsIDOMElement> domCell =
+    do_QueryInterface(tableFrame->GetCellAt(aRowIndex, aColIndex));
+  domCell.forget(aCell);
+
+  return NS_OK;
+}
+
+// When all you want are the rowspan and colspan (not exposed in nsITableEditor)
+NS_IMETHODIMP
+HTMLEditor::GetCellSpansAt(nsIDOMElement* aTable,
+                           int32_t aRowIndex,
+                           int32_t aColIndex,
+                           int32_t& aActualRowSpan,
+                           int32_t& aActualColSpan)
+{
+  nsTableWrapperFrame* tableFrame = GetTableFrame(aTable);
+  if (!tableFrame) {
+    return NS_ERROR_FAILURE;
+  }
+  aActualRowSpan = tableFrame->GetEffectiveRowSpanAt(aRowIndex, aColIndex);
+  aActualColSpan = tableFrame->GetEffectiveColSpanAt(aRowIndex, aColIndex);
+
+  return NS_OK;
+}
+
+nsresult
+HTMLEditor::GetCellContext(Selection** aSelection,
+                           nsIDOMElement** aTable,
+                           nsIDOMElement** aCell,
+                           nsIDOMNode** aCellParent,
+                           int32_t* aCellOffset,
+                           int32_t* aRowIndex,
+                           int32_t* aColIndex)
+{
+  // Initialize return pointers
+  if (aSelection) {
+    *aSelection = nullptr;
+  }
+  if (aTable) {
+    *aTable = nullptr;
+  }
+  if (aCell) {
+    *aCell = nullptr;
+  }
+  if (aCellParent) {
+    *aCellParent = nullptr;
+  }
+  if (aCellOffset) {
+    *aCellOffset = 0;
+  }
+  if (aRowIndex) {
+    *aRowIndex = 0;
+  }
+  if (aColIndex) {
+    *aColIndex = 0;
+  }
+
+  RefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
+
+  if (aSelection) {
+    *aSelection = selection.get();
+    NS_ADDREF(*aSelection);
+  }
+  nsCOMPtr <nsIDOMElement> table;
+  nsCOMPtr <nsIDOMElement> cell;
+
+  // Caller may supply the cell...
+  if (aCell && *aCell) {
+    cell = *aCell;
+  }
+
+  // ...but if not supplied,
+  //    get cell if it's the child of selection anchor node,
+  //    or get the enclosing by a cell
+  if (!cell) {
+    // Find a selected or enclosing table element
+    nsCOMPtr<nsIDOMElement> cellOrTableElement;
+    int32_t selectedCount;
+    nsAutoString tagName;
+    nsresult rv =
+      GetSelectedOrParentTableElement(tagName, &selectedCount,
+                                      getter_AddRefs(cellOrTableElement));
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (tagName.EqualsLiteral("table")) {
+      // We have a selected table, not a cell
+      if (aTable) {
+        *aTable = cellOrTableElement.get();
+        NS_ADDREF(*aTable);
+      }
+      return NS_OK;
+    }
+    if (!tagName.EqualsLiteral("td")) {
+      return NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND;
+    }
+
+    // We found a cell
+    cell = cellOrTableElement;
+  }
+  if (aCell) {
+    *aCell = cell.get();
+    NS_ADDREF(*aCell);
+  }
+
+  // Get containing table
+  nsresult rv = GetElementOrParentByTagName(NS_LITERAL_STRING("table"), cell,
+                                            getter_AddRefs(table));
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Cell must be in a table, so fail if not found
+  NS_ENSURE_TRUE(table, NS_ERROR_FAILURE);
+  if (aTable) {
+    *aTable = table.get();
+    NS_ADDREF(*aTable);
+  }
+
+  // Get the rest of the related data only if requested
+  if (aRowIndex || aColIndex) {
+    int32_t rowIndex, colIndex;
+    // Get current cell location so we can put caret back there when done
+    rv = GetCellIndexes(cell, &rowIndex, &colIndex);
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+    if (aRowIndex) {
+      *aRowIndex = rowIndex;
+    }
+    if (aColIndex) {
+      *aColIndex = colIndex;
+    }
+  }
+  if (aCellParent) {
+    nsCOMPtr <nsIDOMNode> cellParent;
+    // Get the immediate parent of the cell
+    rv = cell->GetParentNode(getter_AddRefs(cellParent));
+    NS_ENSURE_SUCCESS(rv, rv);
+    // Cell has to have a parent, so fail if not found
+    NS_ENSURE_TRUE(cellParent, NS_ERROR_FAILURE);
+
+    *aCellParent = cellParent.get();
+    NS_ADDREF(*aCellParent);
+
+    if (aCellOffset) {
+      *aCellOffset = GetChildOffset(cell, cellParent);
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult
+HTMLEditor::GetCellFromRange(nsRange* aRange,
+                             nsIDOMElement** aCell)
+{
+  // Note: this might return a node that is outside of the range.
+  // Use carefully.
+  NS_ENSURE_TRUE(aRange && aCell, NS_ERROR_NULL_POINTER);
+
+  *aCell = nullptr;
+
+  nsCOMPtr<nsIDOMNode> startParent;
+  nsresult rv = aRange->GetStartContainer(getter_AddRefs(startParent));
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(startParent, NS_ERROR_FAILURE);
+
+  int32_t startOffset;
+  rv = aRange->GetStartOffset(&startOffset);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDOMNode> childNode = GetChildAt(startParent, startOffset);
+  // This means selection is probably at a text node (or end of doc?)
+  if (!childNode) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIDOMNode> endParent;
+  rv = aRange->GetEndContainer(getter_AddRefs(endParent));
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(startParent, NS_ERROR_FAILURE);
+
+  int32_t endOffset;
+  rv = aRange->GetEndOffset(&endOffset);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // If a cell is deleted, the range is collapse
+  //   (startOffset == endOffset)
+  //   so tell caller the cell wasn't found
+  if (startParent == endParent &&
+      endOffset == startOffset+1 &&
+      HTMLEditUtils::IsTableCell(childNode)) {
+    // Should we also test if frame is selected? (Use GetCellDataAt())
+    // (Let's not for now -- more efficient)
+    nsCOMPtr<nsIDOMElement> cellElement = do_QueryInterface(childNode);
+    *aCell = cellElement.get();
+    NS_ADDREF(*aCell);
+    return NS_OK;
+  }
+  return NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND;
+}
+
+NS_IMETHODIMP
+HTMLEditor::GetFirstSelectedCell(nsIDOMRange** aRange,
+                                 nsIDOMElement** aCell)
+{
+  NS_ENSURE_TRUE(aCell, NS_ERROR_NULL_POINTER);
+  *aCell = nullptr;
+  if (aRange) {
+    *aRange = nullptr;
+  }
+
+  RefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
+
+  RefPtr<nsRange> range = selection->GetRangeAt(0);
+  NS_ENSURE_TRUE(range, NS_ERROR_FAILURE);
+
+  mSelectedCellIndex = 0;
+
+  nsresult rv = GetCellFromRange(range, aCell);
+  // Failure here probably means selection is in a text node,
+  //  so there's no selected cell
+  if (NS_FAILED(rv)) {
+    return NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND;
+  }
+  // No cell means range was collapsed (cell was deleted)
+  if (!*aCell) {
+    return NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND;
+  }
+
+  if (aRange) {
+    *aRange = range.get();
+    NS_ADDREF(*aRange);
+  }
+
+  // Setup for next cell
+  mSelectedCellIndex = 1;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::GetNextSelectedCell(nsIDOMRange** aRange,
+                                nsIDOMElement** aCell)
+{
+  NS_ENSURE_TRUE(aCell, NS_ERROR_NULL_POINTER);
+  *aCell = nullptr;
+  if (aRange) {
+    *aRange = nullptr;
+  }
+
+  RefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
+
+  int32_t rangeCount = selection->RangeCount();
+
+  // Don't even try if index exceeds range count
+  if (mSelectedCellIndex >= rangeCount) {
+    return NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND;
+  }
+
+  // Scan through ranges to find next valid selected cell
+  RefPtr<nsRange> range;
+  for (; mSelectedCellIndex < rangeCount; mSelectedCellIndex++) {
+    range = selection->GetRangeAt(mSelectedCellIndex);
+    NS_ENSURE_TRUE(range, NS_ERROR_FAILURE);
+
+    nsresult rv = GetCellFromRange(range, aCell);
+    // Failure here means the range doesn't contain a cell
+    NS_ENSURE_SUCCESS(rv, NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND);
+
+    // We found a selected cell
+    if (*aCell) {
+      break;
+    }
+
+    // If we didn't find a cell, continue to next range in selection
+  }
+  // No cell means all remaining ranges were collapsed (cells were deleted)
+  NS_ENSURE_TRUE(*aCell, NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND);
+
+  if (aRange) {
+    *aRange = range.get();
+    NS_ADDREF(*aRange);
+  }
+
+  // Setup for next cell
+  mSelectedCellIndex++;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::GetFirstSelectedCellInTable(int32_t* aRowIndex,
+                                        int32_t* aColIndex,
+                                        nsIDOMElement** aCell)
+{
+  NS_ENSURE_TRUE(aCell, NS_ERROR_NULL_POINTER);
+  *aCell = nullptr;
+  if (aRowIndex) {
+    *aRowIndex = 0;
+  }
+  if (aColIndex) {
+    *aColIndex = 0;
+  }
+
+  nsCOMPtr<nsIDOMElement> cell;
+  nsresult rv = GetFirstSelectedCell(nullptr, getter_AddRefs(cell));
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(cell, NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND);
+
+  *aCell = cell.get();
+  NS_ADDREF(*aCell);
+
+  // Also return the row and/or column if requested
+  if (aRowIndex || aColIndex) {
+    int32_t startRowIndex, startColIndex;
+    rv = GetCellIndexes(cell, &startRowIndex, &startColIndex);
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+
+    if (aRowIndex) {
+      *aRowIndex = startRowIndex;
+    }
+    if (aColIndex) {
+      *aColIndex = startColIndex;
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::SetSelectionAfterTableEdit(nsIDOMElement* aTable,
+                                       int32_t aRow,
+                                       int32_t aCol,
+                                       int32_t aDirection,
+                                       bool aSelected)
+{
+  NS_ENSURE_TRUE(aTable, NS_ERROR_NOT_INITIALIZED);
+
+  RefPtr<Selection> selection = GetSelection();
+
+  if (!selection) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIDOMElement> cell;
+  bool done = false;
+  do {
+    nsresult rv = GetCellAt(aTable, aRow, aCol, getter_AddRefs(cell));
+    if (NS_FAILED(rv)) {
+      break;
+    }
+
+    if (cell) {
+      if (aSelected) {
+        // Reselect the cell
+        return SelectElement(cell);
+      } else {
+        // Set the caret to deepest first child
+        //   but don't go into nested tables
+        // TODO: Should we really be placing the caret at the END
+        //  of the cell content?
+        nsCOMPtr<nsINode> cellNode = do_QueryInterface(cell);
+        if (cellNode) {
+          CollapseSelectionToDeepestNonTableFirstChild(selection, cellNode);
+        }
+        return NS_OK;
+      }
+    } else {
+      // Setup index to find another cell in the
+      //   direction requested, but move in
+      //   other direction if already at beginning of row or column
+      switch (aDirection) {
+        case ePreviousColumn:
+          if (!aCol) {
+            if (aRow > 0) {
+              aRow--;
+            } else {
+              done = true;
+            }
+          } else {
+            aCol--;
+          }
+          break;
+        case ePreviousRow:
+          if (!aRow) {
+            if (aCol > 0) {
+              aCol--;
+            } else {
+              done = true;
+            }
+          } else {
+            aRow--;
+          }
+          break;
+        default:
+          done = true;
+      }
+    }
+  } while (!done);
+
+  // We didn't find a cell
+  // Set selection to just before the table
+  nsCOMPtr<nsIDOMNode> tableParent;
+  nsresult rv = aTable->GetParentNode(getter_AddRefs(tableParent));
+  if (NS_SUCCEEDED(rv) && tableParent) {
+    int32_t tableOffset = GetChildOffset(aTable, tableParent);
+    return selection->Collapse(tableParent, tableOffset);
+  }
+  // Last resort: Set selection to start of doc
+  // (it's very bad to not have a valid selection!)
+  return SetSelectionAtDocumentStart(selection);
+}
+
+NS_IMETHODIMP
+HTMLEditor::GetSelectedOrParentTableElement(nsAString& aTagName,
+                                            int32_t* aSelectedCount,
+                                            nsIDOMElement** aTableElement)
+{
+  NS_ENSURE_ARG_POINTER(aTableElement);
+  NS_ENSURE_ARG_POINTER(aSelectedCount);
+  *aTableElement = nullptr;
+  aTagName.Truncate();
+  *aSelectedCount = 0;
+
+  RefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
+
+  // Try to get the first selected cell
+  nsCOMPtr<nsIDOMElement> tableOrCellElement;
+  nsresult rv = GetFirstSelectedCell(nullptr,
+                                     getter_AddRefs(tableOrCellElement));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_NAMED_LITERAL_STRING(tdName, "td");
+
+  if (tableOrCellElement) {
+      // Each cell is in its own selection range,
+      //  so count signals multiple-cell selection
+      rv = selection->GetRangeCount(aSelectedCount);
+      NS_ENSURE_SUCCESS(rv, rv);
+      aTagName = tdName;
+  } else {
+    nsCOMPtr<nsIDOMNode> anchorNode;
+    rv = selection->GetAnchorNode(getter_AddRefs(anchorNode));
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+    NS_ENSURE_TRUE(anchorNode, NS_ERROR_FAILURE);
+
+    nsCOMPtr<nsIDOMNode> selectedNode;
+
+    // Get child of anchor node, if exists
+    bool hasChildren;
+    anchorNode->HasChildNodes(&hasChildren);
+
+    if (hasChildren) {
+      int32_t anchorOffset;
+      rv = selection->GetAnchorOffset(&anchorOffset);
+      NS_ENSURE_SUCCESS(rv, rv);
+      selectedNode = GetChildAt(anchorNode, anchorOffset);
+      if (!selectedNode) {
+        selectedNode = anchorNode;
+        // If anchor doesn't have a child, we can't be selecting a table element,
+        //  so don't do the following:
+      } else {
+        nsCOMPtr<nsIAtom> atom = EditorBase::GetTag(selectedNode);
+
+        if (atom == nsGkAtoms::td) {
+          tableOrCellElement = do_QueryInterface(selectedNode);
+          aTagName = tdName;
+          // Each cell is in its own selection range,
+          //  so count signals multiple-cell selection
+          rv = selection->GetRangeCount(aSelectedCount);
+          NS_ENSURE_SUCCESS(rv, rv);
+        } else if (atom == nsGkAtoms::table) {
+          tableOrCellElement = do_QueryInterface(selectedNode);
+          aTagName.AssignLiteral("table");
+          *aSelectedCount = 1;
+        } else if (atom == nsGkAtoms::tr) {
+          tableOrCellElement = do_QueryInterface(selectedNode);
+          aTagName.AssignLiteral("tr");
+          *aSelectedCount = 1;
+        }
+      }
+    }
+    if (!tableOrCellElement) {
+      // Didn't find a table element -- find a cell parent
+      rv = GetElementOrParentByTagName(tdName, anchorNode,
+                                       getter_AddRefs(tableOrCellElement));
+      if (NS_FAILED(rv)) {
+        return rv;
+      }
+      if (tableOrCellElement) {
+        aTagName = tdName;
+      }
+    }
+  }
+  if (tableOrCellElement) {
+    *aTableElement = tableOrCellElement.get();
+    NS_ADDREF(*aTableElement);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::GetSelectedCellsType(nsIDOMElement* aElement,
+                                 uint32_t* aSelectionType)
+{
+  NS_ENSURE_ARG_POINTER(aSelectionType);
+  *aSelectionType = 0;
+
+  // Be sure we have a table element
+  //  (if aElement is null, this uses selection's anchor node)
+  nsCOMPtr<nsIDOMElement> table;
+
+  nsresult rv =
+    GetElementOrParentByTagName(NS_LITERAL_STRING("table"), aElement,
+                                getter_AddRefs(table));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t rowCount, colCount;
+  rv = GetTableSize(table, &rowCount, &colCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Traverse all selected cells
+  nsCOMPtr<nsIDOMElement> selectedCell;
+  rv = GetFirstSelectedCell(nullptr, getter_AddRefs(selectedCell));
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (rv == NS_SUCCESS_EDITOR_ELEMENT_NOT_FOUND) {
+    return NS_OK;
+  }
+
+  // We have at least one selected cell, so set return value
+  *aSelectionType = nsISelectionPrivate::TABLESELECTION_CELL;
+
+  // Store indexes of each row/col to avoid duplication of searches
+  nsTArray<int32_t> indexArray;
+
+  bool allCellsInRowAreSelected = false;
+  bool allCellsInColAreSelected = false;
+  while (NS_SUCCEEDED(rv) && selectedCell) {
+    // Get the cell's location in the cellmap
+    int32_t startRowIndex, startColIndex;
+    rv = GetCellIndexes(selectedCell, &startRowIndex, &startColIndex);
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+
+    if (!indexArray.Contains(startColIndex)) {
+      indexArray.AppendElement(startColIndex);
+      allCellsInRowAreSelected = AllCellsInRowSelected(table, startRowIndex, colCount);
+      // We're done as soon as we fail for any row
+      if (!allCellsInRowAreSelected) {
+        break;
+      }
+    }
+    rv = GetNextSelectedCell(nullptr, getter_AddRefs(selectedCell));
+  }
+
+  if (allCellsInRowAreSelected) {
+    *aSelectionType = nsISelectionPrivate::TABLESELECTION_ROW;
+    return NS_OK;
+  }
+  // Test for columns
+
+  // Empty the indexArray
+  indexArray.Clear();
+
+  // Start at first cell again
+  rv = GetFirstSelectedCell(nullptr, getter_AddRefs(selectedCell));
+  while (NS_SUCCEEDED(rv) && selectedCell) {
+    // Get the cell's location in the cellmap
+    int32_t startRowIndex, startColIndex;
+    rv = GetCellIndexes(selectedCell, &startRowIndex, &startColIndex);
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+
+    if (!indexArray.Contains(startRowIndex)) {
+      indexArray.AppendElement(startColIndex);
+      allCellsInColAreSelected = AllCellsInColumnSelected(table, startColIndex, rowCount);
+      // We're done as soon as we fail for any column
+      if (!allCellsInRowAreSelected) {
+        break;
+      }
+    }
+    rv = GetNextSelectedCell(nullptr, getter_AddRefs(selectedCell));
+  }
+  if (allCellsInColAreSelected) {
+    *aSelectionType = nsISelectionPrivate::TABLESELECTION_COLUMN;
+  }
+
+  return NS_OK;
+}
+
+bool
+HTMLEditor::AllCellsInRowSelected(nsIDOMElement* aTable,
+                                  int32_t aRowIndex,
+                                  int32_t aNumberOfColumns)
+{
+  NS_ENSURE_TRUE(aTable, false);
+
+  int32_t curStartRowIndex, curStartColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
+  bool    isSelected;
+
+  for (int32_t col = 0; col < aNumberOfColumns;
+       col += std::max(actualColSpan, 1)) {
+    nsCOMPtr<nsIDOMElement> cell;
+    nsresult rv = GetCellDataAt(aTable, aRowIndex, col, getter_AddRefs(cell),
+                                &curStartRowIndex, &curStartColIndex,
+                                &rowSpan, &colSpan,
+                                &actualRowSpan, &actualColSpan, &isSelected);
+
+    NS_ENSURE_SUCCESS(rv, false);
+    // If no cell, we may have a "ragged" right edge,
+    //   so return TRUE only if we already found a cell in the row
+    NS_ENSURE_TRUE(cell, (col > 0) ? true : false);
+
+    // Return as soon as a non-selected cell is found
+    NS_ENSURE_TRUE(isSelected, false);
+
+    NS_ASSERTION((actualColSpan > 0),"ActualColSpan = 0 in AllCellsInRowSelected");
+  }
+  return true;
+}
+
+bool
+HTMLEditor::AllCellsInColumnSelected(nsIDOMElement* aTable,
+                                     int32_t aColIndex,
+                                     int32_t aNumberOfRows)
+{
+  NS_ENSURE_TRUE(aTable, false);
+
+  int32_t curStartRowIndex, curStartColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
+  bool    isSelected;
+
+  for (int32_t row = 0; row < aNumberOfRows;
+       row += std::max(actualRowSpan, 1)) {
+    nsCOMPtr<nsIDOMElement> cell;
+    nsresult rv = GetCellDataAt(aTable, row, aColIndex, getter_AddRefs(cell),
+                                &curStartRowIndex, &curStartColIndex,
+                                &rowSpan, &colSpan,
+                                &actualRowSpan, &actualColSpan, &isSelected);
+
+    NS_ENSURE_SUCCESS(rv, false);
+    // If no cell, we must have a "ragged" right edge on the last column
+    //   so return TRUE only if we already found a cell in the row
+    NS_ENSURE_TRUE(cell, (row > 0) ? true : false);
+
+    // Return as soon as a non-selected cell is found
+    NS_ENSURE_TRUE(isSelected, false);
+  }
+  return true;
+}
+
+bool
+HTMLEditor::IsEmptyCell(dom::Element* aCell)
+{
+  MOZ_ASSERT(aCell);
+
+  // Check if target only contains empty text node or <br>
+  nsCOMPtr<nsINode> cellChild = aCell->GetFirstChild();
+  if (!cellChild) {
+    return false;
+  }
+
+  nsCOMPtr<nsINode> nextChild = cellChild->GetNextSibling();
+  if (nextChild) {
+    return false;
+  }
+
+  // We insert a single break into a cell by default
+  //   to have some place to locate a cursor -- it is dispensable
+  if (cellChild->IsHTMLElement(nsGkAtoms::br)) {
+    return true;
+  }
+
+  bool isEmpty;
+  // Or check if no real content
+  nsresult rv = IsEmptyNode(cellChild, &isEmpty, false, false);
+  NS_ENSURE_SUCCESS(rv, false);
+  return isEmpty;
+}
+
+} // namespace mozilla