The Tor Browser: editor/libeditor/html/nsHTMLEditRules.cpp@129ffea94266 (annotated)

editor/libeditor/html/nsHTMLEditRules.cpp@129ffea94266 (annotated)

editor/libeditor/html/nsHTMLEditRules.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 sw=2 et tw=79: */
 /* 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 <stdlib.h>
 #include "mozilla/Assertions.h"
 #include "mozilla/MathAlgorithms.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/dom/Selection.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/mozalloc.h"
 #include "nsAString.h"
 #include "nsAlgorithm.h"
 #include "nsCOMArray.h"
 #include "nsCRT.h"
 #include "nsCRTGlue.h"
 #include "nsComponentManagerUtils.h"
 #include "nsContentUtils.h"
 #include "nsDebug.h"
 #include "nsEditProperty.h"
 #include "nsEditor.h"
 #include "nsEditorUtils.h"
 #include "nsError.h"
 #include "nsGkAtoms.h"
 #include "nsHTMLCSSUtils.h"
 #include "nsHTMLEditRules.h"
 #include "nsHTMLEditUtils.h"
 #include "nsHTMLEditor.h"
 #include "nsIAtom.h"
 #include "nsIContent.h"
 #include "nsIContentIterator.h"
 #include "nsID.h"
 #include "nsIDOMCharacterData.h"
 #include "nsIDOMDocument.h"
 #include "nsIDOMElement.h"
 #include "nsIDOMNode.h"
 #include "nsIDOMRange.h"
 #include "nsIDOMText.h"
 #include "nsIHTMLAbsPosEditor.h"
 #include "nsIHTMLDocument.h"
 #include "nsINode.h"
 #include "nsISelection.h"
 #include "nsISelectionPrivate.h"
 #include "nsLiteralString.h"
 #include "nsPlaintextEditor.h"
 #include "nsRange.h"
 #include "nsReadableUtils.h"
 #include "nsString.h"
 #include "nsStringFwd.h"
 #include "nsTArray.h"
 #include "nsTextEditUtils.h"
 #include "nsThreadUtils.h"
 #include "nsUnicharUtils.h"
 #include "nsWSRunObject.h"
 #include <algorithm>
 class nsISupports;
 class nsRulesInfo;
 using namespace mozilla;
 using namespace mozilla::dom;
 //const static char* kMOZEditorBogusNodeAttr="MOZ_EDITOR_BOGUS_NODE";
 //const static char* kMOZEditorBogusNodeValue="TRUE";
 enum
 {
   kLonely = 0,
   kPrevSib = 1,
   kNextSib = 2,
   kBothSibs = 3
 };
 /********************************************************
  *  first some helpful functors we will use
  ********************************************************/
 static bool IsBlockNode(nsIDOMNode* node)
 {
   bool isBlock (false);
   nsHTMLEditor::NodeIsBlockStatic(node, &isBlock);
   return isBlock;
 }
 static bool IsInlineNode(nsIDOMNode* node)
 {
   return !IsBlockNode(node);
 }
 static bool
 IsStyleCachePreservingAction(EditAction action)
 {
   return action == EditAction::deleteSelection ||
          action == EditAction::insertBreak ||
          action == EditAction::makeList ||
          action == EditAction::indent ||
          action == EditAction::outdent ||
          action == EditAction::align ||
          action == EditAction::makeBasicBlock ||
          action == EditAction::removeList ||
          action == EditAction::makeDefListItem ||
          action == EditAction::insertElement ||
          action == EditAction::insertQuotation;
 }
 class nsTableCellAndListItemFunctor : public nsBoolDomIterFunctor
 {
   public:
     virtual bool operator()(nsIDOMNode* aNode)  // used to build list of all li's, td's & th's iterator covers
     {
       if (nsHTMLEditUtils::IsTableCell(aNode)) return true;
       if (nsHTMLEditUtils::IsListItem(aNode)) return true;
       return false;
     }
 };
 class nsBRNodeFunctor : public nsBoolDomIterFunctor
 {
   public:
     virtual bool operator()(nsIDOMNode* aNode)
     {
       if (nsTextEditUtils::IsBreak(aNode)) return true;
       return false;
     }
 };
 class nsEmptyEditableFunctor : public nsBoolDomIterFunctor
 {
   public:
     nsEmptyEditableFunctor(nsHTMLEditor* editor) : mHTMLEditor(editor) {}
     virtual bool operator()(nsIDOMNode* aNode)
     {
       if (mHTMLEditor->IsEditable(aNode) &&
         (nsHTMLEditUtils::IsListItem(aNode) ||
         nsHTMLEditUtils::IsTableCellOrCaption(aNode)))
       {
         bool bIsEmptyNode;
         nsresult res = mHTMLEditor->IsEmptyNode(aNode, &bIsEmptyNode, false, false);
         NS_ENSURE_SUCCESS(res, false);
         if (bIsEmptyNode)
           return true;
       }
       return false;
     }
   protected:
     nsHTMLEditor* mHTMLEditor;
 };
 class nsEditableTextFunctor : public nsBoolDomIterFunctor
 {
   public:
     nsEditableTextFunctor(nsHTMLEditor* editor) : mHTMLEditor(editor) {}
     virtual bool operator()(nsIDOMNode* aNode)
     {
       if (nsEditor::IsTextNode(aNode) && mHTMLEditor->IsEditable(aNode))
       {
         return true;
       }
       return false;
     }
   protected:
     nsHTMLEditor* mHTMLEditor;
 };
 /********************************************************
  *  Constructor/Destructor
  ********************************************************/
 nsHTMLEditRules::nsHTMLEditRules()
 {
   InitFields();
 }
 void
 nsHTMLEditRules::InitFields()
 {
   mHTMLEditor = nullptr;
   mDocChangeRange = nullptr;
   mListenerEnabled = true;
   mReturnInEmptyLIKillsList = true;
   mDidDeleteSelection = false;
   mDidRangedDelete = false;
   mRestoreContentEditableCount = false;
   mUtilRange = nullptr;
   mJoinOffset = 0;
   mNewBlock = nullptr;
   mRangeItem = new nsRangeStore();
   // populate mCachedStyles
   mCachedStyles[0] = StyleCache(nsEditProperty::b, EmptyString(), EmptyString());
   mCachedStyles[1] = StyleCache(nsEditProperty::i, EmptyString(), EmptyString());
   mCachedStyles[2] = StyleCache(nsEditProperty::u, EmptyString(), EmptyString());
   mCachedStyles[3] = StyleCache(nsEditProperty::font, NS_LITERAL_STRING("face"), EmptyString());
   mCachedStyles[4] = StyleCache(nsEditProperty::font, NS_LITERAL_STRING("size"), EmptyString());
   mCachedStyles[5] = StyleCache(nsEditProperty::font, NS_LITERAL_STRING("color"), EmptyString());
   mCachedStyles[6] = StyleCache(nsEditProperty::tt, EmptyString(), EmptyString());
   mCachedStyles[7] = StyleCache(nsEditProperty::em, EmptyString(), EmptyString());
   mCachedStyles[8] = StyleCache(nsEditProperty::strong, EmptyString(), EmptyString());
   mCachedStyles[9] = StyleCache(nsEditProperty::dfn, EmptyString(), EmptyString());
   mCachedStyles[10] = StyleCache(nsEditProperty::code, EmptyString(), EmptyString());
   mCachedStyles[11] = StyleCache(nsEditProperty::samp, EmptyString(), EmptyString());
   mCachedStyles[12] = StyleCache(nsEditProperty::var, EmptyString(), EmptyString());
   mCachedStyles[13] = StyleCache(nsEditProperty::cite, EmptyString(), EmptyString());
   mCachedStyles[14] = StyleCache(nsEditProperty::abbr, EmptyString(), EmptyString());
   mCachedStyles[15] = StyleCache(nsEditProperty::acronym, EmptyString(), EmptyString());
   mCachedStyles[16] = StyleCache(nsEditProperty::cssBackgroundColor, EmptyString(), EmptyString());
   mCachedStyles[17] = StyleCache(nsEditProperty::sub, EmptyString(), EmptyString());
   mCachedStyles[18] = StyleCache(nsEditProperty::sup, EmptyString(), EmptyString());
 }
 nsHTMLEditRules::~nsHTMLEditRules()
 {
   // remove ourselves as a listener to edit actions
   // In some cases, we have already been removed by
   // ~nsHTMLEditor, in which case we will get a null pointer here
   // which we ignore.  But this allows us to add the ability to
   // switch rule sets on the fly if we want.
   if (mHTMLEditor)
     mHTMLEditor->RemoveEditActionListener(this);
 }
 /********************************************************
  *  XPCOM Cruft
  ********************************************************/
 NS_IMPL_ADDREF_INHERITED(nsHTMLEditRules, nsTextEditRules)
 NS_IMPL_RELEASE_INHERITED(nsHTMLEditRules, nsTextEditRules)
 NS_IMPL_QUERY_INTERFACE_INHERITED(nsHTMLEditRules, nsTextEditRules, nsIEditActionListener)
 /********************************************************
  *  Public methods
  ********************************************************/
 NS_IMETHODIMP
 nsHTMLEditRules::Init(nsPlaintextEditor *aEditor)
 {
   InitFields();
   mHTMLEditor = static_cast<nsHTMLEditor*>(aEditor);
   nsresult res;
   // call through to base class Init
   res = nsTextEditRules::Init(aEditor);
   NS_ENSURE_SUCCESS(res, res);
   // cache any prefs we care about
   static const char kPrefName[] =
     "editor.html.typing.returnInEmptyListItemClosesList";
   nsAdoptingCString returnInEmptyLIKillsList =
     Preferences::GetCString(kPrefName);
   // only when "false", becomes FALSE.  Otherwise (including empty), TRUE.
   // XXX Why was this pref designed as a string and not bool?
   mReturnInEmptyLIKillsList = !returnInEmptyLIKillsList.EqualsLiteral("false");
   // make a utility range for use by the listenter
   nsCOMPtr<nsINode> node = mHTMLEditor->GetRoot();
   if (!node) {
     node = mHTMLEditor->GetDocument();
   }
   NS_ENSURE_STATE(node);
   mUtilRange = new nsRange(node);
   // set up mDocChangeRange to be whole doc
   // temporarily turn off rules sniffing
   nsAutoLockRulesSniffing lockIt((nsTextEditRules*)this);
   if (!mDocChangeRange) {
     mDocChangeRange = new nsRange(node);
   }
   if (node->IsElement()) {
     ErrorResult rv;
     mDocChangeRange->SelectNode(*node, rv);
     res = AdjustSpecialBreaks(node);
     NS_ENSURE_SUCCESS(res, res);
   }
   // add ourselves as a listener to edit actions
   res = mHTMLEditor->AddEditActionListener(this);
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::DetachEditor()
 {
   if (mHTMLEditor) {
     mHTMLEditor->RemoveEditActionListener(this);
   }
   mHTMLEditor = nullptr;
   return nsTextEditRules::DetachEditor();
 }
 NS_IMETHODIMP
 nsHTMLEditRules::BeforeEdit(EditAction action,
                             nsIEditor::EDirection aDirection)
 {
   if (mLockRulesSniffing) return NS_OK;
   nsAutoLockRulesSniffing lockIt((nsTextEditRules*)this);
   mDidExplicitlySetInterline = false;
   if (!mActionNesting++)
   {
     // clear our flag about if just deleted a range
     mDidRangedDelete = false;
     // remember where our selection was before edit action took place:
     // get selection
     nsCOMPtr<nsISelection> selection;
     NS_ENSURE_STATE(mHTMLEditor);
     nsresult res = mHTMLEditor->GetSelection(getter_AddRefs(selection));
     NS_ENSURE_SUCCESS(res, res);
     // get the selection start location
     nsCOMPtr<nsIDOMNode> selStartNode, selEndNode;
     int32_t selOffset;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetStartNodeAndOffset(selection, getter_AddRefs(selStartNode), &selOffset);
     NS_ENSURE_SUCCESS(res, res);
     mRangeItem->startNode = selStartNode;
     mRangeItem->startOffset = selOffset;
     // get the selection end location
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetEndNodeAndOffset(selection, getter_AddRefs(selEndNode), &selOffset);
     NS_ENSURE_SUCCESS(res, res);
     mRangeItem->endNode = selEndNode;
     mRangeItem->endOffset = selOffset;
     // register this range with range updater to track this as we perturb the doc
     NS_ENSURE_STATE(mHTMLEditor);
     (mHTMLEditor->mRangeUpdater).RegisterRangeItem(mRangeItem);
     // clear deletion state bool
     mDidDeleteSelection = false;
     // clear out mDocChangeRange and mUtilRange
     if(mDocChangeRange)
     {
       // clear out our accounting of what changed
       mDocChangeRange->Reset();
     }
     if(mUtilRange)
     {
       // ditto for mUtilRange.
       mUtilRange->Reset();
     }
     // remember current inline styles for deletion and normal insertion operations
     if (action == EditAction::insertText ||
         action == EditAction::insertIMEText ||
         action == EditAction::deleteSelection ||
         IsStyleCachePreservingAction(action)) {
       nsCOMPtr<nsIDOMNode> selNode = selStartNode;
       if (aDirection == nsIEditor::eNext)
         selNode = selEndNode;
       res = CacheInlineStyles(selNode);
       NS_ENSURE_SUCCESS(res, res);
     }
     // Stabilize the document against contenteditable count changes
     NS_ENSURE_STATE(mHTMLEditor);
     nsCOMPtr<nsIDOMDocument> doc = mHTMLEditor->GetDOMDocument();
     NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);
     nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(doc);
     NS_ENSURE_TRUE(htmlDoc, NS_ERROR_FAILURE);
     if (htmlDoc->GetEditingState() == nsIHTMLDocument::eContentEditable) {
       htmlDoc->ChangeContentEditableCount(nullptr, +1);
       mRestoreContentEditableCount = true;
     }
     // check that selection is in subtree defined by body node
     ConfirmSelectionInBody();
     // let rules remember the top level action
     mTheAction = action;
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::AfterEdit(EditAction action,
                            nsIEditor::EDirection aDirection)
 {
   if (mLockRulesSniffing) return NS_OK;
   nsAutoLockRulesSniffing lockIt(this);
   NS_PRECONDITION(mActionNesting>0, "bad action nesting!");
   nsresult res = NS_OK;
   if (!--mActionNesting)
   {
     // do all the tricky stuff
     res = AfterEditInner(action, aDirection);
     // free up selectionState range item
     NS_ENSURE_STATE(mHTMLEditor);
     (mHTMLEditor->mRangeUpdater).DropRangeItem(mRangeItem);
     // Reset the contenteditable count to its previous value
     if (mRestoreContentEditableCount) {
       NS_ENSURE_STATE(mHTMLEditor);
       nsCOMPtr<nsIDOMDocument> doc = mHTMLEditor->GetDOMDocument();
       NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);
       nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(doc);
       NS_ENSURE_TRUE(htmlDoc, NS_ERROR_FAILURE);
       if (htmlDoc->GetEditingState() == nsIHTMLDocument::eContentEditable) {
         htmlDoc->ChangeContentEditableCount(nullptr, -1);
       }
       mRestoreContentEditableCount = false;
     }
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::AfterEditInner(EditAction action,
                                 nsIEditor::EDirection aDirection)
 {
   ConfirmSelectionInBody();
   if (action == EditAction::ignore) return NS_OK;
   nsCOMPtr<nsISelection>selection;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res = mHTMLEditor->GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   nsCOMPtr<nsIDOMNode> rangeStartParent, rangeEndParent;
   int32_t rangeStartOffset = 0, rangeEndOffset = 0;
   // do we have a real range to act on?
   bool bDamagedRange = false;
   if (mDocChangeRange)
   {
     mDocChangeRange->GetStartContainer(getter_AddRefs(rangeStartParent));
     mDocChangeRange->GetEndContainer(getter_AddRefs(rangeEndParent));
     mDocChangeRange->GetStartOffset(&rangeStartOffset);
     mDocChangeRange->GetEndOffset(&rangeEndOffset);
     if (rangeStartParent && rangeEndParent)
       bDamagedRange = true;
   }
   if (bDamagedRange && !((action == EditAction::undo) || (action == EditAction::redo)))
   {
     // don't let any txns in here move the selection around behind our back.
     // Note that this won't prevent explicit selection setting from working.
     NS_ENSURE_STATE(mHTMLEditor);
     nsAutoTxnsConserveSelection dontSpazMySelection(mHTMLEditor);
     // expand the "changed doc range" as needed
     res = PromoteRange(mDocChangeRange, action);
     NS_ENSURE_SUCCESS(res, res);
     // if we did a ranged deletion, make sure we have a place to put caret.
     // Note we only want to do this if the overall operation was deletion,
     // not if deletion was done along the way for EditAction::loadHTML, EditAction::insertText, etc.
     // That's why this is here rather than DidDeleteSelection().
     if ((action == EditAction::deleteSelection) && mDidRangedDelete)
     {
       res = InsertBRIfNeeded(selection);
       NS_ENSURE_SUCCESS(res, res);
     }
     // add in any needed <br>s, and remove any unneeded ones.
     res = AdjustSpecialBreaks();
     NS_ENSURE_SUCCESS(res, res);
     // merge any adjacent text nodes
     if ( (action != EditAction::insertText &&
          action != EditAction::insertIMEText) )
     {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->CollapseAdjacentTextNodes(mDocChangeRange);
       NS_ENSURE_SUCCESS(res, res);
     }
     // clean up any empty nodes in the selection
     res = RemoveEmptyNodes();
     NS_ENSURE_SUCCESS(res, res);
     // attempt to transform any unneeded nbsp's into spaces after doing various operations
     if ((action == EditAction::insertText) ||
         (action == EditAction::insertIMEText) ||
         (action == EditAction::deleteSelection) ||
         (action == EditAction::insertBreak) ||
         (action == EditAction::htmlPaste ||
         (action == EditAction::loadHTML)))
     {
       res = AdjustWhitespace(selection);
       NS_ENSURE_SUCCESS(res, res);
       // also do this for original selection endpoints.
       NS_ENSURE_STATE(mHTMLEditor);
       nsWSRunObject(mHTMLEditor, mRangeItem->startNode,
                     mRangeItem->startOffset).AdjustWhitespace();
       // we only need to handle old selection endpoint if it was different from start
       if (mRangeItem->startNode != mRangeItem->endNode ||
           mRangeItem->startOffset != mRangeItem->endOffset) {
         NS_ENSURE_STATE(mHTMLEditor);
         nsWSRunObject(mHTMLEditor, mRangeItem->endNode,
                       mRangeItem->endOffset).AdjustWhitespace();
       }
     }
     // if we created a new block, make sure selection lands in it
     if (mNewBlock)
     {
       res = PinSelectionToNewBlock(selection);
       mNewBlock = 0;
     }
     // adjust selection for insert text, html paste, and delete actions
     if ((action == EditAction::insertText) ||
         (action == EditAction::insertIMEText) ||
         (action == EditAction::deleteSelection) ||
         (action == EditAction::insertBreak) ||
         (action == EditAction::htmlPaste ||
         (action == EditAction::loadHTML)))
     {
       res = AdjustSelection(selection, aDirection);
       NS_ENSURE_SUCCESS(res, res);
     }
     // check for any styles which were removed inappropriately
     if (action == EditAction::insertText ||
         action == EditAction::insertIMEText ||
         action == EditAction::deleteSelection ||
         IsStyleCachePreservingAction(action)) {
       NS_ENSURE_STATE(mHTMLEditor);
       mHTMLEditor->mTypeInState->UpdateSelState(selection);
       res = ReapplyCachedStyles();
       NS_ENSURE_SUCCESS(res, res);
       ClearCachedStyles();
     }
   }
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->HandleInlineSpellCheck(action, selection,
                                             mRangeItem->startNode,
                                             mRangeItem->startOffset,
                                             rangeStartParent, rangeStartOffset,
                                             rangeEndParent, rangeEndOffset);
   NS_ENSURE_SUCCESS(res, res);
   // detect empty doc
   res = CreateBogusNodeIfNeeded(selection);
   // adjust selection HINT if needed
   NS_ENSURE_SUCCESS(res, res);
   if (!mDidExplicitlySetInterline)
   {
     res = CheckInterlinePosition(selection);
   }
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::WillDoAction(Selection* aSelection,
                               nsRulesInfo* aInfo,
                               bool* aCancel,
                               bool* aHandled)
 {
   MOZ_ASSERT(aInfo && aCancel && aHandled);
   *aCancel = false;
   *aHandled = false;
   // my kingdom for dynamic cast
   nsTextRulesInfo *info = static_cast<nsTextRulesInfo*>(aInfo);
   // Deal with actions for which we don't need to check whether the selection is
   // editable.
   if (info->action == EditAction::outputText ||
       info->action == EditAction::undo ||
       info->action == EditAction::redo) {
     return nsTextEditRules::WillDoAction(aSelection, aInfo, aCancel, aHandled);
   }
   // Nothing to do if there's no selection to act on
   if (!aSelection) {
     return NS_OK;
   }
   NS_ENSURE_TRUE(aSelection->GetRangeCount(), NS_OK);
   nsRefPtr<nsRange> range = aSelection->GetRangeAt(0);
   nsCOMPtr<nsINode> selStartNode = range->GetStartParent();
   NS_ENSURE_STATE(mHTMLEditor);
   if (!mHTMLEditor->IsModifiableNode(selStartNode)) {
     *aCancel = true;
     return NS_OK;
   }
   nsCOMPtr<nsINode> selEndNode = range->GetEndParent();
   if (selStartNode != selEndNode) {
     NS_ENSURE_STATE(mHTMLEditor);
     if (!mHTMLEditor->IsModifiableNode(selEndNode)) {
       *aCancel = true;
       return NS_OK;
     }
     NS_ENSURE_STATE(mHTMLEditor);
     if (!mHTMLEditor->IsModifiableNode(range->GetCommonAncestor())) {
       *aCancel = true;
       return NS_OK;
     }
   }
   switch (info->action) {
     case EditAction::insertText:
     case EditAction::insertIMEText:
       return WillInsertText(info->action, aSelection, aCancel, aHandled,
                             info->inString, info->outString, info->maxLength);
     case EditAction::loadHTML:
       return WillLoadHTML(aSelection, aCancel);
     case EditAction::insertBreak:
       return WillInsertBreak(aSelection, aCancel, aHandled);
     case EditAction::deleteSelection:
       return WillDeleteSelection(aSelection, info->collapsedAction,
                                  info->stripWrappers, aCancel, aHandled);
     case EditAction::makeList:
       return WillMakeList(aSelection, info->blockType, info->entireList,
                           info->bulletType, aCancel, aHandled);
     case EditAction::indent:
       return WillIndent(aSelection, aCancel, aHandled);
     case EditAction::outdent:
       return WillOutdent(aSelection, aCancel, aHandled);
     case EditAction::setAbsolutePosition:
       return WillAbsolutePosition(aSelection, aCancel, aHandled);
     case EditAction::removeAbsolutePosition:
       return WillRemoveAbsolutePosition(aSelection, aCancel, aHandled);
     case EditAction::align:
       return WillAlign(aSelection, info->alignType, aCancel, aHandled);
     case EditAction::makeBasicBlock:
       return WillMakeBasicBlock(aSelection, info->blockType, aCancel, aHandled);
     case EditAction::removeList:
       return WillRemoveList(aSelection, info->bOrdered, aCancel, aHandled);
     case EditAction::makeDefListItem:
       return WillMakeDefListItem(aSelection, info->blockType, info->entireList,
                                  aCancel, aHandled);
     case EditAction::insertElement:
       return WillInsert(aSelection, aCancel);
     case EditAction::decreaseZIndex:
       return WillRelativeChangeZIndex(aSelection, -1, aCancel, aHandled);
     case EditAction::increaseZIndex:
       return WillRelativeChangeZIndex(aSelection, 1, aCancel, aHandled);
     default:
       return nsTextEditRules::WillDoAction(aSelection, aInfo,
                                            aCancel, aHandled);
   }
 }
 NS_IMETHODIMP
 nsHTMLEditRules::DidDoAction(nsISelection *aSelection,
                              nsRulesInfo *aInfo, nsresult aResult)
 {
   nsTextRulesInfo *info = static_cast<nsTextRulesInfo*>(aInfo);
   switch (info->action)
   {
     case EditAction::insertBreak:
       return DidInsertBreak(aSelection, aResult);
     case EditAction::deleteSelection:
       return DidDeleteSelection(aSelection, info->collapsedAction, aResult);
     case EditAction::makeBasicBlock:
     case EditAction::indent:
     case EditAction::outdent:
     case EditAction::align:
       return DidMakeBasicBlock(aSelection, aInfo, aResult);
     case EditAction::setAbsolutePosition: {
       nsresult rv = DidMakeBasicBlock(aSelection, aInfo, aResult);
       NS_ENSURE_SUCCESS(rv, rv);
       return DidAbsolutePosition();
     }
     default:
       // pass thru to nsTextEditRules
       return nsTextEditRules::DidDoAction(aSelection, aInfo, aResult);
   }
 }
 nsresult
 nsHTMLEditRules::GetListState(bool *aMixed, bool *aOL, bool *aUL, bool *aDL)
 {
   NS_ENSURE_TRUE(aMixed && aOL && aUL && aDL, NS_ERROR_NULL_POINTER);
   *aMixed = false;
   *aOL = false;
   *aUL = false;
   *aDL = false;
   bool bNonList = false;
   nsCOMArray<nsIDOMNode> arrayOfNodes;
   nsresult res = GetListActionNodes(arrayOfNodes, false, true);
   NS_ENSURE_SUCCESS(res, res);
   // Examine list type for nodes in selection.
   int32_t listCount = arrayOfNodes.Count();
   for (int32_t i = listCount - 1; i >= 0; --i) {
     nsIDOMNode* curDOMNode = arrayOfNodes[i];
     nsCOMPtr<dom::Element> curElement = do_QueryInterface(curDOMNode);
     if (!curElement) {
       bNonList = true;
     } else if (curElement->IsHTML(nsGkAtoms::ul)) {
       *aUL = true;
     } else if (curElement->IsHTML(nsGkAtoms::ol)) {
       *aOL = true;
     } else if (curElement->IsHTML(nsGkAtoms::li)) {
       if (dom::Element* parent = curElement->GetParentElement()) {
         if (parent->IsHTML(nsGkAtoms::ul)) {
           *aUL = true;
         } else if (parent->IsHTML(nsGkAtoms::ol)) {
           *aOL = true;
         }
       }
     } else if (curElement->IsHTML(nsGkAtoms::dl) ||
                curElement->IsHTML(nsGkAtoms::dt) ||
                curElement->IsHTML(nsGkAtoms::dd)) {
       *aDL = true;
     } else {
       bNonList = true;
     }
   }
   // hokey arithmetic with booleans
   if ((*aUL + *aOL + *aDL + bNonList) > 1) {
     *aMixed = true;
   }
   return NS_OK;
 }
 nsresult
 nsHTMLEditRules::GetListItemState(bool *aMixed, bool *aLI, bool *aDT, bool *aDD)
 {
   NS_ENSURE_TRUE(aMixed && aLI && aDT && aDD, NS_ERROR_NULL_POINTER);
   *aMixed = false;
   *aLI = false;
   *aDT = false;
   *aDD = false;
   bool bNonList = false;
   nsCOMArray<nsIDOMNode> arrayOfNodes;
   nsresult res = GetListActionNodes(arrayOfNodes, false, true);
   NS_ENSURE_SUCCESS(res, res);
   // examine list type for nodes in selection
   int32_t listCount = arrayOfNodes.Count();
   for (int32_t i = listCount - 1; i >= 0; --i) {
     nsIDOMNode* curNode = arrayOfNodes[i];
     nsCOMPtr<dom::Element> element = do_QueryInterface(curNode);
     if (!element) {
       bNonList = true;
     } else if (element->IsHTML(nsGkAtoms::ul) ||
                element->IsHTML(nsGkAtoms::ol) ||
                element->IsHTML(nsGkAtoms::li)) {
       *aLI = true;
     } else if (element->IsHTML(nsGkAtoms::dt)) {
       *aDT = true;
     } else if (element->IsHTML(nsGkAtoms::dd)) {
       *aDD = true;
     } else if (element->IsHTML(nsGkAtoms::dl)) {
       // need to look inside dl and see which types of items it has
       bool bDT, bDD;
       GetDefinitionListItemTypes(element, &bDT, &bDD);
       *aDT |= bDT;
       *aDD |= bDD;
     } else {
       bNonList = true;
     }
   }
   // hokey arithmetic with booleans
   if ( (*aDT + *aDD + bNonList) > 1) *aMixed = true;
   return NS_OK;
 }
 nsresult
 nsHTMLEditRules::GetAlignment(bool *aMixed, nsIHTMLEditor::EAlignment *aAlign)
 {
   // for now, just return first alignment.  we'll lie about
   // if it's mixed.  This is for efficiency
   // given that our current ui doesn't care if it's mixed.
   // cmanske: NOT TRUE! We would like to pay attention to mixed state
   //  in Format | Align submenu!
   // this routine assumes that alignment is done ONLY via divs
   // default alignment is left
   NS_ENSURE_TRUE(aMixed && aAlign, NS_ERROR_NULL_POINTER);
   *aMixed = false;
   *aAlign = nsIHTMLEditor::eLeft;
   // get selection
   nsCOMPtr<nsISelection>selection;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res = mHTMLEditor->GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   // get selection location
   NS_ENSURE_STATE(mHTMLEditor);
   nsCOMPtr<nsIDOMElement> rootElem = do_QueryInterface(mHTMLEditor->GetRoot());
   NS_ENSURE_TRUE(rootElem, NS_ERROR_FAILURE);
   int32_t offset, rootOffset;
   nsCOMPtr<nsIDOMNode> parent = nsEditor::GetNodeLocation(rootElem, &rootOffset);
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetStartNodeAndOffset(selection, getter_AddRefs(parent), &offset);
   NS_ENSURE_SUCCESS(res, res);
   // is the selection collapsed?
   nsCOMPtr<nsIDOMNode> nodeToExamine;
   if (selection->Collapsed()) {
     // if it is, we want to look at 'parent' and its ancestors
     // for divs with alignment on them
     nodeToExamine = parent;
   }
   else if (!mHTMLEditor) {
     return NS_ERROR_UNEXPECTED;
   }
   else if (mHTMLEditor->IsTextNode(parent))
   {
     // if we are in a text node, then that is the node of interest
     nodeToExamine = parent;
   }
   else if (nsEditor::NodeIsType(parent, nsEditProperty::html) &&
            offset == rootOffset)
   {
     // if we have selected the body, let's look at the first editable node
     NS_ENSURE_STATE(mHTMLEditor);
     mHTMLEditor->GetNextNode(parent, offset, true, address_of(nodeToExamine));
   }
   else
   {
     nsCOMArray<nsIDOMRange> arrayOfRanges;
     res = GetPromotedRanges(selection, arrayOfRanges, EditAction::align);
     NS_ENSURE_SUCCESS(res, res);
     // use these ranges to construct a list of nodes to act on.
     nsCOMArray<nsIDOMNode> arrayOfNodes;
     res = GetNodesForOperation(arrayOfRanges, arrayOfNodes,
                                EditAction::align, true);
     NS_ENSURE_SUCCESS(res, res);
     nodeToExamine = arrayOfNodes.SafeObjectAt(0);
   }
   NS_ENSURE_TRUE(nodeToExamine, NS_ERROR_NULL_POINTER);
   NS_NAMED_LITERAL_STRING(typeAttrName, "align");
   nsIAtom  *dummyProperty = nullptr;
   nsCOMPtr<nsIDOMNode> blockParent;
   NS_ENSURE_STATE(mHTMLEditor);
   if (mHTMLEditor->IsBlockNode(nodeToExamine))
     blockParent = nodeToExamine;
   else {
     NS_ENSURE_STATE(mHTMLEditor);
     blockParent = mHTMLEditor->GetBlockNodeParent(nodeToExamine);
   }
   NS_ENSURE_TRUE(blockParent, NS_ERROR_FAILURE);
   NS_ENSURE_STATE(mHTMLEditor);
   if (mHTMLEditor->IsCSSEnabled())
   {
     nsCOMPtr<nsIContent> blockParentContent = do_QueryInterface(blockParent);
     NS_ENSURE_STATE(mHTMLEditor);
     if (blockParentContent &&
         mHTMLEditor->mHTMLCSSUtils->IsCSSEditableProperty(blockParentContent, dummyProperty, &typeAttrName))
     {
       // we are in CSS mode and we know how to align this element with CSS
       nsAutoString value;
       // let's get the value(s) of text-align or margin-left/margin-right
       NS_ENSURE_STATE(mHTMLEditor);
       mHTMLEditor->mHTMLCSSUtils->GetCSSEquivalentToHTMLInlineStyleSet(
         blockParentContent, dummyProperty, &typeAttrName, value,
         nsHTMLCSSUtils::eComputed);
       if (value.EqualsLiteral("center") ||
           value.EqualsLiteral("-moz-center") ||
           value.EqualsLiteral("auto auto"))
       {
         *aAlign = nsIHTMLEditor::eCenter;
         return NS_OK;
       }
       if (value.EqualsLiteral("right") ||
           value.EqualsLiteral("-moz-right") ||
           value.EqualsLiteral("auto 0px"))
       {
         *aAlign = nsIHTMLEditor::eRight;
         return NS_OK;
       }
       if (value.EqualsLiteral("justify"))
       {
         *aAlign = nsIHTMLEditor::eJustify;
         return NS_OK;
       }
       *aAlign = nsIHTMLEditor::eLeft;
       return NS_OK;
     }
   }
   // check up the ladder for divs with alignment
   nsCOMPtr<nsIDOMNode> temp = nodeToExamine;
   bool isFirstNodeToExamine = true;
   while (nodeToExamine)
   {
     if (!isFirstNodeToExamine && nsHTMLEditUtils::IsTable(nodeToExamine))
     {
       // the node to examine is a table and this is not the first node
       // we examine; let's break here to materialize the 'inline-block'
       // behaviour of html tables regarding to text alignment
       return NS_OK;
     }
     if (nsHTMLEditUtils::SupportsAlignAttr(nodeToExamine))
     {
       // check for alignment
       nsCOMPtr<nsIDOMElement> elem = do_QueryInterface(nodeToExamine);
       if (elem)
       {
         nsAutoString typeAttrVal;
         res = elem->GetAttribute(NS_LITERAL_STRING("align"), typeAttrVal);
         ToLowerCase(typeAttrVal);
         if (NS_SUCCEEDED(res) && typeAttrVal.Length())
         {
           if (typeAttrVal.EqualsLiteral("center"))
             *aAlign = nsIHTMLEditor::eCenter;
           else if (typeAttrVal.EqualsLiteral("right"))
             *aAlign = nsIHTMLEditor::eRight;
           else if (typeAttrVal.EqualsLiteral("justify"))
             *aAlign = nsIHTMLEditor::eJustify;
           else
             *aAlign = nsIHTMLEditor::eLeft;
           return res;
         }
       }
     }
     isFirstNodeToExamine = false;
     res = nodeToExamine->GetParentNode(getter_AddRefs(temp));
     if (NS_FAILED(res)) temp = nullptr;
     nodeToExamine = temp;
   }
   return NS_OK;
 }
 nsIAtom* MarginPropertyAtomForIndent(nsHTMLCSSUtils* aHTMLCSSUtils, nsIDOMNode* aNode) {
   nsAutoString direction;
   aHTMLCSSUtils->GetComputedProperty(aNode, nsEditProperty::cssDirection, direction);
   return direction.EqualsLiteral("rtl") ?
     nsEditProperty::cssMarginRight : nsEditProperty::cssMarginLeft;
 }
 nsresult
 nsHTMLEditRules::GetIndentState(bool *aCanIndent, bool *aCanOutdent)
 {
   NS_ENSURE_TRUE(aCanIndent && aCanOutdent, NS_ERROR_FAILURE);
   *aCanIndent = true;
   *aCanOutdent = false;
   // get selection
   nsCOMPtr<nsISelection>selection;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res = mHTMLEditor->GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   nsCOMPtr<nsISelectionPrivate> selPriv(do_QueryInterface(selection));
   NS_ENSURE_TRUE(selPriv, NS_ERROR_FAILURE);
   // contruct a list of nodes to act on.
   nsCOMArray<nsIDOMNode> arrayOfNodes;
   res = GetNodesFromSelection(selection, EditAction::indent,
                               arrayOfNodes, true);
   NS_ENSURE_SUCCESS(res, res);
   // examine nodes in selection for blockquotes or list elements;
   // these we can outdent.  Note that we return true for canOutdent
   // if *any* of the selection is outdentable, rather than all of it.
   int32_t listCount = arrayOfNodes.Count();
   int32_t i;
   NS_ENSURE_STATE(mHTMLEditor);
   bool useCSS = mHTMLEditor->IsCSSEnabled();
   for (i=listCount-1; i>=0; i--)
   {
     nsCOMPtr<nsIDOMNode> curNode = arrayOfNodes[i];
     if (nsHTMLEditUtils::IsNodeThatCanOutdent(curNode))
     {
       *aCanOutdent = true;
       break;
     }
     else if (useCSS) {
       // we are in CSS mode, indentation is done using the margin-left (or margin-right) property
       NS_ENSURE_STATE(mHTMLEditor);
       nsIAtom* marginProperty = MarginPropertyAtomForIndent(mHTMLEditor->mHTMLCSSUtils, curNode);
       nsAutoString value;
       // retrieve its specified value
       NS_ENSURE_STATE(mHTMLEditor);
       mHTMLEditor->mHTMLCSSUtils->GetSpecifiedProperty(curNode, marginProperty, value);
       float f;
       nsCOMPtr<nsIAtom> unit;
       // get its number part and its unit
       NS_ENSURE_STATE(mHTMLEditor);
       mHTMLEditor->mHTMLCSSUtils->ParseLength(value, &f, getter_AddRefs(unit));
       // if the number part is strictly positive, outdent is possible
       if (0 < f) {
         *aCanOutdent = true;
         break;
       }
     }
   }
   if (!*aCanOutdent)
   {
     // if we haven't found something to outdent yet, also check the parents
     // of selection endpoints.  We might have a blockquote or list item
     // in the parent hierarchy.
     // gather up info we need for test
     NS_ENSURE_STATE(mHTMLEditor);
     nsCOMPtr<nsIDOMNode> parent, tmp, root = do_QueryInterface(mHTMLEditor->GetRoot());
     NS_ENSURE_TRUE(root, NS_ERROR_NULL_POINTER);
     nsCOMPtr<nsISelection> selection;
     int32_t selOffset;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetSelection(getter_AddRefs(selection));
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
     // test start parent hierarchy
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetStartNodeAndOffset(selection, getter_AddRefs(parent), &selOffset);
     NS_ENSURE_SUCCESS(res, res);
     while (parent && (parent!=root))
     {
       if (nsHTMLEditUtils::IsNodeThatCanOutdent(parent))
       {
         *aCanOutdent = true;
         break;
       }
       tmp=parent;
       tmp->GetParentNode(getter_AddRefs(parent));
     }
     // test end parent hierarchy
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetEndNodeAndOffset(selection, getter_AddRefs(parent), &selOffset);
     NS_ENSURE_SUCCESS(res, res);
     while (parent && (parent!=root))
     {
       if (nsHTMLEditUtils::IsNodeThatCanOutdent(parent))
       {
         *aCanOutdent = true;
         break;
       }
       tmp=parent;
       tmp->GetParentNode(getter_AddRefs(parent));
     }
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::GetParagraphState(bool *aMixed, nsAString &outFormat)
 {
   // This routine is *heavily* tied to our ui choices in the paragraph
   // style popup.  I can't see a way around that.
   NS_ENSURE_TRUE(aMixed, NS_ERROR_NULL_POINTER);
   *aMixed = true;
   outFormat.Truncate(0);
   bool bMixed = false;
   // using "x" as an uninitialized value, since "" is meaningful
   nsAutoString formatStr(NS_LITERAL_STRING("x"));
   nsCOMArray<nsIDOMNode> arrayOfNodes;
   nsresult res = GetParagraphFormatNodes(arrayOfNodes, true);
   NS_ENSURE_SUCCESS(res, res);
   // post process list.  We need to replace any block nodes that are not format
   // nodes with their content.  This is so we only have to look "up" the hierarchy
   // to find format nodes, instead of both up and down.
   int32_t listCount = arrayOfNodes.Count();
   int32_t i;
   for (i=listCount-1; i>=0; i--)
   {
     nsCOMPtr<nsIDOMNode> curNode = arrayOfNodes[i];
     nsAutoString format;
     // if it is a known format node we have it easy
     if (IsBlockNode(curNode) && !nsHTMLEditUtils::IsFormatNode(curNode))
     {
       // arrayOfNodes.RemoveObject(curNode);
       res = AppendInnerFormatNodes(arrayOfNodes, curNode);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   // we might have an empty node list.  if so, find selection parent
   // and put that on the list
   listCount = arrayOfNodes.Count();
   if (!listCount)
   {
     nsCOMPtr<nsIDOMNode> selNode;
     int32_t selOffset;
     nsCOMPtr<nsISelection>selection;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetSelection(getter_AddRefs(selection));
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetStartNodeAndOffset(selection, getter_AddRefs(selNode), &selOffset);
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_TRUE(selNode, NS_ERROR_NULL_POINTER);
     arrayOfNodes.AppendObject(selNode);
     listCount = 1;
   }
   // remember root node
   NS_ENSURE_STATE(mHTMLEditor);
   nsCOMPtr<nsIDOMElement> rootElem = do_QueryInterface(mHTMLEditor->GetRoot());
   NS_ENSURE_TRUE(rootElem, NS_ERROR_NULL_POINTER);
   // loop through the nodes in selection and examine their paragraph format
   for (i=listCount-1; i>=0; i--)
   {
     nsCOMPtr<nsIDOMNode> curNode = arrayOfNodes[i];
     nsAutoString format;
     // if it is a known format node we have it easy
     if (nsHTMLEditUtils::IsFormatNode(curNode))
       GetFormatString(curNode, format);
     else if (IsBlockNode(curNode))
     {
       // this is a div or some other non-format block.
       // we should ignore it.  Its children were appended to this list
       // by AppendInnerFormatNodes() call above.  We will get needed
       // info when we examine them instead.
       continue;
     }
     else
     {
       nsCOMPtr<nsIDOMNode> node, tmp = curNode;
       tmp->GetParentNode(getter_AddRefs(node));
       while (node)
       {
         if (node == rootElem)
         {
           format.Truncate(0);
           break;
         }
         else if (nsHTMLEditUtils::IsFormatNode(node))
         {
           GetFormatString(node, format);
           break;
         }
         // else keep looking up
         tmp = node;
         tmp->GetParentNode(getter_AddRefs(node));
       }
     }
     // if this is the first node, we've found, remember it as the format
     if (formatStr.EqualsLiteral("x"))
       formatStr = format;
     // else make sure it matches previously found format
     else if (format != formatStr)
     {
       bMixed = true;
       break;
     }
   }
   *aMixed = bMixed;
   outFormat = formatStr;
   return res;
 }
 nsresult
 nsHTMLEditRules::AppendInnerFormatNodes(nsCOMArray<nsIDOMNode>& aArray,
                                         nsIDOMNode *aNode)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
   return AppendInnerFormatNodes(aArray, node);
 }
 nsresult
 nsHTMLEditRules::AppendInnerFormatNodes(nsCOMArray<nsIDOMNode>& aArray,
                                         nsINode* aNode)
 {
   MOZ_ASSERT(aNode);
   // we only need to place any one inline inside this node onto
   // the list.  They are all the same for purposes of determining
   // paragraph style.  We use foundInline to track this as we are
   // going through the children in the loop below.
   bool foundInline = false;
   for (nsIContent* child = aNode->GetFirstChild();
        child;
        child = child->GetNextSibling()) {
     bool isBlock = IsBlockNode(child->AsDOMNode());
     bool isFormat = nsHTMLEditUtils::IsFormatNode(child);
     if (isBlock && !isFormat) {
       // if it's a div, etc, recurse
       AppendInnerFormatNodes(aArray, child);
     } else if (isFormat) {
       aArray.AppendObject(child->AsDOMNode());
     } else if (!foundInline) {
       // if this is the first inline we've found, use it
       foundInline = true;
       aArray.AppendObject(child->AsDOMNode());
     }
   }
   return NS_OK;
 }
 nsresult
 nsHTMLEditRules::GetFormatString(nsIDOMNode *aNode, nsAString &outFormat)
 {
   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
   if (nsHTMLEditUtils::IsFormatNode(aNode))
   {
     nsCOMPtr<nsIAtom> atom = nsEditor::GetTag(aNode);
     atom->ToString(outFormat);
   }
   else
     outFormat.Truncate();
   return NS_OK;
 }
 /********************************************************
  *  Protected rules methods
  ********************************************************/
 nsresult
 nsHTMLEditRules::WillInsert(nsISelection *aSelection, bool *aCancel)
 {
   nsresult res = nsTextEditRules::WillInsert(aSelection, aCancel);
   NS_ENSURE_SUCCESS(res, res);
   // Adjust selection to prevent insertion after a moz-BR.
   // this next only works for collapsed selections right now,
   // because selection is a pain to work with when not collapsed.
   // (no good way to extend start or end of selection), so we ignore
   // those types of selections.
   if (!aSelection->Collapsed()) {
     return NS_OK;
   }
   // if we are after a mozBR in the same block, then move selection
   // to be before it
   nsCOMPtr<nsIDOMNode> selNode, priorNode;
   int32_t selOffset;
   // get the (collapsed) selection location
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(selNode),
                                            &selOffset);
   NS_ENSURE_SUCCESS(res, res);
   // get prior node
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetPriorHTMLNode(selNode, selOffset,
                                       address_of(priorNode));
   if (NS_SUCCEEDED(res) && priorNode && nsTextEditUtils::IsMozBR(priorNode))
   {
     nsCOMPtr<nsIDOMNode> block1, block2;
     if (IsBlockNode(selNode)) {
       block1 = selNode;
     }
     else {
       NS_ENSURE_STATE(mHTMLEditor);
       block1 = mHTMLEditor->GetBlockNodeParent(selNode);
     }
     NS_ENSURE_STATE(mHTMLEditor);
     block2 = mHTMLEditor->GetBlockNodeParent(priorNode);
     if (block1 == block2)
     {
       // if we are here then the selection is right after a mozBR
       // that is in the same block as the selection.  We need to move
       // the selection start to be before the mozBR.
       selNode = nsEditor::GetNodeLocation(priorNode, &selOffset);
       res = aSelection->Collapse(selNode,selOffset);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   if (mDidDeleteSelection &&
       (mTheAction == EditAction::insertText ||
        mTheAction == EditAction::insertIMEText ||
        mTheAction == EditAction::deleteSelection)) {
     res = ReapplyCachedStyles();
     NS_ENSURE_SUCCESS(res, res);
   }
   // For most actions we want to clear the cached styles, but there are
   // exceptions
   if (!IsStyleCachePreservingAction(mTheAction)) {
     ClearCachedStyles();
   }
   return NS_OK;
 }
 nsresult
 nsHTMLEditRules::WillInsertText(EditAction aAction,
                                 Selection*       aSelection,
                                 bool            *aCancel,
                                 bool            *aHandled,
                                 const nsAString *inString,
                                 nsAString       *outString,
                                 int32_t          aMaxLength)
 {
   if (!aSelection || !aCancel || !aHandled) { return NS_ERROR_NULL_POINTER; }
   if (inString->IsEmpty() && aAction != EditAction::insertIMEText) {
     // HACK: this is a fix for bug 19395
     // I can't outlaw all empty insertions
     // because IME transaction depend on them
     // There is more work to do to make the
     // world safe for IME.
     *aCancel = true;
     *aHandled = false;
     return NS_OK;
   }
   // initialize out param
   *aCancel = false;
   *aHandled = true;
   nsresult res;
   nsCOMPtr<nsIDOMNode> selNode;
   int32_t selOffset;
   // If the selection isn't collapsed, delete it.  Don't delete existing inline
   // tags, because we're hopefully going to insert text (bug 787432).
   if (!aSelection->Collapsed()) {
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->DeleteSelection(nsIEditor::eNone, nsIEditor::eNoStrip);
     NS_ENSURE_SUCCESS(res, res);
   }
   res = WillInsert(aSelection, aCancel);
   NS_ENSURE_SUCCESS(res, res);
   // initialize out param
   // we want to ignore result of WillInsert()
   *aCancel = false;
   // we need to get the doc
   NS_ENSURE_STATE(mHTMLEditor);
   nsCOMPtr<nsIDOMDocument> doc = mHTMLEditor->GetDOMDocument();
   NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);
   // for every property that is set, insert a new inline style node
   res = CreateStyleForInsertText(aSelection, doc);
   NS_ENSURE_SUCCESS(res, res);
   // get the (collapsed) selection location
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(selNode), &selOffset);
   NS_ENSURE_SUCCESS(res, res);
   // dont put text in places that can't have it
   NS_ENSURE_STATE(mHTMLEditor);
   if (!mHTMLEditor->IsTextNode(selNode) &&
       (!mHTMLEditor ||
        !mHTMLEditor->CanContainTag(selNode, nsGkAtoms::textTagName))) {
     return NS_ERROR_FAILURE;
   }
   if (aAction == EditAction::insertIMEText) {
     // Right now the nsWSRunObject code bails on empty strings, but IME needs
     // the InsertTextImpl() call to still happen since empty strings are meaningful there.
     if (inString->IsEmpty())
     {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->InsertTextImpl(*inString, address_of(selNode), &selOffset, doc);
     }
     else
     {
       NS_ENSURE_STATE(mHTMLEditor);
       nsWSRunObject wsObj(mHTMLEditor, selNode, selOffset);
       res = wsObj.InsertText(*inString, address_of(selNode), &selOffset, doc);
     }
     NS_ENSURE_SUCCESS(res, res);
   }
   else // aAction == kInsertText
   {
     // find where we are
     nsCOMPtr<nsIDOMNode> curNode = selNode;
     int32_t curOffset = selOffset;
     // is our text going to be PREformatted?
     // We remember this so that we know how to handle tabs.
     bool isPRE;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->IsPreformatted(selNode, &isPRE);
     NS_ENSURE_SUCCESS(res, res);
     // turn off the edit listener: we know how to
     // build the "doc changed range" ourselves, and it's
     // must faster to do it once here than to track all
     // the changes one at a time.
     nsAutoLockListener lockit(&mListenerEnabled);
     // don't spaz my selection in subtransactions
     NS_ENSURE_STATE(mHTMLEditor);
     nsAutoTxnsConserveSelection dontSpazMySelection(mHTMLEditor);
     nsAutoString tString(*inString);
     const char16_t *unicodeBuf = tString.get();
     nsCOMPtr<nsIDOMNode> unused;
     int32_t pos = 0;
     NS_NAMED_LITERAL_STRING(newlineStr, LFSTR);
     // for efficiency, break out the pre case separately.  This is because
     // its a lot cheaper to search the input string for only newlines than
     // it is to search for both tabs and newlines.
     if (isPRE || IsPlaintextEditor())
     {
       while (unicodeBuf && (pos != -1) && (pos < (int32_t)(*inString).Length()))
       {
         int32_t oldPos = pos;
         int32_t subStrLen;
         pos = tString.FindChar(nsCRT::LF, oldPos);
         if (pos != -1)
         {
           subStrLen = pos - oldPos;
           // if first char is newline, then use just it
           if (subStrLen == 0)
             subStrLen = 1;
         }
         else
         {
           subStrLen = tString.Length() - oldPos;
           pos = tString.Length();
         }
         nsDependentSubstring subStr(tString, oldPos, subStrLen);
         // is it a return?
         if (subStr.Equals(newlineStr))
         {
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->CreateBRImpl(address_of(curNode), &curOffset, address_of(unused), nsIEditor::eNone);
           pos++;
         }
         else
         {
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->InsertTextImpl(subStr, address_of(curNode), &curOffset, doc);
         }
         NS_ENSURE_SUCCESS(res, res);
       }
     }
     else
     {
       NS_NAMED_LITERAL_STRING(tabStr, "\t");
       NS_NAMED_LITERAL_STRING(spacesStr, "    ");
       char specialChars[] = {TAB, nsCRT::LF, 0};
       while (unicodeBuf && (pos != -1) && (pos < (int32_t)inString->Length()))
       {
         int32_t oldPos = pos;
         int32_t subStrLen;
         pos = tString.FindCharInSet(specialChars, oldPos);
         if (pos != -1)
         {
           subStrLen = pos - oldPos;
           // if first char is newline, then use just it
           if (subStrLen == 0)
             subStrLen = 1;
         }
         else
         {
           subStrLen = tString.Length() - oldPos;
           pos = tString.Length();
         }
         nsDependentSubstring subStr(tString, oldPos, subStrLen);
         NS_ENSURE_STATE(mHTMLEditor);
         nsWSRunObject wsObj(mHTMLEditor, curNode, curOffset);
         // is it a tab?
         if (subStr.Equals(tabStr))
         {
           res = wsObj.InsertText(spacesStr, address_of(curNode), &curOffset, doc);
           NS_ENSURE_SUCCESS(res, res);
           pos++;
         }
         // is it a return?
         else if (subStr.Equals(newlineStr))
         {
           res = wsObj.InsertBreak(address_of(curNode), &curOffset, address_of(unused), nsIEditor::eNone);
           NS_ENSURE_SUCCESS(res, res);
           pos++;
         }
         else
         {
           res = wsObj.InsertText(subStr, address_of(curNode), &curOffset, doc);
           NS_ENSURE_SUCCESS(res, res);
         }
         NS_ENSURE_SUCCESS(res, res);
       }
     }
     nsCOMPtr<nsISelection> selection(aSelection);
     nsCOMPtr<nsISelectionPrivate> selPriv(do_QueryInterface(selection));
     selPriv->SetInterlinePosition(false);
     if (curNode) aSelection->Collapse(curNode, curOffset);
     // manually update the doc changed range so that AfterEdit will clean up
     // the correct portion of the document.
     if (!mDocChangeRange)
     {
       nsCOMPtr<nsINode> node = do_QueryInterface(selNode);
       NS_ENSURE_STATE(node);
       mDocChangeRange = new nsRange(node);
     }
     res = mDocChangeRange->SetStart(selNode, selOffset);
     NS_ENSURE_SUCCESS(res, res);
     if (curNode)
       res = mDocChangeRange->SetEnd(curNode, curOffset);
     else
       res = mDocChangeRange->SetEnd(selNode, selOffset);
     NS_ENSURE_SUCCESS(res, res);
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::WillLoadHTML(nsISelection *aSelection, bool *aCancel)
 {
   NS_ENSURE_TRUE(aSelection && aCancel, NS_ERROR_NULL_POINTER);
   *aCancel = false;
   // Delete mBogusNode if it exists. If we really need one,
   // it will be added during post-processing in AfterEditInner().
   if (mBogusNode)
   {
     mEditor->DeleteNode(mBogusNode);
     mBogusNode = nullptr;
   }
   return NS_OK;
 }
 nsresult
 nsHTMLEditRules::WillInsertBreak(Selection* aSelection,
                                  bool* aCancel, bool* aHandled)
 {
   if (!aSelection || !aCancel || !aHandled) {
     return NS_ERROR_NULL_POINTER;
   }
   // initialize out params
   *aCancel = false;
   *aHandled = false;
   // if the selection isn't collapsed, delete it.
   nsresult res = NS_OK;
   if (!aSelection->Collapsed()) {
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->DeleteSelection(nsIEditor::eNone, nsIEditor::eStrip);
     NS_ENSURE_SUCCESS(res, res);
   }
   res = WillInsert(aSelection, aCancel);
   NS_ENSURE_SUCCESS(res, res);
   // initialize out param
   // we want to ignore result of WillInsert()
   *aCancel = false;
   // split any mailcites in the way.
   // should we abort this if we encounter table cell boundaries?
   if (IsMailEditor()) {
     res = SplitMailCites(aSelection, IsPlaintextEditor(), aHandled);
     NS_ENSURE_SUCCESS(res, res);
     if (*aHandled) {
       return NS_OK;
     }
   }
   // smart splitting rules
   nsCOMPtr<nsIDOMNode> node;
   int32_t offset;
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(node),
                                            &offset);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
   // do nothing if the node is read-only
   NS_ENSURE_STATE(mHTMLEditor);
   if (!mHTMLEditor->IsModifiableNode(node)) {
     *aCancel = true;
     return NS_OK;
   }
   // identify the block
   nsCOMPtr<nsIDOMNode> blockParent;
   if (IsBlockNode(node)) {
     blockParent = node;
   } else {
     NS_ENSURE_STATE(mHTMLEditor);
     blockParent = mHTMLEditor->GetBlockNodeParent(node);
   }
   NS_ENSURE_TRUE(blockParent, NS_ERROR_FAILURE);
   // if the active editing host is an inline element, or if the active editing
   // host is the block parent itself, just append a br.
   NS_ENSURE_STATE(mHTMLEditor);
   nsCOMPtr<nsIContent> hostContent = mHTMLEditor->GetActiveEditingHost();
   nsCOMPtr<nsIDOMNode> hostNode = do_QueryInterface(hostContent);
   if (!nsEditorUtils::IsDescendantOf(blockParent, hostNode)) {
     res = StandardBreakImpl(node, offset, aSelection);
     NS_ENSURE_SUCCESS(res, res);
     *aHandled = true;
     return NS_OK;
   }
   // if block is empty, populate with br.  (for example, imagine a div that
   // contains the word "text".  the user selects "text" and types return.
   // "text" is deleted leaving an empty block.  we want to put in one br to
   // make block have a line.  then code further below will put in a second br.)
   bool isEmpty;
   IsEmptyBlock(blockParent, &isEmpty);
   if (isEmpty) {
     uint32_t blockLen;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetLengthOfDOMNode(blockParent, blockLen);
     NS_ENSURE_SUCCESS(res, res);
     nsCOMPtr<nsIDOMNode> brNode;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->CreateBR(blockParent, blockLen, address_of(brNode));
     NS_ENSURE_SUCCESS(res, res);
   }
   nsCOMPtr<nsIDOMNode> listItem = IsInListItem(blockParent);
   if (listItem && listItem != hostNode) {
     ReturnInListItem(aSelection, listItem, node, offset);
     *aHandled = true;
     return NS_OK;
   } else if (nsHTMLEditUtils::IsHeader(blockParent)) {
     // headers: close (or split) header
     ReturnInHeader(aSelection, blockParent, node, offset);
     *aHandled = true;
     return NS_OK;
   } else if (nsHTMLEditUtils::IsParagraph(blockParent)) {
     // paragraphs: special rules to look for <br>s
     res = ReturnInParagraph(aSelection, blockParent, node, offset,
                             aCancel, aHandled);
     NS_ENSURE_SUCCESS(res, res);
     // fall through, we may not have handled it in ReturnInParagraph()
   }
   // if not already handled then do the standard thing
   if (!(*aHandled)) {
     *aHandled = true;
     return StandardBreakImpl(node, offset, aSelection);
   }
   return NS_OK;
 }
 nsresult
 nsHTMLEditRules::StandardBreakImpl(nsIDOMNode* aNode, int32_t aOffset,
                                    nsISelection* aSelection)
 {
   nsCOMPtr<nsIDOMNode> brNode;
   bool bAfterBlock = false;
   bool bBeforeBlock = false;
   nsresult res = NS_OK;
   nsCOMPtr<nsIDOMNode> node(aNode);
   nsCOMPtr<nsISelectionPrivate> selPriv(do_QueryInterface(aSelection));
   if (IsPlaintextEditor()) {
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->CreateBR(node, aOffset, address_of(brNode));
   } else {
     NS_ENSURE_STATE(mHTMLEditor);
     nsWSRunObject wsObj(mHTMLEditor, node, aOffset);
     nsCOMPtr<nsIDOMNode> visNode, linkNode;
     int32_t visOffset = 0, newOffset;
     WSType wsType;
     wsObj.PriorVisibleNode(node, aOffset, address_of(visNode),
                            &visOffset, &wsType);
     if (wsType & WSType::block) {
       bAfterBlock = true;
     }
     wsObj.NextVisibleNode(node, aOffset, address_of(visNode),
                           &visOffset, &wsType);
     if (wsType & WSType::block) {
       bBeforeBlock = true;
     }
     NS_ENSURE_STATE(mHTMLEditor);
     if (mHTMLEditor->IsInLink(node, address_of(linkNode))) {
       // split the link
       nsCOMPtr<nsIDOMNode> linkParent;
       res = linkNode->GetParentNode(getter_AddRefs(linkParent));
       NS_ENSURE_SUCCESS(res, res);
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->SplitNodeDeep(linkNode, node, aOffset,
                                        &newOffset, true);
       NS_ENSURE_SUCCESS(res, res);
       // reset {node,aOffset} to the point where link was split
       node = linkParent;
       aOffset = newOffset;
     }
     res = wsObj.InsertBreak(address_of(node), &aOffset,
                             address_of(brNode), nsIEditor::eNone);
   }
   NS_ENSURE_SUCCESS(res, res);
   node = nsEditor::GetNodeLocation(brNode, &aOffset);
   NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
   if (bAfterBlock && bBeforeBlock) {
     // we just placed a br between block boundaries.  This is the one case
     // where we want the selection to be before the br we just placed, as the
     // br will be on a new line, rather than at end of prior line.
     selPriv->SetInterlinePosition(true);
     res = aSelection->Collapse(node, aOffset);
   } else {
     NS_ENSURE_STATE(mHTMLEditor);
     nsWSRunObject wsObj(mHTMLEditor, node, aOffset+1);
     nsCOMPtr<nsIDOMNode> secondBR;
     int32_t visOffset = 0;
     WSType wsType;
     wsObj.NextVisibleNode(node, aOffset+1, address_of(secondBR),
                           &visOffset, &wsType);
     if (wsType == WSType::br) {
       // the next thing after the break we inserted is another break.  Move
       // the 2nd break to be the first breaks sibling.  This will prevent them
       // from being in different inline nodes, which would break
       // SetInterlinePosition().  It will also assure that if the user clicks
       // away and then clicks back on their new blank line, they will still
       // get the style from the line above.
       int32_t brOffset;
       nsCOMPtr<nsIDOMNode> brParent = nsEditor::GetNodeLocation(secondBR, &brOffset);
       if (brParent != node || brOffset != aOffset + 1) {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->MoveNode(secondBR, node, aOffset+1);
         NS_ENSURE_SUCCESS(res, res);
       }
     }
     // SetInterlinePosition(true) means we want the caret to stick to the
     // content on the "right".  We want the caret to stick to whatever is past
     // the break.  This is because the break is on the same line we were on,
     // but the next content will be on the following line.
     // An exception to this is if the break has a next sibling that is a block
     // node.  Then we stick to the left to avoid an uber caret.
     nsCOMPtr<nsIDOMNode> siblingNode;
     brNode->GetNextSibling(getter_AddRefs(siblingNode));
     if (siblingNode && IsBlockNode(siblingNode)) {
       selPriv->SetInterlinePosition(false);
     } else {
       selPriv->SetInterlinePosition(true);
     }
     res = aSelection->Collapse(node, aOffset+1);
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::DidInsertBreak(nsISelection *aSelection, nsresult aResult)
 {
   return NS_OK;
 }
 nsresult
 nsHTMLEditRules::SplitMailCites(nsISelection *aSelection, bool aPlaintext, bool *aHandled)
 {
   NS_ENSURE_TRUE(aSelection && aHandled, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsISelectionPrivate> selPriv(do_QueryInterface(aSelection));
   nsCOMPtr<nsIDOMNode> citeNode, selNode, leftCite, rightCite;
   int32_t selOffset, newOffset;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(selNode), &selOffset);
   NS_ENSURE_SUCCESS(res, res);
   res = GetTopEnclosingMailCite(selNode, address_of(citeNode), aPlaintext);
   NS_ENSURE_SUCCESS(res, res);
   if (citeNode)
   {
     // If our selection is just before a break, nudge it to be
     // just after it.  This does two things for us.  It saves us the trouble of having to add
     // a break here ourselves to preserve the "blockness" of the inline span mailquote
     // (in the inline case), and :
     // it means the break won't end up making an empty line that happens to be inside a
     // mailquote (in either inline or block case).
     // The latter can confuse a user if they click there and start typing,
     // because being in the mailquote may affect wrapping behavior, or font color, etc.
     NS_ENSURE_STATE(mHTMLEditor);
     nsWSRunObject wsObj(mHTMLEditor, selNode, selOffset);
     nsCOMPtr<nsIDOMNode> visNode;
     int32_t visOffset=0;
     WSType wsType;
     wsObj.NextVisibleNode(selNode, selOffset, address_of(visNode),
                           &visOffset, &wsType);
     if (wsType == WSType::br) {
       // ok, we are just before a break.  is it inside the mailquote?
       int32_t unused;
       if (nsEditorUtils::IsDescendantOf(visNode, citeNode, &unused))
       {
         // it is.  so lets reset our selection to be just after it.
         NS_ENSURE_STATE(mHTMLEditor);
         selNode = mHTMLEditor->GetNodeLocation(visNode, &selOffset);
         ++selOffset;
       }
     }
     nsCOMPtr<nsIDOMNode> brNode;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->SplitNodeDeep(citeNode, selNode, selOffset, &newOffset,
                        true, address_of(leftCite), address_of(rightCite));
     NS_ENSURE_SUCCESS(res, res);
     res = citeNode->GetParentNode(getter_AddRefs(selNode));
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->CreateBR(selNode, newOffset, address_of(brNode));
     NS_ENSURE_SUCCESS(res, res);
     // want selection before the break, and on same line
     selPriv->SetInterlinePosition(true);
     res = aSelection->Collapse(selNode, newOffset);
     NS_ENSURE_SUCCESS(res, res);
     // if citeNode wasn't a block, we might also want another break before it.
     // We need to examine the content both before the br we just added and also
     // just after it.  If we don't have another br or block boundary adjacent,
     // then we will need a 2nd br added to achieve blank line that user expects.
     if (IsInlineNode(citeNode))
     {
       NS_ENSURE_STATE(mHTMLEditor);
       nsWSRunObject wsObj(mHTMLEditor, selNode, newOffset);
       nsCOMPtr<nsIDOMNode> visNode;
       int32_t visOffset=0;
       WSType wsType;
       wsObj.PriorVisibleNode(selNode, newOffset, address_of(visNode),
                              &visOffset, &wsType);
       if (wsType == WSType::normalWS || wsType == WSType::text ||
           wsType == WSType::special) {
         NS_ENSURE_STATE(mHTMLEditor);
         nsWSRunObject wsObjAfterBR(mHTMLEditor, selNode, newOffset+1);
         wsObjAfterBR.NextVisibleNode(selNode, newOffset+1, address_of(visNode),
                                      &visOffset, &wsType);
         if (wsType == WSType::normalWS || wsType == WSType::text ||
             wsType == WSType::special) {
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->CreateBR(selNode, newOffset, address_of(brNode));
           NS_ENSURE_SUCCESS(res, res);
         }
       }
     }
     // delete any empty cites
     bool bEmptyCite = false;
     if (leftCite)
     {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->IsEmptyNode(leftCite, &bEmptyCite, true, false);
       if (NS_SUCCEEDED(res) && bEmptyCite) {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->DeleteNode(leftCite);
       }
       NS_ENSURE_SUCCESS(res, res);
     }
     if (rightCite)
     {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->IsEmptyNode(rightCite, &bEmptyCite, true, false);
       if (NS_SUCCEEDED(res) && bEmptyCite) {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->DeleteNode(rightCite);
       }
       NS_ENSURE_SUCCESS(res, res);
     }
     *aHandled = true;
   }
   return NS_OK;
 }
 nsresult
 nsHTMLEditRules::WillDeleteSelection(Selection* aSelection,
                                      nsIEditor::EDirection aAction,
                                      nsIEditor::EStripWrappers aStripWrappers,
                                      bool* aCancel,
                                      bool* aHandled)
 {
   MOZ_ASSERT(aStripWrappers == nsIEditor::eStrip ||
              aStripWrappers == nsIEditor::eNoStrip);
   if (!aSelection || !aCancel || !aHandled) { return NS_ERROR_NULL_POINTER; }
   // initialize out param
   *aCancel = false;
   *aHandled = false;
   // remember that we did a selection deletion.  Used by CreateStyleForInsertText()
   mDidDeleteSelection = true;
   // if there is only bogus content, cancel the operation
   if (mBogusNode)
   {
     *aCancel = true;
     return NS_OK;
   }
   bool bCollapsed = aSelection->Collapsed(), join = false;
   // origCollapsed is used later to determine whether we should join
   // blocks. We don't really care about bCollapsed because it will be
   // modified by ExtendSelectionForDelete later. JoinBlocks should
   // happen if the original selection is collapsed and the cursor is
   // at the end of a block element, in which case ExtendSelectionForDelete
   // would always make the selection not collapsed.
   bool origCollapsed = bCollapsed;
   nsCOMPtr<nsIDOMNode> startNode, selNode;
   int32_t startOffset, selOffset;
   // first check for table selection mode.  If so,
   // hand off to table editor.
   nsCOMPtr<nsIDOMElement> cell;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res = mHTMLEditor->GetFirstSelectedCell(nullptr, getter_AddRefs(cell));
   if (NS_SUCCEEDED(res) && cell) {
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->DeleteTableCellContents();
     *aHandled = true;
     return res;
   }
   cell = nullptr;
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(startNode), &startOffset);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(startNode, NS_ERROR_FAILURE);
   if (bCollapsed)
   {
     // if we are inside an empty block, delete it.
     NS_ENSURE_STATE(mHTMLEditor);
     nsCOMPtr<nsIContent> hostContent = mHTMLEditor->GetActiveEditingHost();
     nsCOMPtr<nsIDOMNode> hostNode = do_QueryInterface(hostContent);
     NS_ENSURE_TRUE(hostNode, NS_ERROR_FAILURE);
     res = CheckForEmptyBlock(startNode, hostNode, aSelection, aHandled);
     NS_ENSURE_SUCCESS(res, res);
     if (*aHandled) return NS_OK;
     // Test for distance between caret and text that will be deleted
     res = CheckBidiLevelForDeletion(aSelection, startNode, startOffset, aAction, aCancel);
     NS_ENSURE_SUCCESS(res, res);
     if (*aCancel) return NS_OK;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->ExtendSelectionForDelete(aSelection, &aAction);
     NS_ENSURE_SUCCESS(res, res);
     // We should delete nothing.
     if (aAction == nsIEditor::eNone)
       return NS_OK;
     // ExtendSelectionForDelete() may have changed the selection, update it
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(startNode), &startOffset);
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_TRUE(startNode, NS_ERROR_FAILURE);
     bCollapsed = aSelection->Collapsed();
   }
   if (bCollapsed)
   {
     // what's in the direction we are deleting?
     NS_ENSURE_STATE(mHTMLEditor);
     nsWSRunObject wsObj(mHTMLEditor, startNode, startOffset);
     nsCOMPtr<nsIDOMNode> visNode;
     int32_t visOffset;
     WSType wsType;
     // find next visible node
     if (aAction == nsIEditor::eNext)
       wsObj.NextVisibleNode(startNode, startOffset, address_of(visNode),
                             &visOffset, &wsType);
     else
       wsObj.PriorVisibleNode(startNode, startOffset, address_of(visNode),
                              &visOffset, &wsType);
     if (!visNode) // can't find anything to delete!
     {
       *aCancel = true;
       return res;
     }
     if (wsType == WSType::normalWS) {
       // we found some visible ws to delete.  Let ws code handle it.
       if (aAction == nsIEditor::eNext)
         res = wsObj.DeleteWSForward();
       else
         res = wsObj.DeleteWSBackward();
       *aHandled = true;
       NS_ENSURE_SUCCESS(res, res);
       res = InsertBRIfNeeded(aSelection);
       return res;
     } else if (wsType == WSType::text) {
       // found normal text to delete.
       int32_t so = visOffset;
       int32_t eo = visOffset+1;
       if (aAction == nsIEditor::ePrevious)
       {
         if (so == 0) return NS_ERROR_UNEXPECTED;
         so--;
         eo--;
       }
       else
       {
         nsCOMPtr<nsIDOMRange> range;
         res = aSelection->GetRangeAt(0, getter_AddRefs(range));
         NS_ENSURE_SUCCESS(res, res);
 #ifdef DEBUG
         nsIDOMNode *container;
         res = range->GetStartContainer(&container);
         NS_ENSURE_SUCCESS(res, res);
         NS_ASSERTION(container == visNode, "selection start not in visNode");
         res = range->GetEndContainer(&container);
         NS_ENSURE_SUCCESS(res, res);
         NS_ASSERTION(container == visNode, "selection end not in visNode");
 #endif
         res = range->GetStartOffset(&so);
         NS_ENSURE_SUCCESS(res, res);
         res = range->GetEndOffset(&eo);
         NS_ENSURE_SUCCESS(res, res);
       }
       NS_ENSURE_STATE(mHTMLEditor);
       res = nsWSRunObject::PrepareToDeleteRange(mHTMLEditor, address_of(visNode), &so, address_of(visNode), &eo);
       NS_ENSURE_SUCCESS(res, res);
       nsCOMPtr<nsIDOMCharacterData> nodeAsText(do_QueryInterface(visNode));
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->DeleteText(nodeAsText, std::min(so, eo), DeprecatedAbs(eo - so));
       *aHandled = true;
       NS_ENSURE_SUCCESS(res, res);
       res = InsertBRIfNeeded(aSelection);
       return res;
     } else if (wsType == WSType::special || wsType == WSType::br ||
                nsHTMLEditUtils::IsHR(visNode)) {
       // short circuit for invisible breaks.  delete them and recurse.
       if (nsTextEditUtils::IsBreak(visNode) &&
           (!mHTMLEditor || !mHTMLEditor->IsVisBreak(visNode)))
       {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->DeleteNode(visNode);
         NS_ENSURE_SUCCESS(res, res);
         return WillDeleteSelection(aSelection, aAction, aStripWrappers,
                                    aCancel, aHandled);
       }
       // special handling for backspace when positioned after <hr>
       if (aAction == nsIEditor::ePrevious && nsHTMLEditUtils::IsHR(visNode))
       {
         /*
           Only if the caret is positioned at the end-of-hr-line position,
           we want to delete the <hr>.
           In other words, we only want to delete, if
           our selection position (indicated by startNode and startOffset)
           is the position directly after the <hr>,
           on the same line as the <hr>.
           To detect this case we check:
           startNode == parentOfVisNode
           and
           startOffset -1 == visNodeOffsetToVisNodeParent
           and
           interline position is false (left)
           In any other case we set the position to
           startnode -1 and interlineposition to false,
           only moving the caret to the end-of-hr-line position.
         */
         bool moveOnly = true;
         selNode = nsEditor::GetNodeLocation(visNode, &selOffset);
         bool interLineIsRight;
         res = aSelection->GetInterlinePosition(&interLineIsRight);
         NS_ENSURE_SUCCESS(res, res);
         if (startNode == selNode &&
             startOffset -1 == selOffset &&
             !interLineIsRight)
         {
           moveOnly = false;
         }
         if (moveOnly)
         {
           // Go to the position after the <hr>, but to the end of the <hr> line
           // by setting the interline position to left.
           ++selOffset;
           res = aSelection->Collapse(selNode, selOffset);
           aSelection->SetInterlinePosition(false);
           mDidExplicitlySetInterline = true;
           *aHandled = true;
           // There is one exception to the move only case.
           // If the <hr> is followed by a <br> we want to delete the <br>.
           WSType otherWSType;
           nsCOMPtr<nsIDOMNode> otherNode;
           int32_t otherOffset;
           wsObj.NextVisibleNode(startNode, startOffset, address_of(otherNode),
                                 &otherOffset, &otherWSType);
           if (otherWSType == WSType::br) {
             // Delete the <br>
             NS_ENSURE_STATE(mHTMLEditor);
             res = nsWSRunObject::PrepareToDeleteNode(mHTMLEditor, otherNode);
             NS_ENSURE_SUCCESS(res, res);
             NS_ENSURE_STATE(mHTMLEditor);
             res = mHTMLEditor->DeleteNode(otherNode);
             NS_ENSURE_SUCCESS(res, res);
           }
           return NS_OK;
         }
         // else continue with normal delete code
       }
       // found break or image, or hr.
       NS_ENSURE_STATE(mHTMLEditor);
       res = nsWSRunObject::PrepareToDeleteNode(mHTMLEditor, visNode);
       NS_ENSURE_SUCCESS(res, res);
       // remember sibling to visnode, if any
       nsCOMPtr<nsIDOMNode> sibling, stepbrother;
       NS_ENSURE_STATE(mHTMLEditor);
       mHTMLEditor->GetPriorHTMLSibling(visNode, address_of(sibling));
       // delete the node, and join like nodes if appropriate
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->DeleteNode(visNode);
       NS_ENSURE_SUCCESS(res, res);
       // we did something, so lets say so.
       *aHandled = true;
       // is there a prior node and are they siblings?
       if (sibling) {
         NS_ENSURE_STATE(mHTMLEditor);
         mHTMLEditor->GetNextHTMLSibling(sibling, address_of(stepbrother));
       }
       if (startNode == stepbrother)
       {
         // are they both text nodes?
         NS_ENSURE_STATE(mHTMLEditor);
         if (mHTMLEditor->IsTextNode(startNode) &&
             (!mHTMLEditor || mHTMLEditor->IsTextNode(sibling)))
         {
           NS_ENSURE_STATE(mHTMLEditor);
           // if so, join them!
           res = JoinNodesSmart(sibling, startNode, address_of(selNode), &selOffset);
           NS_ENSURE_SUCCESS(res, res);
           // fix up selection
           res = aSelection->Collapse(selNode, selOffset);
         }
       }
       NS_ENSURE_SUCCESS(res, res);
       res = InsertBRIfNeeded(aSelection);
       return res;
     } else if (wsType == WSType::otherBlock) {
       // make sure it's not a table element.  If so, cancel the operation
       // (translation: users cannot backspace or delete across table cells)
       if (nsHTMLEditUtils::IsTableElement(visNode))
       {
         *aCancel = true;
         return NS_OK;
       }
       // next to a block.  See if we are between a block and a br.  If so, we really
       // want to delete the br.  Else join content at selection to the block.
       bool bDeletedBR = false;
       WSType otherWSType;
       nsCOMPtr<nsIDOMNode> otherNode;
       int32_t otherOffset;
       // find node in other direction
       if (aAction == nsIEditor::eNext)
         wsObj.PriorVisibleNode(startNode, startOffset, address_of(otherNode),
                                &otherOffset, &otherWSType);
       else
         wsObj.NextVisibleNode(startNode, startOffset, address_of(otherNode),
                               &otherOffset, &otherWSType);
       // first find the adjacent node in the block
       nsCOMPtr<nsIDOMNode> leafNode, leftNode, rightNode;
       if (aAction == nsIEditor::ePrevious)
       {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->GetLastEditableLeaf( visNode, address_of(leafNode));
         NS_ENSURE_SUCCESS(res, res);
         leftNode = leafNode;
         rightNode = startNode;
       }
       else
       {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->GetFirstEditableLeaf( visNode, address_of(leafNode));
         NS_ENSURE_SUCCESS(res, res);
         leftNode = startNode;
         rightNode = leafNode;
       }
       if (nsTextEditUtils::IsBreak(otherNode))
       {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->DeleteNode(otherNode);
         NS_ENSURE_SUCCESS(res, res);
         *aHandled = true;
         bDeletedBR = true;
       }
       // don't cross table boundaries
       if (leftNode && rightNode && InDifferentTableElements(leftNode, rightNode)) {
         return NS_OK;
       }
       if (bDeletedBR)
       {
         // put selection at edge of block and we are done.
         nsCOMPtr<nsIDOMNode> newSelNode;
         int32_t newSelOffset;
         res = GetGoodSelPointForNode(leafNode, aAction, address_of(newSelNode), &newSelOffset);
         NS_ENSURE_SUCCESS(res, res);
         aSelection->Collapse(newSelNode, newSelOffset);
         return res;
       }
       // else we are joining content to block
       nsCOMPtr<nsIDOMNode> selPointNode = startNode;
       int32_t selPointOffset = startOffset;
       {
         NS_ENSURE_STATE(mHTMLEditor);
         nsAutoTrackDOMPoint tracker(mHTMLEditor->mRangeUpdater, address_of(selPointNode), &selPointOffset);
         res = JoinBlocks(leftNode, rightNode, aCancel);
         *aHandled = true;
         NS_ENSURE_SUCCESS(res, res);
       }
       aSelection->Collapse(selPointNode, selPointOffset);
       return res;
     } else if (wsType == WSType::thisBlock) {
       // at edge of our block.  Look beside it and see if we can join to an adjacent block
       // make sure it's not a table element.  If so, cancel the operation
       // (translation: users cannot backspace or delete across table cells)
       if (nsHTMLEditUtils::IsTableElement(visNode))
       {
         *aCancel = true;
         return NS_OK;
       }
       // first find the relavent nodes
       nsCOMPtr<nsIDOMNode> leftNode, rightNode;
       if (aAction == nsIEditor::ePrevious)
       {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->GetPriorHTMLNode(visNode, address_of(leftNode));
         NS_ENSURE_SUCCESS(res, res);
         rightNode = startNode;
       }
       else
       {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->GetNextHTMLNode( visNode, address_of(rightNode));
         NS_ENSURE_SUCCESS(res, res);
         leftNode = startNode;
       }
       // nothing to join
       if (!leftNode || !rightNode)
       {
         *aCancel = true;
         return NS_OK;
       }
       // don't cross table boundaries -- cancel it
       if (InDifferentTableElements(leftNode, rightNode)) {
         *aCancel = true;
         return NS_OK;
       }
       nsCOMPtr<nsIDOMNode> selPointNode = startNode;
       int32_t selPointOffset = startOffset;
       {
         NS_ENSURE_STATE(mHTMLEditor);
         nsAutoTrackDOMPoint tracker(mHTMLEditor->mRangeUpdater, address_of(selPointNode), &selPointOffset);
         res = JoinBlocks(leftNode, rightNode, aCancel);
         *aHandled = true;
         NS_ENSURE_SUCCESS(res, res);
       }
       aSelection->Collapse(selPointNode, selPointOffset);
       return res;
     }
   }
   // else we have a non collapsed selection
   // first adjust the selection
   res = ExpandSelectionForDeletion(aSelection);
   NS_ENSURE_SUCCESS(res, res);
   // remember that we did a ranged delete for the benefit of AfterEditInner().
   mDidRangedDelete = true;
   // refresh start and end points
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(startNode), &startOffset);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(startNode, NS_ERROR_FAILURE);
   nsCOMPtr<nsIDOMNode> endNode;
   int32_t endOffset;
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetEndNodeAndOffset(aSelection, getter_AddRefs(endNode), &endOffset);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(endNode, NS_ERROR_FAILURE);
   // figure out if the endpoints are in nodes that can be merged
   // adjust surrounding whitespace in preperation to delete selection
   if (!IsPlaintextEditor())
   {
     NS_ENSURE_STATE(mHTMLEditor);
     nsAutoTxnsConserveSelection dontSpazMySelection(mHTMLEditor);
     res = nsWSRunObject::PrepareToDeleteRange(mHTMLEditor,
                                             address_of(startNode), &startOffset,
                                             address_of(endNode), &endOffset);
     NS_ENSURE_SUCCESS(res, res);
   }
   {
     // track location of where we are deleting
     NS_ENSURE_STATE(mHTMLEditor);
     nsAutoTrackDOMPoint startTracker(mHTMLEditor->mRangeUpdater,
                                      address_of(startNode), &startOffset);
     nsAutoTrackDOMPoint endTracker(mHTMLEditor->mRangeUpdater,
                                    address_of(endNode), &endOffset);
     // we are handling all ranged deletions directly now.
     *aHandled = true;
     if (endNode == startNode)
     {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->DeleteSelectionImpl(aAction, aStripWrappers);
       NS_ENSURE_SUCCESS(res, res);
     }
     else
     {
       // figure out mailcite ancestors
       nsCOMPtr<nsIDOMNode> endCiteNode, startCiteNode;
       res = GetTopEnclosingMailCite(startNode, address_of(startCiteNode),
                                     IsPlaintextEditor());
       NS_ENSURE_SUCCESS(res, res);
       res = GetTopEnclosingMailCite(endNode, address_of(endCiteNode),
                                     IsPlaintextEditor());
       NS_ENSURE_SUCCESS(res, res);
       // if we only have a mailcite at one of the two endpoints, set the directionality
       // of the deletion so that the selection will end up outside the mailcite.
       if (startCiteNode && !endCiteNode)
       {
         aAction = nsIEditor::eNext;
       }
       else if (!startCiteNode && endCiteNode)
       {
         aAction = nsIEditor::ePrevious;
       }
       // figure out block parents
       nsCOMPtr<nsIDOMNode> leftParent;
       nsCOMPtr<nsIDOMNode> rightParent;
       if (IsBlockNode(startNode))
         leftParent = startNode;
       else {
         NS_ENSURE_STATE(mHTMLEditor);
         leftParent = mHTMLEditor->GetBlockNodeParent(startNode);
       }
       if (IsBlockNode(endNode))
         rightParent = endNode;
       else {
         NS_ENSURE_STATE(mHTMLEditor);
         rightParent = mHTMLEditor->GetBlockNodeParent(endNode);
       }
       // are endpoint block parents the same?  use default deletion
       if (leftParent == rightParent)
       {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->DeleteSelectionImpl(aAction, aStripWrappers);
       }
       else
       {
         // deleting across blocks
         // are the blocks of same type?
         NS_ENSURE_STATE(leftParent && rightParent);
         // are the blocks siblings?
         nsCOMPtr<nsIDOMNode> leftBlockParent;
         nsCOMPtr<nsIDOMNode> rightBlockParent;
         leftParent->GetParentNode(getter_AddRefs(leftBlockParent));
         rightParent->GetParentNode(getter_AddRefs(rightBlockParent));
         // MOOSE: this could conceivably screw up a table.. fix me.
         if (   (leftBlockParent == rightBlockParent)
             && (!mHTMLEditor || mHTMLEditor->NodesSameType(leftParent, rightParent))  )
         {
           NS_ENSURE_STATE(mHTMLEditor);
           if (nsHTMLEditUtils::IsParagraph(leftParent))
           {
             // first delete the selection
             NS_ENSURE_STATE(mHTMLEditor);
             res = mHTMLEditor->DeleteSelectionImpl(aAction, aStripWrappers);
             NS_ENSURE_SUCCESS(res, res);
             // then join para's, insert break
             NS_ENSURE_STATE(mHTMLEditor);
             res = mHTMLEditor->JoinNodeDeep(leftParent,rightParent,address_of(selNode),&selOffset);
             NS_ENSURE_SUCCESS(res, res);
             // fix up selection
             res = aSelection->Collapse(selNode,selOffset);
             return res;
           }
           if (nsHTMLEditUtils::IsListItem(leftParent)
               || nsHTMLEditUtils::IsHeader(leftParent))
           {
             // first delete the selection
             NS_ENSURE_STATE(mHTMLEditor);
             res = mHTMLEditor->DeleteSelectionImpl(aAction, aStripWrappers);
             NS_ENSURE_SUCCESS(res, res);
             // join blocks
             NS_ENSURE_STATE(mHTMLEditor);
             res = mHTMLEditor->JoinNodeDeep(leftParent,rightParent,address_of(selNode),&selOffset);
             NS_ENSURE_SUCCESS(res, res);
             // fix up selection
             res = aSelection->Collapse(selNode,selOffset);
             return res;
           }
         }
         // else blocks not same type, or not siblings.  Delete everything except
         // table elements.
         join = true;
         uint32_t rangeCount = aSelection->GetRangeCount();
         for (uint32_t rangeIdx = 0; rangeIdx < rangeCount; ++rangeIdx) {
           nsRefPtr<nsRange> range = aSelection->GetRangeAt(rangeIdx);
           // build a list of nodes in the range
           nsCOMArray<nsIDOMNode> arrayOfNodes;
           nsTrivialFunctor functor;
           nsDOMSubtreeIterator iter;
           res = iter.Init(range);
           NS_ENSURE_SUCCESS(res, res);
           res = iter.AppendList(functor, arrayOfNodes);
           NS_ENSURE_SUCCESS(res, res);
           // now that we have the list, delete non table elements
           int32_t listCount = arrayOfNodes.Count();
           for (int32_t j = 0; j < listCount; j++) {
             nsCOMPtr<nsINode> somenode = do_QueryInterface(arrayOfNodes[0]);
             NS_ENSURE_STATE(somenode);
             DeleteNonTableElements(somenode);
             arrayOfNodes.RemoveObjectAt(0);
             // If something visible is deleted, no need to join.
             // Visible means all nodes except non-visible textnodes and breaks.
             if (join && origCollapsed) {
               if (!somenode->IsContent()) {
                 join = false;
                 continue;
               }
               nsCOMPtr<nsIContent> content = somenode->AsContent();
               if (content->NodeType() == nsIDOMNode::TEXT_NODE) {
                 NS_ENSURE_STATE(mHTMLEditor);
                 mHTMLEditor->IsVisTextNode(content, &join, true);
               } else {
                 NS_ENSURE_STATE(mHTMLEditor);
                 join = content->IsHTML(nsGkAtoms::br) &&
                        !mHTMLEditor->IsVisBreak(somenode->AsDOMNode());
               }
             }
           }
         }
         // check endopints for possible text deletion.
         // we can assume that if text node is found, we can
         // delete to end or to begining as appropriate,
         // since the case where both sel endpoints in same
         // text node was already handled (we wouldn't be here)
         NS_ENSURE_STATE(mHTMLEditor);
         if ( mHTMLEditor->IsTextNode(startNode) )
         {
           // delete to last character
           nsCOMPtr<nsIDOMCharacterData>nodeAsText;
           uint32_t len;
           nodeAsText = do_QueryInterface(startNode);
           nodeAsText->GetLength(&len);
           if (len > (uint32_t)startOffset)
           {
             NS_ENSURE_STATE(mHTMLEditor);
             res = mHTMLEditor->DeleteText(nodeAsText,startOffset,len-startOffset);
             NS_ENSURE_SUCCESS(res, res);
           }
         }
         NS_ENSURE_STATE(mHTMLEditor);
         if ( mHTMLEditor->IsTextNode(endNode) )
         {
           // delete to first character
           nsCOMPtr<nsIDOMCharacterData>nodeAsText;
           nodeAsText = do_QueryInterface(endNode);
           if (endOffset)
           {
             NS_ENSURE_STATE(mHTMLEditor);
             res = mHTMLEditor->DeleteText(nodeAsText,0,endOffset);
             NS_ENSURE_SUCCESS(res, res);
           }
         }
         if (join) {
           res = JoinBlocks(leftParent, rightParent, aCancel);
           NS_ENSURE_SUCCESS(res, res);
         }
       }
     }
   }
   //If we're joining blocks: if deleting forward the selection should be
   //collapsed to the end of the selection, if deleting backward the selection
   //should be collapsed to the beginning of the selection. But if we're not
   //joining then the selection should collapse to the beginning of the
   //selection if we'redeleting forward, because the end of the selection will
   //still be in the next block. And same thing for deleting backwards
   //(selection should collapse to the end, because the beginning will still
   //be in the first block). See Bug 507936
   if (join ? aAction == nsIEditor::eNext : aAction == nsIEditor::ePrevious)
   {
     res = aSelection->Collapse(endNode,endOffset);
   }
   else
   {
     res = aSelection->Collapse(startNode,startOffset);
   }
   return res;
 }
 /*****************************************************************************************************
 *    InsertBRIfNeeded: determines if a br is needed for current selection to not be spastic.
 *    If so, it inserts one.  Callers responsibility to only call with collapsed selection.
 *         nsISelection *aSelection      the collapsed selection
 */
 nsresult
 nsHTMLEditRules::InsertBRIfNeeded(nsISelection *aSelection)
 {
   NS_ENSURE_TRUE(aSelection, NS_ERROR_NULL_POINTER);
   // get selection
   nsCOMPtr<nsIDOMNode> node;
   int32_t offset;
   nsresult res = mEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(node), &offset);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
   // inline elements don't need any br
   if (!IsBlockNode(node))
     return res;
   // examine selection
   NS_ENSURE_STATE(mHTMLEditor);
   nsWSRunObject wsObj(mHTMLEditor, node, offset);
   if (((wsObj.mStartReason & WSType::block) ||
        (wsObj.mStartReason & WSType::br)) &&
       (wsObj.mEndReason & WSType::block)) {
     // if we are tucked between block boundaries then insert a br
     // first check that we are allowed to
     NS_ENSURE_STATE(mHTMLEditor);
     if (mHTMLEditor->CanContainTag(node, nsGkAtoms::br)) {
       nsCOMPtr<nsIDOMNode> brNode;
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->CreateBR(node, offset, address_of(brNode), nsIEditor::ePrevious);
     }
   }
   return res;
 }
 /*****************************************************************************************************
 *    GetGoodSelPointForNode: Finds where at a node you would want to set the selection if you were
 *    trying to have a caret next to it.
 *         nsIDOMNode *aNode                  the node
 *         nsIEditor::EDirection aAction      which edge to find: eNext indicates beginning, ePrevious ending
 *         nsCOMPtr<nsIDOMNode> *outSelNode   desired sel node
 *         int32_t *outSelOffset              desired sel offset
 */
 nsresult
 nsHTMLEditRules::GetGoodSelPointForNode(nsIDOMNode *aNode, nsIEditor::EDirection aAction,
                                         nsCOMPtr<nsIDOMNode> *outSelNode, int32_t *outSelOffset)
 {
   NS_ENSURE_TRUE(aNode && outSelNode && outSelOffset, NS_ERROR_NULL_POINTER);
   nsresult res = NS_OK;
   // default values
   *outSelNode = aNode;
   *outSelOffset = 0;
   NS_ENSURE_STATE(mHTMLEditor);
   if (mHTMLEditor->IsTextNode(aNode) ||
       !mHTMLEditor || mHTMLEditor->IsContainer(aNode))
   {
     NS_ENSURE_STATE(mHTMLEditor);
     if (aAction == nsIEditor::ePrevious)
     {
       uint32_t len;
       res = mHTMLEditor->GetLengthOfDOMNode(aNode, len);
       *outSelOffset = int32_t(len);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   else
   {
     *outSelNode = nsEditor::GetNodeLocation(aNode, outSelOffset);
     if (!nsTextEditUtils::IsBreak(aNode) ||
         !mHTMLEditor || mHTMLEditor->IsVisBreak(aNode))
     {
       NS_ENSURE_STATE(mHTMLEditor);
       if (aAction == nsIEditor::ePrevious)
         (*outSelOffset)++;
     }
   }
   return res;
 }
 /*****************************************************************************************************
 *    JoinBlocks: this method is used to join two block elements.  The right element is always joined
 *    to the left element.  If the elements are the same type and not nested within each other,
 *    JoinNodesSmart is called (example, joining two list items together into one).  If the elements
 *    are not the same type, or one is a descendant of the other, we instead destroy the right block
 *    placing its children into leftblock.  DTD containment rules are followed throughout.
 *         nsCOMPtr<nsIDOMNode> *aLeftBlock         pointer to the left block
 *         nsCOMPtr<nsIDOMNode> *aRightBlock        pointer to the right block; will have contents moved to left block
 *         bool *aCanceled                        return TRUE if we had to cancel operation
 */
 nsresult
 nsHTMLEditRules::JoinBlocks(nsIDOMNode *aLeftNode,
                             nsIDOMNode *aRightNode,
                             bool *aCanceled)
 {
   NS_ENSURE_ARG_POINTER(aLeftNode && aRightNode);
   nsCOMPtr<nsIDOMNode> aLeftBlock, aRightBlock;
   if (IsBlockNode(aLeftNode)) {
     aLeftBlock = aLeftNode;
   } else if (aLeftNode) {
     NS_ENSURE_STATE(mHTMLEditor);
     aLeftBlock = mHTMLEditor->GetBlockNodeParent(aLeftNode);
   }
   if (IsBlockNode(aRightNode)) {
     aRightBlock = aRightNode;
   } else if (aRightNode) {
     NS_ENSURE_STATE(mHTMLEditor);
     aRightBlock = mHTMLEditor->GetBlockNodeParent(aRightNode);
   }
   // sanity checks
   NS_ENSURE_TRUE(aLeftBlock && aRightBlock, NS_ERROR_NULL_POINTER);
   NS_ENSURE_STATE(aLeftBlock != aRightBlock);
   if (nsHTMLEditUtils::IsTableElement(aLeftBlock) ||
       nsHTMLEditUtils::IsTableElement(aRightBlock)) {
     // do not try to merge table elements
     *aCanceled = true;
     return NS_OK;
   }
   // make sure we don't try to move thing's into HR's, which look like blocks but aren't containers
   if (nsHTMLEditUtils::IsHR(aLeftBlock)) {
     NS_ENSURE_STATE(mHTMLEditor);
     nsCOMPtr<nsIDOMNode> realLeft = mHTMLEditor->GetBlockNodeParent(aLeftBlock);
     aLeftBlock = realLeft;
   }
   if (nsHTMLEditUtils::IsHR(aRightBlock)) {
     NS_ENSURE_STATE(mHTMLEditor);
     nsCOMPtr<nsIDOMNode> realRight = mHTMLEditor->GetBlockNodeParent(aRightBlock);
     aRightBlock = realRight;
   }
   // bail if both blocks the same
   if (aLeftBlock == aRightBlock) {
     *aCanceled = true;
     return NS_OK;
   }
   // Joining a list item to its parent is a NOP.
   if (nsHTMLEditUtils::IsList(aLeftBlock) &&
       nsHTMLEditUtils::IsListItem(aRightBlock)) {
     nsCOMPtr<nsIDOMNode> rightParent;
     aRightBlock->GetParentNode(getter_AddRefs(rightParent));
     if (rightParent == aLeftBlock) {
       return NS_OK;
     }
   }
   // special rule here: if we are trying to join list items, and they are in different lists,
   // join the lists instead.
   bool bMergeLists = false;
   nsIAtom* existingList = nsGkAtoms::_empty;
   int32_t theOffset;
   nsCOMPtr<nsIDOMNode> leftList, rightList;
   if (nsHTMLEditUtils::IsListItem(aLeftBlock) &&
       nsHTMLEditUtils::IsListItem(aRightBlock)) {
     aLeftBlock->GetParentNode(getter_AddRefs(leftList));
     aRightBlock->GetParentNode(getter_AddRefs(rightList));
     if (leftList && rightList && (leftList!=rightList))
     {
       // there are some special complications if the lists are descendants of
       // the other lists' items.  Note that it is ok for them to be descendants
       // of the other lists themselves, which is the usual case for sublists
       // in our impllementation.
       if (!nsEditorUtils::IsDescendantOf(leftList, aRightBlock, &theOffset) &&
           !nsEditorUtils::IsDescendantOf(rightList, aLeftBlock, &theOffset))
       {
         aLeftBlock = leftList;
         aRightBlock = rightList;
         bMergeLists = true;
         NS_ENSURE_STATE(mHTMLEditor);
         existingList = mHTMLEditor->GetTag(leftList);
       }
     }
   }
   NS_ENSURE_STATE(mHTMLEditor);
   nsAutoTxnsConserveSelection dontSpazMySelection(mHTMLEditor);
   nsresult res = NS_OK;
   int32_t  rightOffset = 0;
   int32_t  leftOffset  = -1;
   // theOffset below is where you find yourself in aRightBlock when you traverse upwards
   // from aLeftBlock
   if (nsEditorUtils::IsDescendantOf(aLeftBlock, aRightBlock, &rightOffset)) {
     // tricky case.  left block is inside right block.
     // Do ws adjustment.  This just destroys non-visible ws at boundaries we will be joining.
     rightOffset++;
     NS_ENSURE_STATE(mHTMLEditor);
     res = nsWSRunObject::ScrubBlockBoundary(mHTMLEditor,
                                             address_of(aLeftBlock),
                                             nsWSRunObject::kBlockEnd);
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_STATE(mHTMLEditor);
     res = nsWSRunObject::ScrubBlockBoundary(mHTMLEditor,
                                             address_of(aRightBlock),
                                             nsWSRunObject::kAfterBlock,
                                             &rightOffset);
     NS_ENSURE_SUCCESS(res, res);
     // Do br adjustment.
     nsCOMPtr<nsIDOMNode> brNode;
     res = CheckForInvisibleBR(aLeftBlock, kBlockEnd, address_of(brNode));
     NS_ENSURE_SUCCESS(res, res);
     if (bMergeLists)
     {
       // idea here is to take all children in  rightList that are past
       // theOffset, and pull them into leftlist.
       nsCOMPtr<nsIDOMNode> childToMove;
       nsCOMPtr<nsIContent> parent(do_QueryInterface(rightList));
       NS_ENSURE_TRUE(parent, NS_ERROR_NULL_POINTER);
       nsIContent *child = parent->GetChildAt(theOffset);
       while (child)
       {
         childToMove = do_QueryInterface(child);
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->MoveNode(childToMove, leftList, -1);
         NS_ENSURE_SUCCESS(res, res);
         child = parent->GetChildAt(rightOffset);
       }
     }
     else
     {
       res = MoveBlock(aLeftBlock, aRightBlock, leftOffset, rightOffset);
     }
     NS_ENSURE_STATE(mHTMLEditor);
     if (brNode) mHTMLEditor->DeleteNode(brNode);
   // theOffset below is where you find yourself in aLeftBlock when you traverse upwards
   // from aRightBlock
   } else if (nsEditorUtils::IsDescendantOf(aRightBlock, aLeftBlock, &leftOffset)) {
     // tricky case.  right block is inside left block.
     // Do ws adjustment.  This just destroys non-visible ws at boundaries we will be joining.
     NS_ENSURE_STATE(mHTMLEditor);
     res = nsWSRunObject::ScrubBlockBoundary(mHTMLEditor,
                                             address_of(aRightBlock),
                                             nsWSRunObject::kBlockStart);
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_STATE(mHTMLEditor);
     res = nsWSRunObject::ScrubBlockBoundary(mHTMLEditor,
                                             address_of(aLeftBlock),
                                             nsWSRunObject::kBeforeBlock,
                                             &leftOffset);
     NS_ENSURE_SUCCESS(res, res);
     // Do br adjustment.
     nsCOMPtr<nsIDOMNode> brNode;
     res = CheckForInvisibleBR(aLeftBlock, kBeforeBlock, address_of(brNode),
                               leftOffset);
     NS_ENSURE_SUCCESS(res, res);
     if (bMergeLists)
     {
       res = MoveContents(rightList, leftList, &leftOffset);
     }
     else
     {
       // Left block is a parent of right block, and the parent of the previous
       // visible content.  Right block is a child and contains the contents we
       // want to move.
       int32_t previousContentOffset;
       nsCOMPtr<nsIDOMNode> previousContentParent;
       if (aLeftNode == aLeftBlock) {
         // We are working with valid HTML, aLeftNode is a block node, and is
         // therefore allowed to contain aRightBlock.  This is the simple case,
         // we will simply move the content in aRightBlock out of its block.
         previousContentParent = aLeftBlock;
         previousContentOffset = leftOffset;
       } else {
         // We try to work as well as possible with HTML that's already invalid.
         // Although "right block" is a block, and a block must not be contained
         // in inline elements, reality is that broken documents do exist.  The
         // DIRECT parent of "left NODE" might be an inline element.  Previous
         // versions of this code skipped inline parents until the first block
         // parent was found (and used "left block" as the destination).
         // However, in some situations this strategy moves the content to an
         // unexpected position.  (see bug 200416) The new idea is to make the
         // moving content a sibling, next to the previous visible content.
         previousContentParent =
           nsEditor::GetNodeLocation(aLeftNode, &previousContentOffset);
         // We want to move our content just after the previous visible node.
         previousContentOffset++;
       }
       // Because we don't want the moving content to receive the style of the
       // previous content, we split the previous content's style.
       NS_ENSURE_STATE(mHTMLEditor);
       nsCOMPtr<nsINode> editorRoot = mHTMLEditor->GetEditorRoot();
       if (!editorRoot || aLeftNode != editorRoot->AsDOMNode()) {
         nsCOMPtr<nsIDOMNode> splittedPreviousContent;
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->SplitStyleAbovePoint(address_of(previousContentParent),
                                                 &previousContentOffset,
                                                 nullptr, nullptr, nullptr,
                                                 address_of(splittedPreviousContent));
         NS_ENSURE_SUCCESS(res, res);
         if (splittedPreviousContent) {
           previousContentParent =
             nsEditor::GetNodeLocation(splittedPreviousContent,
                                       &previousContentOffset);
         }
       }
       res = MoveBlock(previousContentParent, aRightBlock,
                       previousContentOffset, rightOffset);
     }
     NS_ENSURE_STATE(mHTMLEditor);
     if (brNode) mHTMLEditor->DeleteNode(brNode);
   }
   else
   {
     // normal case.  blocks are siblings, or at least close enough to siblings.  An example
     // of the latter is a <p>paragraph</p><ul><li>one<li>two<li>three</ul>.  The first
     // li and the p are not true siblings, but we still want to join them if you backspace
     // from li into p.
     // adjust whitespace at block boundaries
     NS_ENSURE_STATE(mHTMLEditor);
     res = nsWSRunObject::PrepareToJoinBlocks(mHTMLEditor, aLeftBlock, aRightBlock);
     NS_ENSURE_SUCCESS(res, res);
     // Do br adjustment.
     nsCOMPtr<nsIDOMNode> brNode;
     res = CheckForInvisibleBR(aLeftBlock, kBlockEnd, address_of(brNode));
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_STATE(mHTMLEditor);
     if (bMergeLists || mHTMLEditor->NodesSameType(aLeftBlock, aRightBlock)) {
       // nodes are same type.  merge them.
       nsCOMPtr<nsIDOMNode> parent;
       int32_t offset;
       res = JoinNodesSmart(aLeftBlock, aRightBlock, address_of(parent), &offset);
       if (NS_SUCCEEDED(res) && bMergeLists)
       {
         nsCOMPtr<nsIDOMNode> newBlock;
         res = ConvertListType(aRightBlock, address_of(newBlock),
                               existingList, nsGkAtoms::li);
       }
     }
     else
     {
       // nodes are disimilar types.
       res = MoveBlock(aLeftBlock, aRightBlock, leftOffset, rightOffset);
     }
     if (NS_SUCCEEDED(res) && brNode)
     {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->DeleteNode(brNode);
     }
   }
   return res;
 }
 /*****************************************************************************************************
 *    MoveBlock: this method is used to move the content from rightBlock into leftBlock
 *    Note that the "block" might merely be inline nodes between <br>s, or between blocks, etc.
 *    DTD containment rules are followed throughout.
 *         nsIDOMNode *aLeftBlock         parent to receive moved content
 *         nsIDOMNode *aRightBlock        parent to provide moved content
 *         int32_t aLeftOffset            offset in aLeftBlock to move content to
 *         int32_t aRightOffset           offset in aRightBlock to move content from
 */
 nsresult
 nsHTMLEditRules::MoveBlock(nsIDOMNode *aLeftBlock, nsIDOMNode *aRightBlock, int32_t aLeftOffset, int32_t aRightOffset)
 {
   nsCOMArray<nsIDOMNode> arrayOfNodes;
   nsCOMPtr<nsISupports> isupports;
   // GetNodesFromPoint is the workhorse that figures out what we wnat to move.
   nsresult res = GetNodesFromPoint(::DOMPoint(aRightBlock,aRightOffset),
                                    EditAction::makeList, arrayOfNodes, true);
   NS_ENSURE_SUCCESS(res, res);
   int32_t listCount = arrayOfNodes.Count();
   int32_t i;
   for (i=0; i<listCount; i++)
   {
     // get the node to act on
     nsIDOMNode* curNode = arrayOfNodes[i];
     if (IsBlockNode(curNode))
     {
       // For block nodes, move their contents only, then delete block.
       res = MoveContents(curNode, aLeftBlock, &aLeftOffset);
       NS_ENSURE_SUCCESS(res, res);
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->DeleteNode(curNode);
     }
     else
     {
       // otherwise move the content as is, checking against the dtd.
       res = MoveNodeSmart(curNode, aLeftBlock, &aLeftOffset);
     }
   }
   return res;
 }
 /*****************************************************************************************************
 *    MoveNodeSmart: this method is used to move node aSource to (aDest,aOffset).
 *    DTD containment rules are followed throughout.  aOffset is updated to point _after_
 *    inserted content.
 *         nsIDOMNode *aSource       the selection.
 *         nsIDOMNode *aDest         parent to receive moved content
 *         int32_t *aOffset          offset in aDest to move content to
 */
 nsresult
 nsHTMLEditRules::MoveNodeSmart(nsIDOMNode *aSource, nsIDOMNode *aDest, int32_t *aOffset)
 {
   NS_ENSURE_TRUE(aSource && aDest && aOffset, NS_ERROR_NULL_POINTER);
   nsresult res;
   // check if this node can go into the destination node
   NS_ENSURE_STATE(mHTMLEditor);
   if (mHTMLEditor->CanContain(aDest, aSource)) {
     // if it can, move it there
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->MoveNode(aSource, aDest, *aOffset);
     NS_ENSURE_SUCCESS(res, res);
     if (*aOffset != -1) ++(*aOffset);
   }
   else
   {
     // if it can't, move its children, and then delete it.
     res = MoveContents(aSource, aDest, aOffset);
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->DeleteNode(aSource);
     NS_ENSURE_SUCCESS(res, res);
   }
   return NS_OK;
 }
 /*****************************************************************************************************
 *    MoveContents: this method is used to move node the _contents_ of aSource to (aDest,aOffset).
 *    DTD containment rules are followed throughout.  aOffset is updated to point _after_
 *    inserted content.  aSource is deleted.
 *         nsIDOMNode *aSource       the selection.
 *         nsIDOMNode *aDest         parent to receive moved content
 *         int32_t *aOffset          offset in aDest to move content to
 */
 nsresult
 nsHTMLEditRules::MoveContents(nsIDOMNode *aSource, nsIDOMNode *aDest, int32_t *aOffset)
 {
   NS_ENSURE_TRUE(aSource && aDest && aOffset, NS_ERROR_NULL_POINTER);
   if (aSource == aDest) return NS_ERROR_ILLEGAL_VALUE;
   NS_ENSURE_STATE(mHTMLEditor);
   NS_ASSERTION(!mHTMLEditor->IsTextNode(aSource), "#text does not have contents");
   nsCOMPtr<nsIDOMNode> child;
   nsAutoString tag;
   nsresult res;
   aSource->GetFirstChild(getter_AddRefs(child));
   while (child)
   {
     res = MoveNodeSmart(child, aDest, aOffset);
     NS_ENSURE_SUCCESS(res, res);
     aSource->GetFirstChild(getter_AddRefs(child));
   }
   return NS_OK;
 }
 nsresult
 nsHTMLEditRules::DeleteNonTableElements(nsINode* aNode)
 {
   MOZ_ASSERT(aNode);
   if (!nsHTMLEditUtils::IsTableElementButNotTable(aNode)) {
     NS_ENSURE_STATE(mHTMLEditor);
     return mHTMLEditor->DeleteNode(aNode->AsDOMNode());
   }
   for (int32_t i = aNode->GetChildCount() - 1; i >= 0; --i) {
     nsresult rv = DeleteNonTableElements(aNode->GetChildAt(i));
     NS_ENSURE_SUCCESS(rv, rv);
   }
   return NS_OK;
 }
 nsresult
 nsHTMLEditRules::DidDeleteSelection(nsISelection *aSelection,
                                     nsIEditor::EDirection aDir,
                                     nsresult aResult)
 {
   if (!aSelection) { return NS_ERROR_NULL_POINTER; }
   // find where we are
   nsCOMPtr<nsIDOMNode> startNode;
   int32_t startOffset;
   nsresult res = mEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(startNode), &startOffset);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(startNode, NS_ERROR_FAILURE);
   // find any enclosing mailcite
   nsCOMPtr<nsIDOMNode> citeNode;
   res = GetTopEnclosingMailCite(startNode, address_of(citeNode),
                                 IsPlaintextEditor());
   NS_ENSURE_SUCCESS(res, res);
   if (citeNode) {
     nsCOMPtr<nsINode> cite = do_QueryInterface(citeNode);
     bool isEmpty = true, seenBR = false;
     NS_ENSURE_STATE(mHTMLEditor);
     mHTMLEditor->IsEmptyNodeImpl(cite, &isEmpty, true, true, false, &seenBR);
     if (isEmpty)
     {
       nsCOMPtr<nsIDOMNode> brNode;
       int32_t offset;
       nsCOMPtr<nsIDOMNode> parent = nsEditor::GetNodeLocation(citeNode, &offset);
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->DeleteNode(citeNode);
       NS_ENSURE_SUCCESS(res, res);
       if (parent && seenBR)
       {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->CreateBR(parent, offset, address_of(brNode));
         NS_ENSURE_SUCCESS(res, res);
         aSelection->Collapse(parent, offset);
       }
     }
   }
   // call through to base class
   return nsTextEditRules::DidDeleteSelection(aSelection, aDir, aResult);
 }
 nsresult
 nsHTMLEditRules::WillMakeList(Selection* aSelection,
                               const nsAString* aListType,
                               bool aEntireList,
                               const nsAString* aBulletType,
                               bool* aCancel,
                               bool* aHandled,
                               const nsAString* aItemType)
 {
   if (!aSelection || !aListType || !aCancel || !aHandled) {
     return NS_ERROR_NULL_POINTER;
   }
   nsCOMPtr<nsIAtom> listTypeAtom = do_GetAtom(*aListType);
   NS_ENSURE_TRUE(listTypeAtom, NS_ERROR_OUT_OF_MEMORY);
   nsresult res = WillInsert(aSelection, aCancel);
   NS_ENSURE_SUCCESS(res, res);
   // initialize out param
   // we want to ignore result of WillInsert()
   *aCancel = false;
   *aHandled = false;
   // deduce what tag to use for list items
   nsCOMPtr<nsIAtom> itemType;
   if (aItemType) {
     itemType = do_GetAtom(*aItemType);
     NS_ENSURE_TRUE(itemType, NS_ERROR_OUT_OF_MEMORY);
   } else if (listTypeAtom == nsGkAtoms::dl) {
     itemType = nsGkAtoms::dd;
   } else {
     itemType = nsGkAtoms::li;
   }
   // convert the selection ranges into "promoted" selection ranges:
   // this basically just expands the range to include the immediate
   // block parent, and then further expands to include any ancestors
   // whose children are all in the range
   *aHandled = true;
   res = NormalizeSelection(aSelection);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_STATE(mHTMLEditor);
   nsAutoSelectionReset selectionResetter(aSelection, mHTMLEditor);
   nsCOMArray<nsIDOMNode> arrayOfNodes;
   res = GetListActionNodes(arrayOfNodes, aEntireList);
   NS_ENSURE_SUCCESS(res, res);
   int32_t listCount = arrayOfNodes.Count();
   // check if all our nodes are <br>s, or empty inlines
   bool bOnlyBreaks = true;
   for (int32_t j = 0; j < listCount; j++) {
     nsIDOMNode* curNode = arrayOfNodes[j];
     // if curNode is not a Break or empty inline, we're done
     if (!nsTextEditUtils::IsBreak(curNode) && !IsEmptyInline(curNode)) {
       bOnlyBreaks = false;
       break;
     }
   }
   // if no nodes, we make empty list.  Ditto if the user tried to make a list
   // of some # of breaks.
   if (!listCount || bOnlyBreaks) {
     nsCOMPtr<nsIDOMNode> parent, theList, theListItem;
     int32_t offset;
     // if only breaks, delete them
     if (bOnlyBreaks) {
       for (int32_t j = 0; j < (int32_t)listCount; j++) {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->DeleteNode(arrayOfNodes[j]);
         NS_ENSURE_SUCCESS(res, res);
       }
     }
     // get selection location
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetStartNodeAndOffset(aSelection,
                                              getter_AddRefs(parent), &offset);
     NS_ENSURE_SUCCESS(res, res);
     // make sure we can put a list here
     NS_ENSURE_STATE(mHTMLEditor);
     if (!mHTMLEditor->CanContainTag(parent, listTypeAtom)) {
       *aCancel = true;
       return NS_OK;
     }
     res = SplitAsNeeded(aListType, address_of(parent), &offset);
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->CreateNode(*aListType, parent, offset,
                                   getter_AddRefs(theList));
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->CreateNode(nsDependentAtomString(itemType), theList, 0,
                                   getter_AddRefs(theListItem));
     NS_ENSURE_SUCCESS(res, res);
     // remember our new block for postprocessing
     mNewBlock = theListItem;
     // put selection in new list item
     res = aSelection->Collapse(theListItem, 0);
     // to prevent selection resetter from overriding us
     selectionResetter.Abort();
     *aHandled = true;
     return res;
   }
   // if there is only one node in the array, and it is a list, div, or
   // blockquote, then look inside of it until we find inner list or content.
   res = LookInsideDivBQandList(arrayOfNodes);
   NS_ENSURE_SUCCESS(res, res);
   // Ok, now go through all the nodes and put then in the list,
   // or whatever is approriate.  Wohoo!
   listCount = arrayOfNodes.Count();
   nsCOMPtr<nsIDOMNode> curParent;
   nsCOMPtr<nsIDOMNode> curList;
   nsCOMPtr<nsIDOMNode> prevListItem;
   for (int32_t i = 0; i < listCount; i++) {
     // here's where we actually figure out what to do
     nsCOMPtr<nsIDOMNode> newBlock;
     nsCOMPtr<nsIDOMNode> curNode = arrayOfNodes[i];
     int32_t offset;
     curParent = nsEditor::GetNodeLocation(curNode, &offset);
     // make sure we don't assemble content that is in different table cells
     // into the same list.  respect table cell boundaries when listifying.
     if (curList && InDifferentTableElements(curList, curNode)) {
       curList = nullptr;
     }
     // if curNode is a Break, delete it, and quit remembering prev list item
     if (nsTextEditUtils::IsBreak(curNode)) {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->DeleteNode(curNode);
       NS_ENSURE_SUCCESS(res, res);
       prevListItem = 0;
       continue;
     } else if (IsEmptyInline(curNode)) {
       // if curNode is an empty inline container, delete it
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->DeleteNode(curNode);
       NS_ENSURE_SUCCESS(res, res);
       continue;
     }
     if (nsHTMLEditUtils::IsList(curNode)) {
       // do we have a curList already?
       if (curList && !nsEditorUtils::IsDescendantOf(curNode, curList)) {
         // move all of our children into curList.  cheezy way to do it: move
         // whole list and then RemoveContainer() on the list.  ConvertListType
         // first: that routine handles converting the list item types, if
         // needed
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->MoveNode(curNode, curList, -1);
         NS_ENSURE_SUCCESS(res, res);
         res = ConvertListType(curNode, address_of(newBlock), listTypeAtom,
                               itemType);
         NS_ENSURE_SUCCESS(res, res);
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->RemoveBlockContainer(newBlock);
         NS_ENSURE_SUCCESS(res, res);
       } else {
         // replace list with new list type
         res = ConvertListType(curNode, address_of(newBlock), listTypeAtom,
                               itemType);
         NS_ENSURE_SUCCESS(res, res);
         curList = newBlock;
       }
       prevListItem = 0;
       continue;
     }
     if (nsHTMLEditUtils::IsListItem(curNode)) {
       NS_ENSURE_STATE(mHTMLEditor);
       if (mHTMLEditor->GetTag(curParent) != listTypeAtom) {
         // list item is in wrong type of list. if we don't have a curList,
         // split the old list and make a new list of correct type.
         if (!curList || nsEditorUtils::IsDescendantOf(curNode, curList)) {
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->SplitNode(curParent, offset,
                                        getter_AddRefs(newBlock));
           NS_ENSURE_SUCCESS(res, res);
           int32_t offset;
           nsCOMPtr<nsIDOMNode> parent = nsEditor::GetNodeLocation(curParent, &offset);
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->CreateNode(*aListType, parent, offset,
                                         getter_AddRefs(curList));
           NS_ENSURE_SUCCESS(res, res);
         }
         // move list item to new list
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->MoveNode(curNode, curList, -1);
         NS_ENSURE_SUCCESS(res, res);
         // convert list item type if needed
         NS_ENSURE_STATE(mHTMLEditor);
         if (!mHTMLEditor->NodeIsType(curNode, itemType)) {
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->ReplaceContainer(curNode, address_of(newBlock),
                                               nsDependentAtomString(itemType));
           NS_ENSURE_SUCCESS(res, res);
         }
       } else {
         // item is in right type of list.  But we might still have to move it.
         // and we might need to convert list item types.
         if (!curList) {
           curList = curParent;
         } else if (curParent != curList) {
           // move list item to new list
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->MoveNode(curNode, curList, -1);
           NS_ENSURE_SUCCESS(res, res);
         }
         NS_ENSURE_STATE(mHTMLEditor);
         if (!mHTMLEditor->NodeIsType(curNode, itemType)) {
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->ReplaceContainer(curNode, address_of(newBlock),
                                               nsDependentAtomString(itemType));
           NS_ENSURE_SUCCESS(res, res);
         }
       }
       nsCOMPtr<nsIDOMElement> curElement = do_QueryInterface(curNode);
       NS_NAMED_LITERAL_STRING(typestr, "type");
       if (aBulletType && !aBulletType->IsEmpty()) {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->SetAttribute(curElement, typestr, *aBulletType);
       } else {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->RemoveAttribute(curElement, typestr);
       }
       NS_ENSURE_SUCCESS(res, res);
       continue;
     }
     // if we hit a div clear our prevListItem, insert divs contents
     // into our node array, and remove the div
     if (nsHTMLEditUtils::IsDiv(curNode)) {
       prevListItem = nullptr;
       int32_t j = i + 1;
       res = GetInnerContent(curNode, arrayOfNodes, &j);
       NS_ENSURE_SUCCESS(res, res);
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->RemoveContainer(curNode);
       NS_ENSURE_SUCCESS(res, res);
       listCount = arrayOfNodes.Count();
       continue;
     }
     // need to make a list to put things in if we haven't already,
     if (!curList) {
       res = SplitAsNeeded(aListType, address_of(curParent), &offset);
       NS_ENSURE_SUCCESS(res, res);
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->CreateNode(*aListType, curParent, offset,
                                     getter_AddRefs(curList));
       NS_ENSURE_SUCCESS(res, res);
       // remember our new block for postprocessing
       mNewBlock = curList;
       // curList is now the correct thing to put curNode in
       prevListItem = 0;
     }
     // if curNode isn't a list item, we must wrap it in one
     nsCOMPtr<nsIDOMNode> listItem;
     if (!nsHTMLEditUtils::IsListItem(curNode)) {
       if (IsInlineNode(curNode) && prevListItem) {
         // this is a continuation of some inline nodes that belong together in
         // the same list item.  use prevListItem
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->MoveNode(curNode, prevListItem, -1);
         NS_ENSURE_SUCCESS(res, res);
       } else {
         // don't wrap li around a paragraph.  instead replace paragraph with li
         if (nsHTMLEditUtils::IsParagraph(curNode)) {
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->ReplaceContainer(curNode, address_of(listItem),
                                               nsDependentAtomString(itemType));
         } else {
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->InsertContainerAbove(curNode, address_of(listItem),
                                                   nsDependentAtomString(itemType));
         }
         NS_ENSURE_SUCCESS(res, res);
         if (IsInlineNode(curNode)) {
           prevListItem = listItem;
         } else {
           prevListItem = nullptr;
         }
       }
     } else {
       listItem = curNode;
     }
     if (listItem) {
       // if we made a new list item, deal with it: tuck the listItem into the
       // end of the active list
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->MoveNode(listItem, curList, -1);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::WillRemoveList(Selection* aSelection,
                                 bool aOrdered,
                                 bool *aCancel,
                                 bool *aHandled)
 {
   if (!aSelection || !aCancel || !aHandled) { return NS_ERROR_NULL_POINTER; }
   // initialize out param
   *aCancel = false;
   *aHandled = true;
   nsresult res = NormalizeSelection(aSelection);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_STATE(mHTMLEditor);
   nsAutoSelectionReset selectionResetter(aSelection, mHTMLEditor);
   nsCOMArray<nsIDOMRange> arrayOfRanges;
   res = GetPromotedRanges(aSelection, arrayOfRanges, EditAction::makeList);
   NS_ENSURE_SUCCESS(res, res);
   // use these ranges to contruct a list of nodes to act on.
   nsCOMArray<nsIDOMNode> arrayOfNodes;
   res = GetListActionNodes(arrayOfNodes, false);
   NS_ENSURE_SUCCESS(res, res);
   // Remove all non-editable nodes.  Leave them be.
   int32_t listCount = arrayOfNodes.Count();
   int32_t i;
   for (i=listCount-1; i>=0; i--)
   {
     nsIDOMNode* testNode = arrayOfNodes[i];
     NS_ENSURE_STATE(mHTMLEditor);
     if (!mHTMLEditor->IsEditable(testNode))
     {
       arrayOfNodes.RemoveObjectAt(i);
     }
   }
   // reset list count
   listCount = arrayOfNodes.Count();
   // Only act on lists or list items in the array
   nsCOMPtr<nsIDOMNode> curParent;
   for (i=0; i<listCount; i++)
   {
     // here's where we actually figure out what to do
     nsIDOMNode* curNode = arrayOfNodes[i];
     int32_t offset;
     curParent = nsEditor::GetNodeLocation(curNode, &offset);
     if (nsHTMLEditUtils::IsListItem(curNode))  // unlist this listitem
     {
       bool bOutOfList;
       do
       {
         res = PopListItem(curNode, &bOutOfList);
         NS_ENSURE_SUCCESS(res, res);
       } while (!bOutOfList); // keep popping it out until it's not in a list anymore
     }
     else if (nsHTMLEditUtils::IsList(curNode)) // node is a list, move list items out
     {
       res = RemoveListStructure(curNode);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::WillMakeDefListItem(Selection* aSelection,
                                      const nsAString *aItemType,
                                      bool aEntireList,
                                      bool *aCancel,
                                      bool *aHandled)
 {
   // for now we let WillMakeList handle this
   NS_NAMED_LITERAL_STRING(listType, "dl");
   return WillMakeList(aSelection, &listType, aEntireList, nullptr, aCancel, aHandled, aItemType);
 }
 nsresult
 nsHTMLEditRules::WillMakeBasicBlock(Selection* aSelection,
                                     const nsAString *aBlockType,
                                     bool *aCancel,
                                     bool *aHandled)
 {
   if (!aSelection || !aCancel || !aHandled) { return NS_ERROR_NULL_POINTER; }
   // initialize out param
   *aCancel = false;
   *aHandled = false;
   nsresult res = WillInsert(aSelection, aCancel);
   NS_ENSURE_SUCCESS(res, res);
   // initialize out param
   // we want to ignore result of WillInsert()
   *aCancel = false;
   res = NormalizeSelection(aSelection);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_STATE(mHTMLEditor);
   nsAutoSelectionReset selectionResetter(aSelection, mHTMLEditor);
   NS_ENSURE_STATE(mHTMLEditor);
   nsAutoTxnsConserveSelection dontSpazMySelection(mHTMLEditor);
   *aHandled = true;
   nsString tString(*aBlockType);
   // contruct a list of nodes to act on.
   nsCOMArray<nsIDOMNode> arrayOfNodes;
   res = GetNodesFromSelection(aSelection, EditAction::makeBasicBlock,
                               arrayOfNodes);
   NS_ENSURE_SUCCESS(res, res);
   // Remove all non-editable nodes.  Leave them be.
   int32_t listCount = arrayOfNodes.Count();
   int32_t i;
   for (i=listCount-1; i>=0; i--)
   {
     NS_ENSURE_STATE(mHTMLEditor);
     if (!mHTMLEditor->IsEditable(arrayOfNodes[i]))
     {
       arrayOfNodes.RemoveObjectAt(i);
     }
   }
   // reset list count
   listCount = arrayOfNodes.Count();
   // if nothing visible in list, make an empty block
   if (ListIsEmptyLine(arrayOfNodes))
   {
     nsCOMPtr<nsIDOMNode> parent, theBlock;
     int32_t offset;
     // get selection location
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(parent), &offset);
     NS_ENSURE_SUCCESS(res, res);
     if (tString.EqualsLiteral("normal") ||
         tString.IsEmpty() ) // we are removing blocks (going to "body text")
     {
       nsCOMPtr<nsIDOMNode> curBlock = parent;
       if (!IsBlockNode(curBlock)) {
         NS_ENSURE_STATE(mHTMLEditor);
         curBlock = mHTMLEditor->GetBlockNodeParent(parent);
       }
       nsCOMPtr<nsIDOMNode> curBlockPar;
       NS_ENSURE_TRUE(curBlock, NS_ERROR_NULL_POINTER);
       curBlock->GetParentNode(getter_AddRefs(curBlockPar));
       if (nsHTMLEditUtils::IsFormatNode(curBlock))
       {
         // if the first editable node after selection is a br, consume it.  Otherwise
         // it gets pushed into a following block after the split, which is visually bad.
         nsCOMPtr<nsIDOMNode> brNode;
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->GetNextHTMLNode(parent, offset, address_of(brNode));
         NS_ENSURE_SUCCESS(res, res);
         if (brNode && nsTextEditUtils::IsBreak(brNode))
         {
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->DeleteNode(brNode);
           NS_ENSURE_SUCCESS(res, res);
         }
         // do the splits!
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->SplitNodeDeep(curBlock, parent, offset, &offset, true);
         NS_ENSURE_SUCCESS(res, res);
         // put a br at the split point
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->CreateBR(curBlockPar, offset, address_of(brNode));
         NS_ENSURE_SUCCESS(res, res);
         // put selection at the split point
         res = aSelection->Collapse(curBlockPar, offset);
         selectionResetter.Abort();  // to prevent selection reseter from overriding us.
         *aHandled = true;
       }
       // else nothing to do!
     }
     else  // we are making a block
     {
       // consume a br, if needed
       nsCOMPtr<nsIDOMNode> brNode;
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->GetNextHTMLNode(parent, offset, address_of(brNode), true);
       NS_ENSURE_SUCCESS(res, res);
       if (brNode && nsTextEditUtils::IsBreak(brNode))
       {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->DeleteNode(brNode);
         NS_ENSURE_SUCCESS(res, res);
         // we don't need to act on this node any more
         arrayOfNodes.RemoveObject(brNode);
       }
       // make sure we can put a block here
       res = SplitAsNeeded(aBlockType, address_of(parent), &offset);
       NS_ENSURE_SUCCESS(res, res);
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->CreateNode(*aBlockType, parent, offset, getter_AddRefs(theBlock));
       NS_ENSURE_SUCCESS(res, res);
       // remember our new block for postprocessing
       mNewBlock = theBlock;
       // delete anything that was in the list of nodes
       for (int32_t j = arrayOfNodes.Count() - 1; j >= 0; --j)
       {
         nsCOMPtr<nsIDOMNode> curNode = arrayOfNodes[0];
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->DeleteNode(curNode);
         NS_ENSURE_SUCCESS(res, res);
         arrayOfNodes.RemoveObjectAt(0);
       }
       // put selection in new block
       res = aSelection->Collapse(theBlock,0);
       selectionResetter.Abort();  // to prevent selection reseter from overriding us.
       *aHandled = true;
     }
     return res;
   }
   else
   {
     // Ok, now go through all the nodes and make the right kind of blocks,
     // or whatever is approriate.  Wohoo!
     // Note: blockquote is handled a little differently
     if (tString.EqualsLiteral("blockquote"))
       res = MakeBlockquote(arrayOfNodes);
     else if (tString.EqualsLiteral("normal") ||
              tString.IsEmpty() )
       res = RemoveBlockStyle(arrayOfNodes);
     else
       res = ApplyBlockStyle(arrayOfNodes, aBlockType);
     return res;
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::DidMakeBasicBlock(nsISelection *aSelection,
                                    nsRulesInfo *aInfo, nsresult aResult)
 {
   NS_ENSURE_TRUE(aSelection, NS_ERROR_NULL_POINTER);
   // check for empty block.  if so, put a moz br in it.
   if (!aSelection->Collapsed()) {
     return NS_OK;
   }
   nsCOMPtr<nsIDOMNode> parent;
   int32_t offset;
   nsresult res = nsEditor::GetStartNodeAndOffset(aSelection, getter_AddRefs(parent), &offset);
   NS_ENSURE_SUCCESS(res, res);
   res = InsertMozBRIfNeeded(parent);
   return res;
 }
 nsresult
 nsHTMLEditRules::WillIndent(Selection* aSelection,
                             bool* aCancel, bool* aHandled)
 {
   nsresult res;
   NS_ENSURE_STATE(mHTMLEditor);
   if (mHTMLEditor->IsCSSEnabled()) {
     res = WillCSSIndent(aSelection, aCancel, aHandled);
   }
   else {
     res = WillHTMLIndent(aSelection, aCancel, aHandled);
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::WillCSSIndent(Selection* aSelection,
                                bool* aCancel, bool* aHandled)
 {
   if (!aSelection || !aCancel || !aHandled) { return NS_ERROR_NULL_POINTER; }
   nsresult res = WillInsert(aSelection, aCancel);
   NS_ENSURE_SUCCESS(res, res);
   // initialize out param
   // we want to ignore result of WillInsert()
   *aCancel = false;
   *aHandled = true;
   res = NormalizeSelection(aSelection);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_STATE(mHTMLEditor);
   nsAutoSelectionReset selectionResetter(aSelection, mHTMLEditor);
   nsCOMArray<nsIDOMRange>  arrayOfRanges;
   nsCOMArray<nsIDOMNode> arrayOfNodes;
   // short circuit: detect case of collapsed selection inside an <li>.
   // just sublist that <li>.  This prevents bug 97797.
   nsCOMPtr<nsIDOMNode> liNode;
   if (aSelection->Collapsed()) {
     nsCOMPtr<nsIDOMNode> node, block;
     int32_t offset;
     NS_ENSURE_STATE(mHTMLEditor);
     nsresult res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(node), &offset);
     NS_ENSURE_SUCCESS(res, res);
     if (IsBlockNode(node)) {
       block = node;
     } else {
       NS_ENSURE_STATE(mHTMLEditor);
       block = mHTMLEditor->GetBlockNodeParent(node);
     }
     if (block && nsHTMLEditUtils::IsListItem(block))
       liNode = block;
   }
   if (liNode)
   {
     arrayOfNodes.AppendObject(liNode);
   }
   else
   {
     // convert the selection ranges into "promoted" selection ranges:
     // this basically just expands the range to include the immediate
     // block parent, and then further expands to include any ancestors
     // whose children are all in the range
     res = GetNodesFromSelection(aSelection, EditAction::indent, arrayOfNodes);
     NS_ENSURE_SUCCESS(res, res);
   }
   NS_NAMED_LITERAL_STRING(quoteType, "blockquote");
   // if nothing visible in list, make an empty block
   if (ListIsEmptyLine(arrayOfNodes))
   {
     nsCOMPtr<nsIDOMNode> parent, theBlock;
     int32_t offset;
     nsAutoString quoteType(NS_LITERAL_STRING("div"));
     // get selection location
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(parent), &offset);
     NS_ENSURE_SUCCESS(res, res);
     // make sure we can put a block here
     res = SplitAsNeeded(&quoteType, address_of(parent), &offset);
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->CreateNode(quoteType, parent, offset, getter_AddRefs(theBlock));
     NS_ENSURE_SUCCESS(res, res);
     // remember our new block for postprocessing
     mNewBlock = theBlock;
     RelativeChangeIndentationOfElementNode(theBlock, +1);
     // delete anything that was in the list of nodes
     for (int32_t j = arrayOfNodes.Count() - 1; j >= 0; --j)
     {
       nsCOMPtr<nsIDOMNode> curNode = arrayOfNodes[0];
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->DeleteNode(curNode);
       NS_ENSURE_SUCCESS(res, res);
       arrayOfNodes.RemoveObjectAt(0);
     }
     // put selection in new block
     res = aSelection->Collapse(theBlock,0);
     selectionResetter.Abort();  // to prevent selection reseter from overriding us.
     *aHandled = true;
     return res;
   }
   // Ok, now go through all the nodes and put them in a blockquote,
   // or whatever is appropriate.  Wohoo!
   int32_t i;
   nsCOMPtr<nsIDOMNode> curParent;
   nsCOMPtr<nsIDOMNode> curQuote;
   nsCOMPtr<nsIDOMNode> curList;
   nsCOMPtr<nsIDOMNode> sibling;
   int32_t listCount = arrayOfNodes.Count();
   for (i=0; i<listCount; i++)
   {
     // here's where we actually figure out what to do
     nsCOMPtr<nsIDOMNode> curNode = arrayOfNodes[i];
     // Ignore all non-editable nodes.  Leave them be.
     NS_ENSURE_STATE(mHTMLEditor);
     if (!mHTMLEditor->IsEditable(curNode)) continue;
     int32_t offset;
     curParent = nsEditor::GetNodeLocation(curNode, &offset);
     // some logic for putting list items into nested lists...
     if (nsHTMLEditUtils::IsList(curParent))
     {
       sibling = nullptr;
       // Check for whether we should join a list that follows curNode.
       // We do this if the next element is a list, and the list is of the
       // same type (li/ol) as curNode was a part it.
       NS_ENSURE_STATE(mHTMLEditor);
       mHTMLEditor->GetNextHTMLSibling(curNode, address_of(sibling));
       if (sibling && nsHTMLEditUtils::IsList(sibling))
       {
         nsAutoString curListTag, siblingListTag;
         nsEditor::GetTagString(curParent, curListTag);
         nsEditor::GetTagString(sibling, siblingListTag);
         if (curListTag == siblingListTag)
         {
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->MoveNode(curNode, sibling, 0);
           NS_ENSURE_SUCCESS(res, res);
           continue;
         }
       }
       // Check for whether we should join a list that preceeds curNode.
       // We do this if the previous element is a list, and the list is of
       // the same type (li/ol) as curNode was a part of.
       NS_ENSURE_STATE(mHTMLEditor);
       mHTMLEditor->GetPriorHTMLSibling(curNode, address_of(sibling));
       if (sibling && nsHTMLEditUtils::IsList(sibling))
       {
         nsAutoString curListTag, siblingListTag;
         nsEditor::GetTagString(curParent, curListTag);
         nsEditor::GetTagString(sibling, siblingListTag);
         if (curListTag == siblingListTag)
         {
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->MoveNode(curNode, sibling, -1);
           NS_ENSURE_SUCCESS(res, res);
           continue;
         }
       }
       sibling = nullptr;
       // check to see if curList is still appropriate.  Which it is if
       // curNode is still right after it in the same list.
       if (curList) {
         NS_ENSURE_STATE(mHTMLEditor);
         mHTMLEditor->GetPriorHTMLSibling(curNode, address_of(sibling));
       }
       if (!curList || (sibling && sibling != curList))
       {
         nsAutoString listTag;
         nsEditor::GetTagString(curParent,listTag);
         ToLowerCase(listTag);
         // create a new nested list of correct type
         res = SplitAsNeeded(&listTag, address_of(curParent), &offset);
         NS_ENSURE_SUCCESS(res, res);
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->CreateNode(listTag, curParent, offset, getter_AddRefs(curList));
         NS_ENSURE_SUCCESS(res, res);
         // curList is now the correct thing to put curNode in
         // remember our new block for postprocessing
         mNewBlock = curList;
       }
       // tuck the node into the end of the active list
       uint32_t listLen;
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->GetLengthOfDOMNode(curList, listLen);
       NS_ENSURE_SUCCESS(res, res);
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->MoveNode(curNode, curList, listLen);
       NS_ENSURE_SUCCESS(res, res);
     }
     else // not a list item
     {
       if (IsBlockNode(curNode)) {
         RelativeChangeIndentationOfElementNode(curNode, +1);
         curQuote = nullptr;
       }
       else {
         if (!curQuote)
         {
           // First, check that our element can contain a div.
           if (!mEditor->CanContainTag(curParent, nsGkAtoms::div)) {
             return NS_OK; // cancelled
           }
           NS_NAMED_LITERAL_STRING(divquoteType, "div");
           res = SplitAsNeeded(&divquoteType, address_of(curParent), &offset);
           NS_ENSURE_SUCCESS(res, res);
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->CreateNode(divquoteType, curParent, offset, getter_AddRefs(curQuote));
           NS_ENSURE_SUCCESS(res, res);
           RelativeChangeIndentationOfElementNode(curQuote, +1);
           // remember our new block for postprocessing
           mNewBlock = curQuote;
           // curQuote is now the correct thing to put curNode in
         }
         // tuck the node into the end of the active blockquote
         uint32_t quoteLen;
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->GetLengthOfDOMNode(curQuote, quoteLen);
         NS_ENSURE_SUCCESS(res, res);
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->MoveNode(curNode, curQuote, quoteLen);
         NS_ENSURE_SUCCESS(res, res);
       }
     }
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::WillHTMLIndent(Selection* aSelection,
                                 bool* aCancel, bool* aHandled)
 {
   if (!aSelection || !aCancel || !aHandled) { return NS_ERROR_NULL_POINTER; }
   nsresult res = WillInsert(aSelection, aCancel);
   NS_ENSURE_SUCCESS(res, res);
   // initialize out param
   // we want to ignore result of WillInsert()
   *aCancel = false;
   *aHandled = true;
   res = NormalizeSelection(aSelection);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_STATE(mHTMLEditor);
   nsAutoSelectionReset selectionResetter(aSelection, mHTMLEditor);
   // convert the selection ranges into "promoted" selection ranges:
   // this basically just expands the range to include the immediate
   // block parent, and then further expands to include any ancestors
   // whose children are all in the range
   nsCOMArray<nsIDOMRange> arrayOfRanges;
   res = GetPromotedRanges(aSelection, arrayOfRanges, EditAction::indent);
   NS_ENSURE_SUCCESS(res, res);
   // use these ranges to contruct a list of nodes to act on.
   nsCOMArray<nsIDOMNode> arrayOfNodes;
   res = GetNodesForOperation(arrayOfRanges, arrayOfNodes, EditAction::indent);
   NS_ENSURE_SUCCESS(res, res);
   NS_NAMED_LITERAL_STRING(quoteType, "blockquote");
   // if nothing visible in list, make an empty block
   if (ListIsEmptyLine(arrayOfNodes))
   {
     nsCOMPtr<nsIDOMNode> parent, theBlock;
     int32_t offset;
     // get selection location
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(parent), &offset);
     NS_ENSURE_SUCCESS(res, res);
     // make sure we can put a block here
     res = SplitAsNeeded(&quoteType, address_of(parent), &offset);
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->CreateNode(quoteType, parent, offset, getter_AddRefs(theBlock));
     NS_ENSURE_SUCCESS(res, res);
     // remember our new block for postprocessing
     mNewBlock = theBlock;
     // delete anything that was in the list of nodes
     for (int32_t j = arrayOfNodes.Count() - 1; j >= 0; --j)
     {
       nsCOMPtr<nsIDOMNode> curNode = arrayOfNodes[0];
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->DeleteNode(curNode);
       NS_ENSURE_SUCCESS(res, res);
       arrayOfNodes.RemoveObjectAt(0);
     }
     // put selection in new block
     res = aSelection->Collapse(theBlock,0);
     selectionResetter.Abort();  // to prevent selection reseter from overriding us.
     *aHandled = true;
     return res;
   }
   // Ok, now go through all the nodes and put them in a blockquote,
   // or whatever is appropriate.  Wohoo!
   int32_t i;
   nsCOMPtr<nsIDOMNode> curParent, curQuote, curList, indentedLI, sibling;
   int32_t listCount = arrayOfNodes.Count();
   for (i=0; i<listCount; i++)
   {
     // here's where we actually figure out what to do
     nsCOMPtr<nsIDOMNode> curNode = arrayOfNodes[i];
     // Ignore all non-editable nodes.  Leave them be.
     NS_ENSURE_STATE(mHTMLEditor);
     if (!mHTMLEditor->IsEditable(curNode)) continue;
     int32_t offset;
     curParent = nsEditor::GetNodeLocation(curNode, &offset);
     // some logic for putting list items into nested lists...
     if (nsHTMLEditUtils::IsList(curParent))
     {
       sibling = nullptr;
       // Check for whether we should join a list that follows curNode.
       // We do this if the next element is a list, and the list is of the
       // same type (li/ol) as curNode was a part it.
       NS_ENSURE_STATE(mHTMLEditor);
       mHTMLEditor->GetNextHTMLSibling(curNode, address_of(sibling));
       if (sibling && nsHTMLEditUtils::IsList(sibling))
       {
         nsAutoString curListTag, siblingListTag;
         nsEditor::GetTagString(curParent, curListTag);
         nsEditor::GetTagString(sibling, siblingListTag);
         if (curListTag == siblingListTag)
         {
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->MoveNode(curNode, sibling, 0);
           NS_ENSURE_SUCCESS(res, res);
           continue;
         }
       }
       // Check for whether we should join a list that preceeds curNode.
       // We do this if the previous element is a list, and the list is of
       // the same type (li/ol) as curNode was a part of.
       NS_ENSURE_STATE(mHTMLEditor);
       mHTMLEditor->GetPriorHTMLSibling(curNode, address_of(sibling));
       if (sibling && nsHTMLEditUtils::IsList(sibling))
       {
         nsAutoString curListTag, siblingListTag;
         nsEditor::GetTagString(curParent, curListTag);
         nsEditor::GetTagString(sibling, siblingListTag);
         if (curListTag == siblingListTag)
         {
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->MoveNode(curNode, sibling, -1);
           NS_ENSURE_SUCCESS(res, res);
           continue;
         }
       }
       sibling = nullptr;
       // check to see if curList is still appropriate.  Which it is if
       // curNode is still right after it in the same list.
       if (curList) {
         NS_ENSURE_STATE(mHTMLEditor);
         mHTMLEditor->GetPriorHTMLSibling(curNode, address_of(sibling));
       }
       if (!curList || (sibling && sibling != curList) )
       {
         nsAutoString listTag;
         nsEditor::GetTagString(curParent,listTag);
         ToLowerCase(listTag);
         // create a new nested list of correct type
         res = SplitAsNeeded(&listTag, address_of(curParent), &offset);
         NS_ENSURE_SUCCESS(res, res);
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->CreateNode(listTag, curParent, offset, getter_AddRefs(curList));
         NS_ENSURE_SUCCESS(res, res);
         // curList is now the correct thing to put curNode in
         // remember our new block for postprocessing
         mNewBlock = curList;
       }
       // tuck the node into the end of the active list
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->MoveNode(curNode, curList, -1);
       NS_ENSURE_SUCCESS(res, res);
       // forget curQuote, if any
       curQuote = nullptr;
     }
     else // not a list item, use blockquote?
     {
       // if we are inside a list item, we don't want to blockquote, we want
       // to sublist the list item.  We may have several nodes listed in the
       // array of nodes to act on, that are in the same list item.  Since
       // we only want to indent that li once, we must keep track of the most
       // recent indented list item, and not indent it if we find another node
       // to act on that is still inside the same li.
       nsCOMPtr<nsIDOMNode> listitem=IsInListItem(curNode);
       if (listitem)
       {
         if (indentedLI == listitem) continue;  // already indented this list item
         curParent = nsEditor::GetNodeLocation(listitem, &offset);
         // check to see if curList is still appropriate.  Which it is if
         // curNode is still right after it in the same list.
         if (curList)
         {
           sibling = nullptr;
           NS_ENSURE_STATE(mHTMLEditor);
           mHTMLEditor->GetPriorHTMLSibling(curNode, address_of(sibling));
         }
         if (!curList || (sibling && sibling != curList) )
         {
           nsAutoString listTag;
           nsEditor::GetTagString(curParent,listTag);
           ToLowerCase(listTag);
           // create a new nested list of correct type
           res = SplitAsNeeded(&listTag, address_of(curParent), &offset);
           NS_ENSURE_SUCCESS(res, res);
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->CreateNode(listTag, curParent, offset, getter_AddRefs(curList));
           NS_ENSURE_SUCCESS(res, res);
         }
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->MoveNode(listitem, curList, -1);
         NS_ENSURE_SUCCESS(res, res);
         // remember we indented this li
         indentedLI = listitem;
       }
       else
       {
         // need to make a blockquote to put things in if we haven't already,
         // or if this node doesn't go in blockquote we used earlier.
         // One reason it might not go in prio blockquote is if we are now
         // in a different table cell.
         if (curQuote && InDifferentTableElements(curQuote, curNode)) {
           curQuote = nullptr;
         }
         if (!curQuote)
         {
           // First, check that our element can contain a blockquote.
           if (!mEditor->CanContainTag(curParent, nsGkAtoms::blockquote)) {
             return NS_OK; // cancelled
           }
           res = SplitAsNeeded(&quoteType, address_of(curParent), &offset);
           NS_ENSURE_SUCCESS(res, res);
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->CreateNode(quoteType, curParent, offset, getter_AddRefs(curQuote));
           NS_ENSURE_SUCCESS(res, res);
           // remember our new block for postprocessing
           mNewBlock = curQuote;
           // curQuote is now the correct thing to put curNode in
         }
         // tuck the node into the end of the active blockquote
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->MoveNode(curNode, curQuote, -1);
         NS_ENSURE_SUCCESS(res, res);
         // forget curList, if any
         curList = nullptr;
       }
     }
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::WillOutdent(Selection* aSelection,
                              bool* aCancel, bool* aHandled)
 {
   if (!aSelection || !aCancel || !aHandled) { return NS_ERROR_NULL_POINTER; }
   // initialize out param
   *aCancel = false;
   *aHandled = true;
   nsresult res = NS_OK;
   nsCOMPtr<nsIDOMNode> rememberedLeftBQ, rememberedRightBQ;
   NS_ENSURE_STATE(mHTMLEditor);
   bool useCSS = mHTMLEditor->IsCSSEnabled();
   res = NormalizeSelection(aSelection);
   NS_ENSURE_SUCCESS(res, res);
   // some scoping for selection resetting - we may need to tweak it
   {
     NS_ENSURE_STATE(mHTMLEditor);
     nsAutoSelectionReset selectionResetter(aSelection, mHTMLEditor);
     // convert the selection ranges into "promoted" selection ranges:
     // this basically just expands the range to include the immediate
     // block parent, and then further expands to include any ancestors
     // whose children are all in the range
     nsCOMArray<nsIDOMNode> arrayOfNodes;
     res = GetNodesFromSelection(aSelection, EditAction::outdent,
                                 arrayOfNodes);
     NS_ENSURE_SUCCESS(res, res);
     // Ok, now go through all the nodes and remove a level of blockquoting,
     // or whatever is appropriate.  Wohoo!
     nsCOMPtr<nsIDOMNode> curBlockQuote, firstBQChild, lastBQChild;
     bool curBlockQuoteIsIndentedWithCSS = false;
     int32_t listCount = arrayOfNodes.Count();
     int32_t i;
     nsCOMPtr<nsIDOMNode> curParent;
     for (i=0; i<listCount; i++)
     {
       // here's where we actually figure out what to do
       nsCOMPtr<nsIDOMNode> curNode = arrayOfNodes[i];
       int32_t offset;
       curParent = nsEditor::GetNodeLocation(curNode, &offset);
       // is it a blockquote?
       if (nsHTMLEditUtils::IsBlockquote(curNode))
       {
         // if it is a blockquote, remove it.
         // So we need to finish up dealng with any curBlockQuote first.
         if (curBlockQuote)
         {
           res = OutdentPartOfBlock(curBlockQuote, firstBQChild, lastBQChild,
                                    curBlockQuoteIsIndentedWithCSS,
                                    address_of(rememberedLeftBQ),
                                    address_of(rememberedRightBQ));
           NS_ENSURE_SUCCESS(res, res);
           curBlockQuote = 0;  firstBQChild = 0;  lastBQChild = 0;
           curBlockQuoteIsIndentedWithCSS = false;
         }
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->RemoveBlockContainer(curNode);
         NS_ENSURE_SUCCESS(res, res);
         continue;
       }
       // is it a block with a 'margin' property?
       if (useCSS && IsBlockNode(curNode))
       {
         NS_ENSURE_STATE(mHTMLEditor);
         nsIAtom* marginProperty = MarginPropertyAtomForIndent(mHTMLEditor->mHTMLCSSUtils, curNode);
         nsAutoString value;
         NS_ENSURE_STATE(mHTMLEditor);
         mHTMLEditor->mHTMLCSSUtils->GetSpecifiedProperty(curNode, marginProperty, value);
         float f;
         nsCOMPtr<nsIAtom> unit;
         NS_ENSURE_STATE(mHTMLEditor);
         mHTMLEditor->mHTMLCSSUtils->ParseLength(value, &f, getter_AddRefs(unit));
         if (f > 0)
         {
           RelativeChangeIndentationOfElementNode(curNode, -1);
           continue;
         }
       }
       // is it a list item?
       if (nsHTMLEditUtils::IsListItem(curNode))
       {
         // if it is a list item, that means we are not outdenting whole list.
         // So we need to finish up dealing with any curBlockQuote, and then
         // pop this list item.
         if (curBlockQuote)
         {
           res = OutdentPartOfBlock(curBlockQuote, firstBQChild, lastBQChild,
                                    curBlockQuoteIsIndentedWithCSS,
                                    address_of(rememberedLeftBQ),
                                    address_of(rememberedRightBQ));
           NS_ENSURE_SUCCESS(res, res);
           curBlockQuote = 0;  firstBQChild = 0;  lastBQChild = 0;
           curBlockQuoteIsIndentedWithCSS = false;
         }
         bool bOutOfList;
         res = PopListItem(curNode, &bOutOfList);
         NS_ENSURE_SUCCESS(res, res);
         continue;
       }
       // do we have a blockquote that we are already committed to removing?
       if (curBlockQuote)
       {
         // if so, is this node a descendant?
         if (nsEditorUtils::IsDescendantOf(curNode, curBlockQuote))
         {
           lastBQChild = curNode;
           continue;  // then we don't need to do anything different for this node
         }
         else
         {
           // otherwise, we have progressed beyond end of curBlockQuote,
           // so lets handle it now.  We need to remove the portion of
           // curBlockQuote that contains [firstBQChild - lastBQChild].
           res = OutdentPartOfBlock(curBlockQuote, firstBQChild, lastBQChild,
                                    curBlockQuoteIsIndentedWithCSS,
                                    address_of(rememberedLeftBQ),
                                    address_of(rememberedRightBQ));
           NS_ENSURE_SUCCESS(res, res);
           curBlockQuote = 0;  firstBQChild = 0;  lastBQChild = 0;
           curBlockQuoteIsIndentedWithCSS = false;
           // fall out and handle curNode
         }
       }
       // are we inside a blockquote?
       nsCOMPtr<nsIDOMNode> n = curNode;
       nsCOMPtr<nsIDOMNode> tmp;
       curBlockQuoteIsIndentedWithCSS = false;
       // keep looking up the hierarchy as long as we don't hit the body or the
       // active editing host or a table element (other than an entire table)
       while (!nsTextEditUtils::IsBody(n) && mHTMLEditor &&
              mHTMLEditor->IsDescendantOfEditorRoot(n)
           && (nsHTMLEditUtils::IsTable(n) || !nsHTMLEditUtils::IsTableElement(n)))
       {
         n->GetParentNode(getter_AddRefs(tmp));
         if (!tmp) {
           break;
         }
         n = tmp;
         if (nsHTMLEditUtils::IsBlockquote(n))
         {
           // if so, remember it, and remember first node we are taking out of it.
           curBlockQuote = n;
           firstBQChild  = curNode;
           lastBQChild   = curNode;
           break;
         }
         else if (useCSS)
         {
           NS_ENSURE_STATE(mHTMLEditor);
           nsIAtom* marginProperty = MarginPropertyAtomForIndent(mHTMLEditor->mHTMLCSSUtils, curNode);
           nsAutoString value;
           NS_ENSURE_STATE(mHTMLEditor);
           mHTMLEditor->mHTMLCSSUtils->GetSpecifiedProperty(n, marginProperty, value);
           float f;
           nsCOMPtr<nsIAtom> unit;
           NS_ENSURE_STATE(mHTMLEditor);
           mHTMLEditor->mHTMLCSSUtils->ParseLength(value, &f, getter_AddRefs(unit));
           if (f > 0 && !(nsHTMLEditUtils::IsList(curParent) && nsHTMLEditUtils::IsList(curNode)))
           {
             curBlockQuote = n;
             firstBQChild  = curNode;
             lastBQChild   = curNode;
             curBlockQuoteIsIndentedWithCSS = true;
             break;
           }
         }
       }
       if (!curBlockQuote)
       {
         // could not find an enclosing blockquote for this node.  handle list cases.
         if (nsHTMLEditUtils::IsList(curParent))  // move node out of list
         {
           if (nsHTMLEditUtils::IsList(curNode))  // just unwrap this sublist
           {
             NS_ENSURE_STATE(mHTMLEditor);
             res = mHTMLEditor->RemoveBlockContainer(curNode);
             NS_ENSURE_SUCCESS(res, res);
           }
           // handled list item case above
         }
         else if (nsHTMLEditUtils::IsList(curNode)) // node is a list, but parent is non-list: move list items out
         {
           nsCOMPtr<nsIDOMNode> child;
           curNode->GetLastChild(getter_AddRefs(child));
           while (child)
           {
             if (nsHTMLEditUtils::IsListItem(child))
             {
               bool bOutOfList;
               res = PopListItem(child, &bOutOfList);
               NS_ENSURE_SUCCESS(res, res);
             }
             else if (nsHTMLEditUtils::IsList(child))
             {
               // We have an embedded list, so move it out from under the
               // parent list. Be sure to put it after the parent list
               // because this loop iterates backwards through the parent's
               // list of children.
               NS_ENSURE_STATE(mHTMLEditor);
               res = mHTMLEditor->MoveNode(child, curParent, offset + 1);
               NS_ENSURE_SUCCESS(res, res);
             }
             else
             {
               // delete any non- list items for now
               NS_ENSURE_STATE(mHTMLEditor);
               res = mHTMLEditor->DeleteNode(child);
               NS_ENSURE_SUCCESS(res, res);
             }
             curNode->GetLastChild(getter_AddRefs(child));
           }
           // delete the now-empty list
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->RemoveBlockContainer(curNode);
           NS_ENSURE_SUCCESS(res, res);
         }
         else if (useCSS) {
           nsCOMPtr<nsIDOMElement> element;
           nsCOMPtr<nsIDOMText> textNode = do_QueryInterface(curNode);
           if (textNode) {
             // We want to outdent the parent of text nodes
             nsCOMPtr<nsIDOMNode> parent;
             textNode->GetParentNode(getter_AddRefs(parent));
             element = do_QueryInterface(parent);
           } else {
             element = do_QueryInterface(curNode);
           }
           if (element) {
             RelativeChangeIndentationOfElementNode(element, -1);
           }
         }
       }
     }
     if (curBlockQuote)
     {
       // we have a blockquote we haven't finished handling
       res = OutdentPartOfBlock(curBlockQuote, firstBQChild, lastBQChild,
                                curBlockQuoteIsIndentedWithCSS,
                                address_of(rememberedLeftBQ),
                                address_of(rememberedRightBQ));
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   // make sure selection didn't stick to last piece of content in old bq
   // (only a problem for collapsed selections)
   if (rememberedLeftBQ || rememberedRightBQ) {
     if (aSelection->Collapsed()) {
       // push selection past end of rememberedLeftBQ
       nsCOMPtr<nsIDOMNode> sNode;
       int32_t sOffset;
       NS_ENSURE_STATE(mHTMLEditor);
       mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(sNode), &sOffset);
       if (rememberedLeftBQ &&
           ((sNode == rememberedLeftBQ) || nsEditorUtils::IsDescendantOf(sNode, rememberedLeftBQ)))
       {
         // selection is inside rememberedLeftBQ - push it past it.
         sNode = nsEditor::GetNodeLocation(rememberedLeftBQ, &sOffset);
         sOffset++;
         aSelection->Collapse(sNode, sOffset);
       }
       // and pull selection before beginning of rememberedRightBQ
       NS_ENSURE_STATE(mHTMLEditor);
       mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(sNode), &sOffset);
       if (rememberedRightBQ &&
           ((sNode == rememberedRightBQ) || nsEditorUtils::IsDescendantOf(sNode, rememberedRightBQ)))
       {
         // selection is inside rememberedRightBQ - push it before it.
         sNode = nsEditor::GetNodeLocation(rememberedRightBQ, &sOffset);
         aSelection->Collapse(sNode, sOffset);
       }
     }
     return NS_OK;
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // RemovePartOfBlock:  split aBlock and move aStartChild to aEndChild out
 //                     of aBlock.  return left side of block (if any) in
 //                     aLeftNode.  return right side of block (if any) in
 //                     aRightNode.
 //
 nsresult
 nsHTMLEditRules::RemovePartOfBlock(nsIDOMNode *aBlock,
                                    nsIDOMNode *aStartChild,
                                    nsIDOMNode *aEndChild,
                                    nsCOMPtr<nsIDOMNode> *aLeftNode,
                                    nsCOMPtr<nsIDOMNode> *aRightNode)
 {
   nsCOMPtr<nsIDOMNode> middleNode;
   nsresult res = SplitBlock(aBlock, aStartChild, aEndChild,
                             aLeftNode, aRightNode,
                             address_of(middleNode));
   NS_ENSURE_SUCCESS(res, res);
   // get rid of part of blockquote we are outdenting
   NS_ENSURE_STATE(mHTMLEditor);
   return mHTMLEditor->RemoveBlockContainer(aBlock);
 }
 nsresult
 nsHTMLEditRules::SplitBlock(nsIDOMNode *aBlock,
                             nsIDOMNode *aStartChild,
                             nsIDOMNode *aEndChild,
                             nsCOMPtr<nsIDOMNode> *aLeftNode,
                             nsCOMPtr<nsIDOMNode> *aRightNode,
                             nsCOMPtr<nsIDOMNode> *aMiddleNode)
 {
   NS_ENSURE_TRUE(aBlock && aStartChild && aEndChild, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIDOMNode> leftNode, rightNode;
   int32_t startOffset, endOffset, offset;
   nsresult res;
   // get split point location
   nsCOMPtr<nsIDOMNode> startParent = nsEditor::GetNodeLocation(aStartChild, &startOffset);
   // do the splits!
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->SplitNodeDeep(aBlock, startParent, startOffset, &offset,
                                    true, address_of(leftNode), address_of(rightNode));
   NS_ENSURE_SUCCESS(res, res);
   if (rightNode)  aBlock = rightNode;
   // remember left portion of block if caller requested
   if (aLeftNode)
     *aLeftNode = leftNode;
   // get split point location
   nsCOMPtr<nsIDOMNode> endParent = nsEditor::GetNodeLocation(aEndChild, &endOffset);
   endOffset++;  // want to be after lastBQChild
   // do the splits!
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->SplitNodeDeep(aBlock, endParent, endOffset, &offset,
                                    true, address_of(leftNode), address_of(rightNode));
   NS_ENSURE_SUCCESS(res, res);
   if (leftNode)  aBlock = leftNode;
   // remember right portion of block if caller requested
   if (aRightNode)
     *aRightNode = rightNode;
   if (aMiddleNode)
     *aMiddleNode = aBlock;
   return NS_OK;
 }
 nsresult
 nsHTMLEditRules::OutdentPartOfBlock(nsIDOMNode *aBlock,
                                     nsIDOMNode *aStartChild,
                                     nsIDOMNode *aEndChild,
                                     bool aIsBlockIndentedWithCSS,
                                     nsCOMPtr<nsIDOMNode> *aLeftNode,
                                     nsCOMPtr<nsIDOMNode> *aRightNode)
 {
   nsCOMPtr<nsIDOMNode> middleNode;
   nsresult res = SplitBlock(aBlock, aStartChild, aEndChild,
                             aLeftNode,
                             aRightNode,
                             address_of(middleNode));
   NS_ENSURE_SUCCESS(res, res);
   if (aIsBlockIndentedWithCSS) {
     res = RelativeChangeIndentationOfElementNode(middleNode, -1);
   } else {
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->RemoveBlockContainer(middleNode);
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // ConvertListType:  convert list type and list item type.
 //
 //
 nsresult
 nsHTMLEditRules::ConvertListType(nsIDOMNode* aList,
                                  nsCOMPtr<nsIDOMNode>* outList,
                                  nsIAtom* aListType,
                                  nsIAtom* aItemType)
 {
   MOZ_ASSERT(aListType);
   MOZ_ASSERT(aItemType);
   NS_ENSURE_TRUE(aList && outList, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsINode> list = do_QueryInterface(aList);
   NS_ENSURE_STATE(list);
   nsCOMPtr<dom::Element> outNode;
   nsresult rv = ConvertListType(list, getter_AddRefs(outNode), aListType, aItemType);
   *outList = outNode ? outNode->AsDOMNode() : nullptr;
   return rv;
 }
 nsresult
 nsHTMLEditRules::ConvertListType(nsINode* aList,
                                  dom::Element** aOutList,
                                  nsIAtom* aListType,
                                  nsIAtom* aItemType)
 {
   MOZ_ASSERT(aList);
   MOZ_ASSERT(aOutList);
   MOZ_ASSERT(aListType);
   MOZ_ASSERT(aItemType);
   nsCOMPtr<nsINode> child = aList->GetFirstChild();
   while (child)
   {
     if (child->IsElement()) {
       dom::Element* element = child->AsElement();
       if (nsHTMLEditUtils::IsListItem(element) && !element->IsHTML(aItemType)) {
         nsCOMPtr<dom::Element> temp;
         nsresult rv =
           mHTMLEditor->ReplaceContainer(child, getter_AddRefs(temp),
                                         nsDependentAtomString(aItemType));
         NS_ENSURE_SUCCESS(rv, rv);
         child = temp.forget();
       } else if (nsHTMLEditUtils::IsList(element) &&
                  !element->IsHTML(aListType)) {
         nsCOMPtr<dom::Element> temp;
         nsresult rv =
           ConvertListType(child, getter_AddRefs(temp), aListType, aItemType);
         NS_ENSURE_SUCCESS(rv, rv);
         child = temp.forget();
       }
     }
     child = child->GetNextSibling();
   }
   if (aList->IsElement() && aList->AsElement()->IsHTML(aListType)) {
     nsCOMPtr<dom::Element> list = aList->AsElement();
     list.forget(aOutList);
     return NS_OK;
   }
   return mHTMLEditor->ReplaceContainer(aList, aOutList,
                                        nsDependentAtomString(aListType));
 }
 ///////////////////////////////////////////////////////////////////////////
 // CreateStyleForInsertText:  take care of clearing and setting appropriate
 //                            style nodes for text insertion.
 //
 //
 nsresult
 nsHTMLEditRules::CreateStyleForInsertText(nsISelection *aSelection,
                                           nsIDOMDocument *aDoc)
 {
   MOZ_ASSERT(aSelection && aDoc && mHTMLEditor->mTypeInState);
   bool weDidSomething = false;
   nsCOMPtr<nsIDOMNode> node, tmp;
   int32_t offset;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res = mHTMLEditor->GetStartNodeAndOffset(aSelection,
                                                     getter_AddRefs(node),
                                                     &offset);
   NS_ENSURE_SUCCESS(res, res);
   // next examine our present style and make sure default styles are either
   // present or explicitly overridden.  If neither, add the default style to
   // the TypeInState
   int32_t length = mHTMLEditor->mDefaultStyles.Length();
   for (int32_t j = 0; j < length; j++) {
     PropItem* propItem = mHTMLEditor->mDefaultStyles[j];
     MOZ_ASSERT(propItem);
     bool bFirst, bAny, bAll;
     // GetInlineProperty also examine TypeInState.  The only gotcha here is
     // that a cleared property looks like an unset property.  For now I'm
     // assuming that's not a problem: that default styles will always be
     // multivalue styles (like font face or size) where clearing the style
     // means we want to go back to the default.  If we ever wanted a "toggle"
     // style like bold for a default, though, I'll have to add code to detect
     // the difference between unset and explicitly cleared, else user would
     // never be able to unbold, for instance.
     nsAutoString curValue;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetInlinePropertyBase(propItem->tag, &propItem->attr,
                                              nullptr, &bFirst, &bAny, &bAll,
                                              &curValue, false);
     NS_ENSURE_SUCCESS(res, res);
     if (!bAny) {
       // no style set for this prop/attr
       mHTMLEditor->mTypeInState->SetProp(propItem->tag, propItem->attr,
                                          propItem->value);
     }
   }
   nsCOMPtr<nsIDOMElement> rootElement;
   res = aDoc->GetDocumentElement(getter_AddRefs(rootElement));
   NS_ENSURE_SUCCESS(res, res);
   // process clearing any styles first
   nsAutoPtr<PropItem> item(mHTMLEditor->mTypeInState->TakeClearProperty());
   while (item && node != rootElement) {
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->ClearStyle(address_of(node), &offset,
                                   item->tag, &item->attr);
     NS_ENSURE_SUCCESS(res, res);
     item = mHTMLEditor->mTypeInState->TakeClearProperty();
     weDidSomething = true;
   }
   // then process setting any styles
   int32_t relFontSize = mHTMLEditor->mTypeInState->TakeRelativeFontSize();
   item = mHTMLEditor->mTypeInState->TakeSetProperty();
   if (item || relFontSize) {
     // we have at least one style to add; make a new text node to insert style
     // nodes above.
     if (mHTMLEditor->IsTextNode(node)) {
       // if we are in a text node, split it
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->SplitNodeDeep(node, node, offset, &offset);
       NS_ENSURE_SUCCESS(res, res);
       node->GetParentNode(getter_AddRefs(tmp));
       node = tmp;
     }
     if (!mHTMLEditor->IsContainer(node)) {
       return NS_OK;
     }
     nsCOMPtr<nsIDOMNode> newNode;
     nsCOMPtr<nsIDOMText> nodeAsText;
     res = aDoc->CreateTextNode(EmptyString(), getter_AddRefs(nodeAsText));
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_TRUE(nodeAsText, NS_ERROR_NULL_POINTER);
     newNode = do_QueryInterface(nodeAsText);
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->InsertNode(newNode, node, offset);
     NS_ENSURE_SUCCESS(res, res);
     node = newNode;
     offset = 0;
     weDidSomething = true;
     if (relFontSize) {
       // dir indicated bigger versus smaller.  1 = bigger, -1 = smaller
       int32_t dir = relFontSize > 0 ? 1 : -1;
       for (int32_t j = 0; j < DeprecatedAbs(relFontSize); j++) {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->RelativeFontChangeOnTextNode(dir, nodeAsText,
 , -1);
         NS_ENSURE_SUCCESS(res, res);
       }
     }
     while (item) {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->SetInlinePropertyOnNode(node, item->tag, &item->attr,
                                                  &item->value);
       NS_ENSURE_SUCCESS(res, res);
       item = mHTMLEditor->mTypeInState->TakeSetProperty();
     }
   }
   if (weDidSomething) {
     return aSelection->Collapse(node, offset);
   }
   return NS_OK;
 }
 ///////////////////////////////////////////////////////////////////////////
 // IsEmptyBlock: figure out if aNode is (or is inside) an empty block.
 //               A block can have children and still be considered empty,
 //               if the children are empty or non-editable.
 //
 nsresult
 nsHTMLEditRules::IsEmptyBlock(nsIDOMNode *aNode,
                               bool *outIsEmptyBlock,
                               bool aMozBRDoesntCount,
                               bool aListItemsNotEmpty)
 {
   NS_ENSURE_TRUE(aNode && outIsEmptyBlock, NS_ERROR_NULL_POINTER);
   *outIsEmptyBlock = true;
 //  nsresult res = NS_OK;
   nsCOMPtr<nsIDOMNode> nodeToTest;
   if (IsBlockNode(aNode)) nodeToTest = do_QueryInterface(aNode);
 //  else nsCOMPtr<nsIDOMElement> block;
 //  looks like I forgot to finish this.  Wonder what I was going to do?
   NS_ENSURE_TRUE(nodeToTest, NS_ERROR_NULL_POINTER);
   return mHTMLEditor->IsEmptyNode(nodeToTest, outIsEmptyBlock,
                      aMozBRDoesntCount, aListItemsNotEmpty);
 }
 nsresult
 nsHTMLEditRules::WillAlign(Selection* aSelection,
                            const nsAString *alignType,
                            bool *aCancel,
                            bool *aHandled)
 {
   if (!aSelection || !aCancel || !aHandled) { return NS_ERROR_NULL_POINTER; }
   nsresult res = WillInsert(aSelection, aCancel);
   NS_ENSURE_SUCCESS(res, res);
   // initialize out param
   // we want to ignore result of WillInsert()
   *aCancel = false;
   *aHandled = false;
   res = NormalizeSelection(aSelection);
   NS_ENSURE_SUCCESS(res, res);
   nsAutoSelectionReset selectionResetter(aSelection, mHTMLEditor);
   // convert the selection ranges into "promoted" selection ranges:
   // this basically just expands the range to include the immediate
   // block parent, and then further expands to include any ancestors
   // whose children are all in the range
   *aHandled = true;
   nsCOMArray<nsIDOMNode> arrayOfNodes;
   res = GetNodesFromSelection(aSelection, EditAction::align, arrayOfNodes);
   NS_ENSURE_SUCCESS(res, res);
   // if we don't have any nodes, or we have only a single br, then we are
   // creating an empty alignment div.  We have to do some different things for these.
   bool emptyDiv = false;
   int32_t listCount = arrayOfNodes.Count();
   if (!listCount) emptyDiv = true;
   if (listCount == 1)
   {
     nsCOMPtr<nsIDOMNode> theNode = arrayOfNodes[0];
     if (nsHTMLEditUtils::SupportsAlignAttr(theNode))
     {
       // the node is a table element, an horiz rule, a paragraph, a div
       // or a section header; in HTML 4, it can directly carry the ALIGN
       // attribute and we don't need to make a div! If we are in CSS mode,
       // all the work is done in AlignBlock
       nsCOMPtr<nsIDOMElement> theElem = do_QueryInterface(theNode);
       res = AlignBlock(theElem, alignType, true);
       NS_ENSURE_SUCCESS(res, res);
       return NS_OK;
     }
     if (nsTextEditUtils::IsBreak(theNode))
     {
       // The special case emptyDiv code (below) that consumes BRs can
       // cause tables to split if the start node of the selection is
       // not in a table cell or caption, for example parent is a <tr>.
       // Avoid this unnecessary splitting if possible by leaving emptyDiv
       // FALSE so that we fall through to the normal case alignment code.
       //
       // XXX: It seems a little error prone for the emptyDiv special
       //      case code to assume that the start node of the selection
       //      is the parent of the single node in the arrayOfNodes, as
       //      the paragraph above points out. Do we rely on the selection
       //      start node because of the fact that arrayOfNodes can be empty?
       //      We should probably revisit this issue. - kin
       nsCOMPtr<nsIDOMNode> parent;
       int32_t offset;
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(parent), &offset);
       if (!nsHTMLEditUtils::IsTableElement(parent) || nsHTMLEditUtils::IsTableCellOrCaption(parent))
         emptyDiv = true;
     }
   }
   if (emptyDiv)
   {
     int32_t offset;
     nsCOMPtr<nsIDOMNode> brNode, parent, theDiv, sib;
     NS_NAMED_LITERAL_STRING(divType, "div");
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(parent), &offset);
     NS_ENSURE_SUCCESS(res, res);
     res = SplitAsNeeded(&divType, address_of(parent), &offset);
     NS_ENSURE_SUCCESS(res, res);
     // consume a trailing br, if any.  This is to keep an alignment from
     // creating extra lines, if possible.
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetNextHTMLNode(parent, offset, address_of(brNode));
     NS_ENSURE_SUCCESS(res, res);
     if (brNode && nsTextEditUtils::IsBreak(brNode))
     {
       // making use of html structure... if next node after where
       // we are putting our div is not a block, then the br we
       // found is in same block we are, so its safe to consume it.
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->GetNextHTMLSibling(parent, offset, address_of(sib));
       NS_ENSURE_SUCCESS(res, res);
       if (!IsBlockNode(sib))
       {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->DeleteNode(brNode);
         NS_ENSURE_SUCCESS(res, res);
       }
     }
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->CreateNode(divType, parent, offset, getter_AddRefs(theDiv));
     NS_ENSURE_SUCCESS(res, res);
     // remember our new block for postprocessing
     mNewBlock = theDiv;
     // set up the alignment on the div, using HTML or CSS
     nsCOMPtr<nsIDOMElement> divElem = do_QueryInterface(theDiv);
     res = AlignBlock(divElem, alignType, true);
     NS_ENSURE_SUCCESS(res, res);
     *aHandled = true;
     // put in a moz-br so that it won't get deleted
     res = CreateMozBR(theDiv, 0);
     NS_ENSURE_SUCCESS(res, res);
     res = aSelection->Collapse(theDiv, 0);
     selectionResetter.Abort();  // don't reset our selection in this case.
     return res;
   }
   // Next we detect all the transitions in the array, where a transition
   // means that adjacent nodes in the array don't have the same parent.
   nsTArray<bool> transitionList;
   res = MakeTransitionList(arrayOfNodes, transitionList);
   NS_ENSURE_SUCCESS(res, res);
   // Ok, now go through all the nodes and give them an align attrib or put them in a div,
   // or whatever is appropriate.  Wohoo!
   nsCOMPtr<nsIDOMNode> curParent;
   nsCOMPtr<nsIDOMNode> curDiv;
   bool useCSS = mHTMLEditor->IsCSSEnabled();
   for (int32_t i = 0; i < listCount; ++i) {
     // here's where we actually figure out what to do
     nsCOMPtr<nsIDOMNode> curNode = arrayOfNodes[i];
     // Ignore all non-editable nodes.  Leave them be.
     if (!mHTMLEditor->IsEditable(curNode)) continue;
     int32_t offset;
     curParent = nsEditor::GetNodeLocation(curNode, &offset);
     // the node is a table element, an horiz rule, a paragraph, a div
     // or a section header; in HTML 4, it can directly carry the ALIGN
     // attribute and we don't need to nest it, just set the alignment.
     // In CSS, assign the corresponding CSS styles in AlignBlock
     if (nsHTMLEditUtils::SupportsAlignAttr(curNode))
     {
       nsCOMPtr<nsIDOMElement> curElem = do_QueryInterface(curNode);
       res = AlignBlock(curElem, alignType, false);
       NS_ENSURE_SUCCESS(res, res);
       // clear out curDiv so that we don't put nodes after this one into it
       curDiv = 0;
       continue;
     }
     // Skip insignificant formatting text nodes to prevent
     // unnecessary structure splitting!
     bool isEmptyTextNode = false;
     if (nsEditor::IsTextNode(curNode) &&
        ((nsHTMLEditUtils::IsTableElement(curParent) && !nsHTMLEditUtils::IsTableCellOrCaption(curParent)) ||
         nsHTMLEditUtils::IsList(curParent) ||
         (NS_SUCCEEDED(mHTMLEditor->IsEmptyNode(curNode, &isEmptyTextNode)) && isEmptyTextNode)))
       continue;
     // if it's a list item, or a list
     // inside a list, forget any "current" div, and instead put divs inside
     // the appropriate block (td, li, etc)
     if ( nsHTMLEditUtils::IsListItem(curNode)
          || nsHTMLEditUtils::IsList(curNode))
     {
       res = RemoveAlignment(curNode, *alignType, true);
       NS_ENSURE_SUCCESS(res, res);
       if (useCSS) {
         nsCOMPtr<nsIDOMElement> curElem = do_QueryInterface(curNode);
         NS_NAMED_LITERAL_STRING(attrName, "align");
         int32_t count;
         mHTMLEditor->mHTMLCSSUtils->SetCSSEquivalentToHTMLStyle(curNode, nullptr,
                                                                 &attrName, alignType,
                                                                 &count, false);
         curDiv = 0;
         continue;
       }
       else if (nsHTMLEditUtils::IsList(curParent)) {
         // if we don't use CSS, add a contraint to list element : they have
         // to be inside another list, ie >= second level of nesting
         res = AlignInnerBlocks(curNode, alignType);
         NS_ENSURE_SUCCESS(res, res);
         curDiv = 0;
         continue;
       }
       // clear out curDiv so that we don't put nodes after this one into it
     }
     // need to make a div to put things in if we haven't already,
     // or if this node doesn't go in div we used earlier.
     if (!curDiv || transitionList[i])
     {
       // First, check that our element can contain a div.
       NS_NAMED_LITERAL_STRING(divType, "div");
       if (!mEditor->CanContainTag(curParent, nsGkAtoms::div)) {
         return NS_OK; // cancelled
       }
       res = SplitAsNeeded(&divType, address_of(curParent), &offset);
       NS_ENSURE_SUCCESS(res, res);
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->CreateNode(divType, curParent, offset, getter_AddRefs(curDiv));
       NS_ENSURE_SUCCESS(res, res);
       // remember our new block for postprocessing
       mNewBlock = curDiv;
       // set up the alignment on the div
       nsCOMPtr<nsIDOMElement> divElem = do_QueryInterface(curDiv);
       res = AlignBlock(divElem, alignType, true);
       //nsAutoString attr(NS_LITERAL_STRING("align"));
       //res = mHTMLEditor->SetAttribute(divElem, attr, *alignType);
       //NS_ENSURE_SUCCESS(res, res);
       // curDiv is now the correct thing to put curNode in
     }
     // tuck the node into the end of the active div
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->MoveNode(curNode, curDiv, -1);
     NS_ENSURE_SUCCESS(res, res);
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // AlignInnerBlocks: align inside table cells or list items
 //
 nsresult
 nsHTMLEditRules::AlignInnerBlocks(nsIDOMNode *aNode, const nsAString *alignType)
 {
   NS_ENSURE_TRUE(aNode && alignType, NS_ERROR_NULL_POINTER);
   nsresult res;
   // gather list of table cells or list items
   nsCOMArray<nsIDOMNode> arrayOfNodes;
   nsTableCellAndListItemFunctor functor;
   nsDOMIterator iter;
   res = iter.Init(aNode);
   NS_ENSURE_SUCCESS(res, res);
   res = iter.AppendList(functor, arrayOfNodes);
   NS_ENSURE_SUCCESS(res, res);
   // now that we have the list, align their contents as requested
   int32_t listCount = arrayOfNodes.Count();
   int32_t j;
   for (j = 0; j < listCount; j++)
   {
     nsIDOMNode* node = arrayOfNodes[0];
     res = AlignBlockContents(node, alignType);
     NS_ENSURE_SUCCESS(res, res);
     arrayOfNodes.RemoveObjectAt(0);
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // AlignBlockContents: align contents of a block element
 //
 nsresult
 nsHTMLEditRules::AlignBlockContents(nsIDOMNode *aNode, const nsAString *alignType)
 {
   NS_ENSURE_TRUE(aNode && alignType, NS_ERROR_NULL_POINTER);
   nsresult res;
   nsCOMPtr <nsIDOMNode> firstChild, lastChild, divNode;
   bool useCSS = mHTMLEditor->IsCSSEnabled();
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetFirstEditableChild(aNode, address_of(firstChild));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetLastEditableChild(aNode, address_of(lastChild));
   NS_ENSURE_SUCCESS(res, res);
   NS_NAMED_LITERAL_STRING(attr, "align");
   if (!firstChild)
   {
     // this cell has no content, nothing to align
   }
   else if ((firstChild==lastChild) && nsHTMLEditUtils::IsDiv(firstChild))
   {
     // the cell already has a div containing all of its content: just
     // act on this div.
     nsCOMPtr<nsIDOMElement> divElem = do_QueryInterface(firstChild);
     if (useCSS) {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->SetAttributeOrEquivalent(divElem, attr, *alignType, false);
     }
     else {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->SetAttribute(divElem, attr, *alignType);
     }
     NS_ENSURE_SUCCESS(res, res);
   }
   else
   {
     // else we need to put in a div, set the alignment, and toss in all the children
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->CreateNode(NS_LITERAL_STRING("div"), aNode, 0, getter_AddRefs(divNode));
     NS_ENSURE_SUCCESS(res, res);
     // set up the alignment on the div
     nsCOMPtr<nsIDOMElement> divElem = do_QueryInterface(divNode);
     if (useCSS) {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->SetAttributeOrEquivalent(divElem, attr, *alignType, false);
     }
     else {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->SetAttribute(divElem, attr, *alignType);
     }
     NS_ENSURE_SUCCESS(res, res);
     // tuck the children into the end of the active div
     while (lastChild && (lastChild != divNode))
     {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->MoveNode(lastChild, divNode, 0);
       NS_ENSURE_SUCCESS(res, res);
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->GetLastEditableChild(aNode, address_of(lastChild));
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // CheckForEmptyBlock: Called by WillDeleteSelection to detect and handle
 //                     case of deleting from inside an empty block.
 //
 nsresult
 nsHTMLEditRules::CheckForEmptyBlock(nsIDOMNode *aStartNode,
                                     nsIDOMNode *aBodyNode,
                                     nsISelection *aSelection,
                                     bool *aHandled)
 {
   // If the editing host is an inline element, bail out early.
   if (IsInlineNode(aBodyNode)) {
     return NS_OK;
   }
   // if we are inside an empty block, delete it.
   // Note: do NOT delete table elements this way.
   nsresult res = NS_OK;
   nsCOMPtr<nsIDOMNode> block, emptyBlock;
   if (IsBlockNode(aStartNode))
     block = aStartNode;
   else
     block = mHTMLEditor->GetBlockNodeParent(aStartNode);
   bool bIsEmptyNode;
   if (block != aBodyNode)  // efficiency hack. avoiding IsEmptyNode() call when in body
   {
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->IsEmptyNode(block, &bIsEmptyNode, true, false);
     NS_ENSURE_SUCCESS(res, res);
     while (bIsEmptyNode && !nsHTMLEditUtils::IsTableElement(block) && (block != aBodyNode))
     {
       emptyBlock = block;
       block = mHTMLEditor->GetBlockNodeParent(emptyBlock);
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->IsEmptyNode(block, &bIsEmptyNode, true, false);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   nsCOMPtr<nsIContent> emptyContent = do_QueryInterface(emptyBlock);
   if (emptyBlock && emptyContent->IsEditable())
   {
     int32_t offset;
     nsCOMPtr<nsIDOMNode> blockParent = nsEditor::GetNodeLocation(emptyBlock, &offset);
     NS_ENSURE_TRUE(blockParent && offset >= 0, NS_ERROR_FAILURE);
     if (nsHTMLEditUtils::IsListItem(emptyBlock))
     {
       // are we the first list item in the list?
       bool bIsFirst;
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->IsFirstEditableChild(emptyBlock, &bIsFirst);
       NS_ENSURE_SUCCESS(res, res);
       if (bIsFirst)
       {
         int32_t listOffset;
         nsCOMPtr<nsIDOMNode> listParent = nsEditor::GetNodeLocation(blockParent,
                                                                     &listOffset);
         NS_ENSURE_TRUE(listParent && listOffset >= 0, NS_ERROR_FAILURE);
         // if we are a sublist, skip the br creation
         if (!nsHTMLEditUtils::IsList(listParent))
         {
           // create a br before list
           nsCOMPtr<nsIDOMNode> brNode;
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->CreateBR(listParent, listOffset, address_of(brNode));
           NS_ENSURE_SUCCESS(res, res);
           // adjust selection to be right before it
           res = aSelection->Collapse(listParent, listOffset);
           NS_ENSURE_SUCCESS(res, res);
         }
         // else just let selection perculate up.  We'll adjust it in AfterEdit()
       }
     }
     else
     {
       // adjust selection to be right after it
       res = aSelection->Collapse(blockParent, offset+1);
       NS_ENSURE_SUCCESS(res, res);
     }
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->DeleteNode(emptyBlock);
     *aHandled = true;
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::CheckForInvisibleBR(nsIDOMNode *aBlock,
                                      BRLocation aWhere,
                                      nsCOMPtr<nsIDOMNode> *outBRNode,
                                      int32_t aOffset)
 {
   NS_ENSURE_TRUE(aBlock && outBRNode, NS_ERROR_NULL_POINTER);
   *outBRNode = nullptr;
   nsCOMPtr<nsIDOMNode> testNode;
   int32_t testOffset = 0;
   bool runTest = false;
   if (aWhere == kBlockEnd)
   {
     nsCOMPtr<nsIDOMNode> rightmostNode =
       mHTMLEditor->GetRightmostChild(aBlock, true); // no block crossing
     if (rightmostNode)
     {
       int32_t nodeOffset;
       nsCOMPtr<nsIDOMNode> nodeParent = nsEditor::GetNodeLocation(rightmostNode,
                                                                   &nodeOffset);
       runTest = true;
       testNode = nodeParent;
       // use offset + 1, because we want the last node included in our
       // evaluation
       testOffset = nodeOffset + 1;
     }
   }
   else if (aOffset)
   {
     runTest = true;
     testNode = aBlock;
     // we'll check everything to the left of the input position
     testOffset = aOffset;
   }
   if (runTest)
   {
     nsWSRunObject wsTester(mHTMLEditor, testNode, testOffset);
     if (WSType::br == wsTester.mStartReason) {
       *outBRNode = wsTester.mStartReasonNode;
     }
   }
   return NS_OK;
 }
 ///////////////////////////////////////////////////////////////////////////
 // GetInnerContent: aList and aTbl allow the caller to specify what kind
 //                  of content to "look inside".  If aTbl is true, look inside
 //                  any table content, and insert the inner content into the
 //                  supplied issupportsarray at offset aIndex.
 //                  Similarly with aList and list content.
 //                  aIndex is updated to point past inserted elements.
 //
 nsresult
 nsHTMLEditRules::GetInnerContent(nsIDOMNode *aNode, nsCOMArray<nsIDOMNode> &outArrayOfNodes,
                                  int32_t *aIndex, bool aList, bool aTbl)
 {
   NS_ENSURE_TRUE(aNode && aIndex, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIDOMNode> node;
   nsresult res = mHTMLEditor->GetFirstEditableChild(aNode, address_of(node));
   while (NS_SUCCEEDED(res) && node)
   {
     if (  ( aList && (nsHTMLEditUtils::IsList(node)     ||
                       nsHTMLEditUtils::IsListItem(node) ) )
        || ( aTbl && nsHTMLEditUtils::IsTableElement(node) )  )
     {
       res = GetInnerContent(node, outArrayOfNodes, aIndex, aList, aTbl);
       NS_ENSURE_SUCCESS(res, res);
     }
     else
     {
       outArrayOfNodes.InsertObjectAt(node, *aIndex);
       (*aIndex)++;
     }
     nsCOMPtr<nsIDOMNode> tmp;
     res = node->GetNextSibling(getter_AddRefs(tmp));
     node = tmp;
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // ExpandSelectionForDeletion: this promotes our selection to include blocks
 // that have all their children selected.
 //
 nsresult
 nsHTMLEditRules::ExpandSelectionForDeletion(nsISelection *aSelection)
 {
   NS_ENSURE_TRUE(aSelection, NS_ERROR_NULL_POINTER);
   // don't need to touch collapsed selections
   if (aSelection->Collapsed()) {
     return NS_OK;
   }
   int32_t rangeCount;
   nsresult res = aSelection->GetRangeCount(&rangeCount);
   NS_ENSURE_SUCCESS(res, res);
   // we don't need to mess with cell selections, and we assume multirange selections are those.
   if (rangeCount != 1) return NS_OK;
   // find current sel start and end
   nsCOMPtr<nsIDOMRange> range;
   res = aSelection->GetRangeAt(0, getter_AddRefs(range));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(range, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIDOMNode> selStartNode, selEndNode, selCommon;
   int32_t selStartOffset, selEndOffset;
   res = range->GetStartContainer(getter_AddRefs(selStartNode));
   NS_ENSURE_SUCCESS(res, res);
   res = range->GetStartOffset(&selStartOffset);
   NS_ENSURE_SUCCESS(res, res);
   res = range->GetEndContainer(getter_AddRefs(selEndNode));
   NS_ENSURE_SUCCESS(res, res);
   res = range->GetEndOffset(&selEndOffset);
   NS_ENSURE_SUCCESS(res, res);
   // find current selection common block parent
   res = range->GetCommonAncestorContainer(getter_AddRefs(selCommon));
   NS_ENSURE_SUCCESS(res, res);
   if (!IsBlockNode(selCommon))
     selCommon = nsHTMLEditor::GetBlockNodeParent(selCommon);
   // set up for loops and cache our root element
   bool stillLooking = true;
   nsCOMPtr<nsIDOMNode> visNode, firstBRParent;
   int32_t visOffset=0, firstBROffset=0;
   WSType wsType;
   nsCOMPtr<nsIContent> rootContent = mHTMLEditor->GetActiveEditingHost();
   nsCOMPtr<nsIDOMNode> rootElement = do_QueryInterface(rootContent);
   NS_ENSURE_TRUE(rootElement, NS_ERROR_FAILURE);
   // find previous visible thingy before start of selection
   if ((selStartNode!=selCommon) && (selStartNode!=rootElement))
   {
     while (stillLooking)
     {
       nsWSRunObject wsObj(mHTMLEditor, selStartNode, selStartOffset);
       wsObj.PriorVisibleNode(selStartNode, selStartOffset, address_of(visNode),
                              &visOffset, &wsType);
       if (wsType == WSType::thisBlock) {
         // we want to keep looking up.  But stop if we are crossing table element
         // boundaries, or if we hit the root.
         if ( nsHTMLEditUtils::IsTableElement(wsObj.mStartReasonNode) ||
             (selCommon == wsObj.mStartReasonNode)                    ||
             (rootElement == wsObj.mStartReasonNode) )
         {
           stillLooking = false;
         }
         else
         {
           selStartNode = nsEditor::GetNodeLocation(wsObj.mStartReasonNode,
                                                    &selStartOffset);
         }
       }
       else
       {
         stillLooking = false;
       }
     }
   }
   stillLooking = true;
   // find next visible thingy after end of selection
   if ((selEndNode!=selCommon) && (selEndNode!=rootElement))
   {
     while (stillLooking)
     {
       nsWSRunObject wsObj(mHTMLEditor, selEndNode, selEndOffset);
       wsObj.NextVisibleNode(selEndNode, selEndOffset, address_of(visNode),
                             &visOffset, &wsType);
       if (wsType == WSType::br) {
         if (mHTMLEditor->IsVisBreak(wsObj.mEndReasonNode))
         {
           stillLooking = false;
         }
         else
         {
           if (!firstBRParent)
           {
             firstBRParent = selEndNode;
             firstBROffset = selEndOffset;
           }
           selEndNode = nsEditor::GetNodeLocation(wsObj.mEndReasonNode, &selEndOffset);
           ++selEndOffset;
         }
       } else if (wsType == WSType::thisBlock) {
         // we want to keep looking up.  But stop if we are crossing table element
         // boundaries, or if we hit the root.
         if ( nsHTMLEditUtils::IsTableElement(wsObj.mEndReasonNode) ||
             (selCommon == wsObj.mEndReasonNode)                    ||
             (rootElement == wsObj.mEndReasonNode) )
         {
           stillLooking = false;
         }
         else
         {
           selEndNode = nsEditor::GetNodeLocation(wsObj.mEndReasonNode, &selEndOffset);
           ++selEndOffset;
         }
        }
       else
       {
         stillLooking = false;
       }
     }
   }
   // now set the selection to the new range
   aSelection->Collapse(selStartNode, selStartOffset);
   // expand selection endpoint only if we didnt pass a br,
   // or if we really needed to pass that br (ie, its block is now
   // totally selected)
   bool doEndExpansion = true;
   if (firstBRParent)
   {
     // find block node containing br
     nsCOMPtr<nsIDOMNode> brBlock = firstBRParent;
     if (!IsBlockNode(brBlock))
       brBlock = nsHTMLEditor::GetBlockNodeParent(brBlock);
     bool nodeBefore=false, nodeAfter=false;
     // create a range that represents expanded selection
     nsCOMPtr<nsINode> node = do_QueryInterface(selStartNode);
     NS_ENSURE_STATE(node);
     nsRefPtr<nsRange> range = new nsRange(node);
     res = range->SetStart(selStartNode, selStartOffset);
     NS_ENSURE_SUCCESS(res, res);
     res = range->SetEnd(selEndNode, selEndOffset);
     NS_ENSURE_SUCCESS(res, res);
     // check if block is entirely inside range
     nsCOMPtr<nsIContent> brContentBlock = do_QueryInterface(brBlock);
     res = nsRange::CompareNodeToRange(brContentBlock, range, &nodeBefore, &nodeAfter);
     // if block isn't contained, forgo grabbing the br in the expanded selection
     if (nodeBefore || nodeAfter)
       doEndExpansion = false;
   }
   if (doEndExpansion)
   {
     res = aSelection->Extend(selEndNode, selEndOffset);
   }
   else
   {
     // only expand to just before br
     res = aSelection->Extend(firstBRParent, firstBROffset);
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // NormalizeSelection:  tweak non-collapsed selections to be more "natural".
 //    Idea here is to adjust selection endpoint so that they do not cross
 //    breaks or block boundaries unless something editable beyond that boundary
 //    is also selected.  This adjustment makes it much easier for the various
 //    block operations to determine what nodes to act on.
 //
 nsresult
 nsHTMLEditRules::NormalizeSelection(nsISelection *inSelection)
 {
   NS_ENSURE_TRUE(inSelection, NS_ERROR_NULL_POINTER);
   // don't need to touch collapsed selections
   if (inSelection->Collapsed()) {
     return NS_OK;
   }
   int32_t rangeCount;
   nsresult res = inSelection->GetRangeCount(&rangeCount);
   NS_ENSURE_SUCCESS(res, res);
   // we don't need to mess with cell selections, and we assume multirange selections are those.
   if (rangeCount != 1) return NS_OK;
   nsCOMPtr<nsIDOMRange> range;
   res = inSelection->GetRangeAt(0, getter_AddRefs(range));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(range, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIDOMNode> startNode, endNode;
   int32_t startOffset, endOffset;
   nsCOMPtr<nsIDOMNode> newStartNode, newEndNode;
   int32_t newStartOffset, newEndOffset;
   res = range->GetStartContainer(getter_AddRefs(startNode));
   NS_ENSURE_SUCCESS(res, res);
   res = range->GetStartOffset(&startOffset);
   NS_ENSURE_SUCCESS(res, res);
   res = range->GetEndContainer(getter_AddRefs(endNode));
   NS_ENSURE_SUCCESS(res, res);
   res = range->GetEndOffset(&endOffset);
   NS_ENSURE_SUCCESS(res, res);
   // adjusted values default to original values
   newStartNode = startNode;
   newStartOffset = startOffset;
   newEndNode = endNode;
   newEndOffset = endOffset;
   // some locals we need for whitespace code
   nsCOMPtr<nsIDOMNode> someNode;
   int32_t offset;
   WSType wsType;
   // let the whitespace code do the heavy lifting
   nsWSRunObject wsEndObj(mHTMLEditor, endNode, endOffset);
   // is there any intervening visible whitespace?  if so we can't push selection past that,
   // it would visibly change maening of users selection
   wsEndObj.PriorVisibleNode(endNode, endOffset, address_of(someNode),
                             &offset, &wsType);
   if (wsType != WSType::text && wsType != WSType::normalWS) {
     // eThisBlock and eOtherBlock conveniently distinquish cases
     // of going "down" into a block and "up" out of a block.
     if (wsEndObj.mStartReason == WSType::otherBlock) {
       // endpoint is just after the close of a block.
       nsCOMPtr<nsIDOMNode> child = mHTMLEditor->GetRightmostChild(wsEndObj.mStartReasonNode, true);
       if (child)
       {
         newEndNode = nsEditor::GetNodeLocation(child, &newEndOffset);
         ++newEndOffset; // offset *after* child
       }
       // else block is empty - we can leave selection alone here, i think.
     } else if (wsEndObj.mStartReason == WSType::thisBlock) {
       // endpoint is just after start of this block
       nsCOMPtr<nsIDOMNode> child;
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->GetPriorHTMLNode(endNode, endOffset, address_of(child));
       if (child)
       {
         newEndNode = nsEditor::GetNodeLocation(child, &newEndOffset);
         ++newEndOffset; // offset *after* child
       }
       // else block is empty - we can leave selection alone here, i think.
     } else if (wsEndObj.mStartReason == WSType::br) {
       // endpoint is just after break.  lets adjust it to before it.
       newEndNode = nsEditor::GetNodeLocation(wsEndObj.mStartReasonNode,
                                              &newEndOffset);
     }
   }
   // similar dealio for start of range
   nsWSRunObject wsStartObj(mHTMLEditor, startNode, startOffset);
   // is there any intervening visible whitespace?  if so we can't push selection past that,
   // it would visibly change maening of users selection
   wsStartObj.NextVisibleNode(startNode, startOffset, address_of(someNode),
                              &offset, &wsType);
   if (wsType != WSType::text && wsType != WSType::normalWS) {
     // eThisBlock and eOtherBlock conveniently distinquish cases
     // of going "down" into a block and "up" out of a block.
     if (wsStartObj.mEndReason == WSType::otherBlock) {
       // startpoint is just before the start of a block.
       nsCOMPtr<nsIDOMNode> child = mHTMLEditor->GetLeftmostChild(wsStartObj.mEndReasonNode, true);
       if (child)
       {
         newStartNode = nsEditor::GetNodeLocation(child, &newStartOffset);
       }
       // else block is empty - we can leave selection alone here, i think.
     } else if (wsStartObj.mEndReason == WSType::thisBlock) {
       // startpoint is just before end of this block
       nsCOMPtr<nsIDOMNode> child;
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->GetNextHTMLNode(startNode, startOffset, address_of(child));
       if (child)
       {
         newStartNode = nsEditor::GetNodeLocation(child, &newStartOffset);
       }
       // else block is empty - we can leave selection alone here, i think.
     } else if (wsStartObj.mEndReason == WSType::br) {
       // startpoint is just before a break.  lets adjust it to after it.
       newStartNode = nsEditor::GetNodeLocation(wsStartObj.mEndReasonNode,
                                                &newStartOffset);
       ++newStartOffset; // offset *after* break
     }
   }
   // there is a demented possiblity we have to check for.  We might have a very strange selection
   // that is not collapsed and yet does not contain any editable content, and satisfies some of the
   // above conditions that cause tweaking.  In this case we don't want to tweak the selection into
   // a block it was never in, etc.  There are a variety of strategies one might use to try to
   // detect these cases, but I think the most straightforward is to see if the adjusted locations
   // "cross" the old values: ie, new end before old start, or new start after old end.  If so
   // then just leave things alone.
   int16_t comp;
   comp = nsContentUtils::ComparePoints(startNode, startOffset,
                                        newEndNode, newEndOffset);
   if (comp == 1) return NS_OK;  // new end before old start
   comp = nsContentUtils::ComparePoints(newStartNode, newStartOffset,
                                        endNode, endOffset);
   if (comp == 1) return NS_OK;  // new start after old end
   // otherwise set selection to new values.
   inSelection->Collapse(newStartNode, newStartOffset);
   inSelection->Extend(newEndNode, newEndOffset);
   return NS_OK;
 }
 ///////////////////////////////////////////////////////////////////////////
 // GetPromotedPoint: figure out where a start or end point for a block
 //                   operation really is
 void
 nsHTMLEditRules::GetPromotedPoint(RulesEndpoint aWhere, nsIDOMNode* aNode,
                                   int32_t aOffset,
                                   EditAction actionID,
                                   nsCOMPtr<nsIDOMNode>* outNode,
                                   int32_t* outOffset)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   MOZ_ASSERT(node && outNode && outOffset);
   // default values
   *outNode = node->AsDOMNode();
   *outOffset = aOffset;
   // we do one thing for text actions, something else entirely for other
   // actions
   if (actionID == EditAction::insertText ||
       actionID == EditAction::insertIMEText ||
       actionID == EditAction::insertBreak ||
       actionID == EditAction::deleteText) {
     bool isSpace, isNBSP;
     nsCOMPtr<nsIContent> content = do_QueryInterface(node), temp;
     // for text actions, we want to look backwards (or forwards, as
     // appropriate) for additional whitespace or nbsp's.  We may have to act on
     // these later even though they are outside of the initial selection.  Even
     // if they are in another node!
     while (content) {
       int32_t offset;
       if (aWhere == kStart) {
         NS_ENSURE_TRUE(mHTMLEditor, /* void */);
         mHTMLEditor->IsPrevCharInNodeWhitespace(content, *outOffset,
                                                 &isSpace, &isNBSP,
                                                 getter_AddRefs(temp), &offset);
       } else {
         NS_ENSURE_TRUE(mHTMLEditor, /* void */);
         mHTMLEditor->IsNextCharInNodeWhitespace(content, *outOffset,
                                                 &isSpace, &isNBSP,
                                                 getter_AddRefs(temp), &offset);
       }
       if (isSpace || isNBSP) {
         content = temp;
         *outOffset = offset;
       } else {
         break;
       }
     }
     *outNode = content->AsDOMNode();
     return;
   }
   int32_t offset = aOffset;
   // else not a text section.  In this case we want to see if we should grab
   // any adjacent inline nodes and/or parents and other ancestors
   if (aWhere == kStart) {
     // some special casing for text nodes
     if (node->IsNodeOfType(nsINode::eTEXT)) {
       if (!node->GetParentNode()) {
         // Okay, can't promote any further
         return;
       }
       offset = node->GetParentNode()->IndexOf(node);
       node = node->GetParentNode();
     }
     // look back through any further inline nodes that aren't across a <br>
     // from us, and that are enclosed in the same block.
     NS_ENSURE_TRUE(mHTMLEditor, /* void */);
     nsCOMPtr<nsINode> priorNode =
       mHTMLEditor->GetPriorHTMLNode(node, offset, true);
     while (priorNode && priorNode->GetParentNode() &&
            mHTMLEditor && !mHTMLEditor->IsVisBreak(priorNode->AsDOMNode()) &&
            !IsBlockNode(priorNode->AsDOMNode())) {
       offset = priorNode->GetParentNode()->IndexOf(priorNode);
       node = priorNode->GetParentNode();
       NS_ENSURE_TRUE(mHTMLEditor, /* void */);
       priorNode = mHTMLEditor->GetPriorHTMLNode(node, offset, true);
     }
     // finding the real start for this point.  look up the tree for as long as
     // we are the first node in the container, and as long as we haven't hit
     // the body node.
     NS_ENSURE_TRUE(mHTMLEditor, /* void */);
     nsCOMPtr<nsIContent> nearNode =
       mHTMLEditor->GetPriorHTMLNode(node, offset, true);
     while (!nearNode && node->Tag() != nsGkAtoms::body &&
            node->GetParentNode()) {
       // some cutoffs are here: we don't need to also include them in the
       // aWhere == kEnd case.  as long as they are in one or the other it will
       // work.  special case for outdent: don't keep looking up if we have
       // found a blockquote element to act on
       if (actionID == EditAction::outdent &&
           node->Tag() == nsGkAtoms::blockquote) {
         break;
       }
       int32_t parentOffset = node->GetParentNode()->IndexOf(node);
       nsCOMPtr<nsINode> parent = node->GetParentNode();
       // Don't walk past the editable section. Note that we need to check
       // before walking up to a parent because we need to return the parent
       // object, so the parent itself might not be in the editable area, but
       // it's OK if we're not performing a block-level action.
       bool blockLevelAction = actionID == EditAction::indent ||
                               actionID == EditAction::outdent ||
                               actionID == EditAction::align ||
                               actionID == EditAction::makeBasicBlock;
       NS_ENSURE_TRUE(mHTMLEditor, /* void */);
       if (!mHTMLEditor->IsDescendantOfEditorRoot(parent) &&
           (blockLevelAction || !mHTMLEditor ||
            !mHTMLEditor->IsDescendantOfEditorRoot(node))) {
         NS_ENSURE_TRUE(mHTMLEditor, /* void */);
         break;
       }
       node = parent;
       offset = parentOffset;
       NS_ENSURE_TRUE(mHTMLEditor, /* void */);
       nearNode = mHTMLEditor->GetPriorHTMLNode(node, offset, true);
     }
     *outNode = node->AsDOMNode();
     *outOffset = offset;
     return;
   }
   // aWhere == kEnd
   // some special casing for text nodes
   if (node->IsNodeOfType(nsINode::eTEXT)) {
     if (!node->GetParentNode()) {
       // Okay, can't promote any further
       return;
     }
     // want to be after the text node
     offset = 1 + node->GetParentNode()->IndexOf(node);
     node = node->GetParentNode();
   }
   // look ahead through any further inline nodes that aren't across a <br> from
   // us, and that are enclosed in the same block.
   NS_ENSURE_TRUE(mHTMLEditor, /* void */);
   nsCOMPtr<nsIContent> nextNode =
     mHTMLEditor->GetNextHTMLNode(node, offset, true);
   while (nextNode && !IsBlockNode(nextNode->AsDOMNode()) &&
          nextNode->GetParentNode()) {
     offset = 1 + nextNode->GetParentNode()->IndexOf(nextNode);
     node = nextNode->GetParentNode();
     NS_ENSURE_TRUE(mHTMLEditor, /* void */);
     if (mHTMLEditor->IsVisBreak(nextNode->AsDOMNode())) {
       break;
     }
     NS_ENSURE_TRUE(mHTMLEditor, /* void */);
     nextNode = mHTMLEditor->GetNextHTMLNode(node, offset, true);
   }
   // finding the real end for this point.  look up the tree for as long as we
   // are the last node in the container, and as long as we haven't hit the body
   // node.
   NS_ENSURE_TRUE(mHTMLEditor, /* void */);
   nsCOMPtr<nsIContent> nearNode =
     mHTMLEditor->GetNextHTMLNode(node, offset, true);
   while (!nearNode && node->Tag() != nsGkAtoms::body &&
          node->GetParentNode()) {
     int32_t parentOffset = node->GetParentNode()->IndexOf(node);
     nsCOMPtr<nsINode> parent = node->GetParentNode();
     // Don't walk past the editable section. Note that we need to check before
     // walking up to a parent because we need to return the parent object, so
     // the parent itself might not be in the editable area, but it's OK.
     if ((!mHTMLEditor || !mHTMLEditor->IsDescendantOfEditorRoot(node)) &&
         (!mHTMLEditor || !mHTMLEditor->IsDescendantOfEditorRoot(parent))) {
       NS_ENSURE_TRUE(mHTMLEditor, /* void */);
       break;
     }
     node = parent;
     // we want to be AFTER nearNode
     offset = parentOffset + 1;
     NS_ENSURE_TRUE(mHTMLEditor, /* void */);
     nearNode = mHTMLEditor->GetNextHTMLNode(node, offset, true);
   }
   *outNode = node->AsDOMNode();
   *outOffset = offset;
 }
 ///////////////////////////////////////////////////////////////////////////
 // GetPromotedRanges: run all the selection range endpoint through
 //                    GetPromotedPoint()
 //
 nsresult
 nsHTMLEditRules::GetPromotedRanges(nsISelection *inSelection,
                                    nsCOMArray<nsIDOMRange> &outArrayOfRanges,
                                    EditAction inOperationType)
 {
   NS_ENSURE_TRUE(inSelection, NS_ERROR_NULL_POINTER);
   int32_t rangeCount;
   nsresult res = inSelection->GetRangeCount(&rangeCount);
   NS_ENSURE_SUCCESS(res, res);
   int32_t i;
   nsCOMPtr<nsIDOMRange> selectionRange;
   nsCOMPtr<nsIDOMRange> opRange;
   for (i = 0; i < rangeCount; i++)
   {
     res = inSelection->GetRangeAt(i, getter_AddRefs(selectionRange));
     NS_ENSURE_SUCCESS(res, res);
     // clone range so we don't muck with actual selection ranges
     res = selectionRange->CloneRange(getter_AddRefs(opRange));
     NS_ENSURE_SUCCESS(res, res);
     // make a new adjusted range to represent the appropriate block content.
     // The basic idea is to push out the range endpoints
     // to truly enclose the blocks that we will affect.
     // This call alters opRange.
     res = PromoteRange(opRange, inOperationType);
     NS_ENSURE_SUCCESS(res, res);
     // stuff new opRange into array
     outArrayOfRanges.AppendObject(opRange);
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // PromoteRange: expand a range to include any parents for which all
 //               editable children are already in range.
 //
 nsresult
 nsHTMLEditRules::PromoteRange(nsIDOMRange *inRange,
                               EditAction inOperationType)
 {
   NS_ENSURE_TRUE(inRange, NS_ERROR_NULL_POINTER);
   nsresult res;
   nsCOMPtr<nsIDOMNode> startNode, endNode;
   int32_t startOffset, endOffset;
   res = inRange->GetStartContainer(getter_AddRefs(startNode));
   NS_ENSURE_SUCCESS(res, res);
   res = inRange->GetStartOffset(&startOffset);
   NS_ENSURE_SUCCESS(res, res);
   res = inRange->GetEndContainer(getter_AddRefs(endNode));
   NS_ENSURE_SUCCESS(res, res);
   res = inRange->GetEndOffset(&endOffset);
   NS_ENSURE_SUCCESS(res, res);
   // MOOSE major hack:
   // GetPromotedPoint doesn't really do the right thing for collapsed ranges
   // inside block elements that contain nothing but a solo <br>.  It's easier
   // to put a workaround here than to revamp GetPromotedPoint.  :-(
   if ( (startNode == endNode) && (startOffset == endOffset))
   {
     nsCOMPtr<nsIDOMNode> block;
     if (IsBlockNode(startNode)) {
       block = startNode;
     } else {
       NS_ENSURE_STATE(mHTMLEditor);
       block = mHTMLEditor->GetBlockNodeParent(startNode);
     }
     if (block)
     {
       bool bIsEmptyNode = false;
       // check for the editing host
       NS_ENSURE_STATE(mHTMLEditor);
       nsIContent *rootContent = mHTMLEditor->GetActiveEditingHost();
       nsCOMPtr<nsINode> rootNode = do_QueryInterface(rootContent);
       nsCOMPtr<nsINode> blockNode = do_QueryInterface(block);
       NS_ENSURE_TRUE(rootNode && blockNode, NS_ERROR_UNEXPECTED);
       // Make sure we don't go higher than our root element in the content tree
       if (!nsContentUtils::ContentIsDescendantOf(rootNode, blockNode))
       {
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->IsEmptyNode(block, &bIsEmptyNode, true, false);
       }
       if (bIsEmptyNode)
       {
         uint32_t numChildren;
         nsEditor::GetLengthOfDOMNode(block, numChildren);
         startNode = block;
         endNode = block;
         startOffset = 0;
         endOffset = numChildren;
       }
     }
   }
   // make a new adjusted range to represent the appropriate block content.
   // this is tricky.  the basic idea is to push out the range endpoints
   // to truly enclose the blocks that we will affect
   nsCOMPtr<nsIDOMNode> opStartNode;
   nsCOMPtr<nsIDOMNode> opEndNode;
   int32_t opStartOffset, opEndOffset;
   nsCOMPtr<nsIDOMRange> opRange;
   GetPromotedPoint(kStart, startNode, startOffset, inOperationType,
                    address_of(opStartNode), &opStartOffset);
   GetPromotedPoint(kEnd, endNode, endOffset, inOperationType,
                    address_of(opEndNode), &opEndOffset);
   // Make sure that the new range ends up to be in the editable section.
   NS_ENSURE_STATE(mHTMLEditor);
   if (!mHTMLEditor->IsDescendantOfEditorRoot(nsEditor::GetNodeAtRangeOffsetPoint(opStartNode, opStartOffset)) ||
       !mHTMLEditor || // Check again, since it may have gone away
       !mHTMLEditor->IsDescendantOfEditorRoot(nsEditor::GetNodeAtRangeOffsetPoint(opEndNode, opEndOffset - 1))) {
     NS_ENSURE_STATE(mHTMLEditor);
     return NS_OK;
   }
   res = inRange->SetStart(opStartNode, opStartOffset);
   NS_ENSURE_SUCCESS(res, res);
   res = inRange->SetEnd(opEndNode, opEndOffset);
   return res;
 }
 class nsUniqueFunctor : public nsBoolDomIterFunctor
 {
 public:
   nsUniqueFunctor(nsCOMArray<nsIDOMNode> &aArray) : mArray(aArray)
   {
   }
   virtual bool operator()(nsIDOMNode* aNode)  // used to build list of all nodes iterator covers
   {
     return mArray.IndexOf(aNode) < 0;
   }
 private:
   nsCOMArray<nsIDOMNode> &mArray;
 };
 ///////////////////////////////////////////////////////////////////////////
 // GetNodesForOperation: run through the ranges in the array and construct
 //                       a new array of nodes to be acted on.
 //
 nsresult
 nsHTMLEditRules::GetNodesForOperation(nsCOMArray<nsIDOMRange>& inArrayOfRanges,
                                       nsCOMArray<nsIDOMNode>& outArrayOfNodes,
                                       EditAction inOperationType,
                                       bool aDontTouchContent)
 {
   int32_t rangeCount = inArrayOfRanges.Count();
   int32_t i;
   nsCOMPtr<nsIDOMRange> opRange;
   nsresult res = NS_OK;
   // bust up any inlines that cross our range endpoints,
   // but only if we are allowed to touch content.
   if (!aDontTouchContent)
   {
     nsTArray<nsRefPtr<nsRangeStore> > rangeItemArray;
     if (!rangeItemArray.AppendElements(rangeCount)) {
       return NS_ERROR_OUT_OF_MEMORY;
     }
     NS_ASSERTION(static_cast<uint32_t>(rangeCount) == rangeItemArray.Length(),
                  "How did that happen?");
     // first register ranges for special editor gravity
     for (i = 0; i < rangeCount; i++)
     {
       opRange = inArrayOfRanges[0];
       rangeItemArray[i] = new nsRangeStore();
       rangeItemArray[i]->StoreRange(opRange);
       NS_ENSURE_STATE(mHTMLEditor);
       mHTMLEditor->mRangeUpdater.RegisterRangeItem(rangeItemArray[i]);
       inArrayOfRanges.RemoveObjectAt(0);
     }
     // now bust up inlines.  Safe to start at rangeCount-1, since we
     // asserted we have enough items above.
     for (i = rangeCount-1; i >= 0 && NS_SUCCEEDED(res); i--)
     {
       res = BustUpInlinesAtRangeEndpoints(*rangeItemArray[i]);
     }
     // then unregister the ranges
     for (i = 0; i < rangeCount; i++)
     {
       nsRangeStore* item = rangeItemArray[i];
       NS_ENSURE_STATE(mHTMLEditor);
       mHTMLEditor->mRangeUpdater.DropRangeItem(item);
       nsRefPtr<nsRange> range;
       nsresult res2 = item->GetRange(getter_AddRefs(range));
       opRange = range;
       if (NS_FAILED(res2) && NS_SUCCEEDED(res)) {
         // Remember the failure, but keep going so we make sure to unregister
         // all our range items.
         res = res2;
       }
       inArrayOfRanges.AppendObject(opRange);
     }
     NS_ENSURE_SUCCESS(res, res);
   }
   // gather up a list of all the nodes
   for (i = 0; i < rangeCount; i++)
   {
     opRange = inArrayOfRanges[i];
     nsDOMSubtreeIterator iter;
     res = iter.Init(opRange);
     NS_ENSURE_SUCCESS(res, res);
     if (outArrayOfNodes.Count() == 0) {
       nsTrivialFunctor functor;
       res = iter.AppendList(functor, outArrayOfNodes);
       NS_ENSURE_SUCCESS(res, res);
     }
     else {
       // We don't want duplicates in outArrayOfNodes, so we use an
       // iterator/functor that only return nodes that are not already in
       // outArrayOfNodes.
       nsCOMArray<nsIDOMNode> nodes;
       nsUniqueFunctor functor(outArrayOfNodes);
       res = iter.AppendList(functor, nodes);
       NS_ENSURE_SUCCESS(res, res);
       if (!outArrayOfNodes.AppendObjects(nodes))
         return NS_ERROR_OUT_OF_MEMORY;
     }
   }
   // certain operations should not act on li's and td's, but rather inside
   // them.  alter the list as needed
   if (inOperationType == EditAction::makeBasicBlock) {
     int32_t listCount = outArrayOfNodes.Count();
     for (i=listCount-1; i>=0; i--)
     {
       nsCOMPtr<nsIDOMNode> node = outArrayOfNodes[i];
       if (nsHTMLEditUtils::IsListItem(node))
       {
         int32_t j=i;
         outArrayOfNodes.RemoveObjectAt(i);
         res = GetInnerContent(node, outArrayOfNodes, &j);
         NS_ENSURE_SUCCESS(res, res);
       }
     }
   }
   // indent/outdent already do something special for list items, but
   // we still need to make sure we don't act on table elements
   else if (inOperationType == EditAction::outdent ||
            inOperationType == EditAction::indent ||
            inOperationType == EditAction::setAbsolutePosition) {
     int32_t listCount = outArrayOfNodes.Count();
     for (i=listCount-1; i>=0; i--)
     {
       nsCOMPtr<nsIDOMNode> node = outArrayOfNodes[i];
       if (nsHTMLEditUtils::IsTableElementButNotTable(node))
       {
         int32_t j=i;
         outArrayOfNodes.RemoveObjectAt(i);
         res = GetInnerContent(node, outArrayOfNodes, &j);
         NS_ENSURE_SUCCESS(res, res);
       }
     }
   }
   // outdent should look inside of divs.
   if (inOperationType == EditAction::outdent &&
       (!mHTMLEditor || !mHTMLEditor->IsCSSEnabled())) {
     NS_ENSURE_STATE(mHTMLEditor);
     int32_t listCount = outArrayOfNodes.Count();
     for (i=listCount-1; i>=0; i--)
     {
       nsCOMPtr<nsIDOMNode> node = outArrayOfNodes[i];
       if (nsHTMLEditUtils::IsDiv(node))
       {
         int32_t j=i;
         outArrayOfNodes.RemoveObjectAt(i);
         res = GetInnerContent(node, outArrayOfNodes, &j, false, false);
         NS_ENSURE_SUCCESS(res, res);
       }
     }
   }
   // post process the list to break up inline containers that contain br's.
   // but only for operations that might care, like making lists or para's...
   if (inOperationType == EditAction::makeBasicBlock ||
       inOperationType == EditAction::makeList ||
       inOperationType == EditAction::align ||
       inOperationType == EditAction::setAbsolutePosition ||
       inOperationType == EditAction::indent ||
       inOperationType == EditAction::outdent) {
     int32_t listCount = outArrayOfNodes.Count();
     for (i=listCount-1; i>=0; i--)
     {
       nsCOMPtr<nsIDOMNode> node = outArrayOfNodes[i];
       if (!aDontTouchContent && IsInlineNode(node) &&
           (!mHTMLEditor || mHTMLEditor->IsContainer(node)) &&
           (!mHTMLEditor || !mHTMLEditor->IsTextNode(node)))
       {
         NS_ENSURE_STATE(mHTMLEditor);
         nsCOMArray<nsIDOMNode> arrayOfInlines;
         res = BustUpInlinesAtBRs(node, arrayOfInlines);
         NS_ENSURE_SUCCESS(res, res);
         // put these nodes in outArrayOfNodes, replacing the current node
         outArrayOfNodes.RemoveObjectAt(i);
         outArrayOfNodes.InsertObjectsAt(arrayOfInlines, i);
       }
     }
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // GetChildNodesForOperation:
 //
 nsresult
 nsHTMLEditRules::GetChildNodesForOperation(nsIDOMNode *inNode,
                                            nsCOMArray<nsIDOMNode>& outArrayOfNodes)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(inNode);
   NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
   for (nsIContent* child = node->GetFirstChild();
        child;
        child = child->GetNextSibling()) {
     nsIDOMNode* childNode = child->AsDOMNode();
     if (!outArrayOfNodes.AppendObject(childNode)) {
       return NS_ERROR_FAILURE;
     }
   }
   return NS_OK;
 }
 ///////////////////////////////////////////////////////////////////////////
 // GetListActionNodes:
 //
 nsresult
 nsHTMLEditRules::GetListActionNodes(nsCOMArray<nsIDOMNode> &outArrayOfNodes,
                                     bool aEntireList,
                                     bool aDontTouchContent)
 {
   nsresult res = NS_OK;
   nsCOMPtr<nsISelection>selection;
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   Selection* sel = static_cast<Selection*>(selection.get());
   NS_ENSURE_TRUE(sel, NS_ERROR_FAILURE);
   // added this in so that ui code can ask to change an entire list, even if selection
   // is only in part of it.  used by list item dialog.
   if (aEntireList)
   {
     uint32_t rangeCount = sel->GetRangeCount();
     for (uint32_t rangeIdx = 0; rangeIdx < rangeCount; ++rangeIdx) {
       nsRefPtr<nsRange> range = sel->GetRangeAt(rangeIdx);
       nsCOMPtr<nsIDOMNode> commonParent, parent, tmp;
       range->GetCommonAncestorContainer(getter_AddRefs(commonParent));
       if (commonParent)
       {
         parent = commonParent;
         while (parent)
         {
           if (nsHTMLEditUtils::IsList(parent))
           {
             outArrayOfNodes.AppendObject(parent);
             break;
           }
           parent->GetParentNode(getter_AddRefs(tmp));
           parent = tmp;
         }
       }
     }
     // if we didn't find any nodes this way, then try the normal way.  perhaps the
     // selection spans multiple lists but with no common list parent.
     if (outArrayOfNodes.Count()) return NS_OK;
   }
   {
     // We don't like other people messing with our selection!
     NS_ENSURE_STATE(mHTMLEditor);
     nsAutoTxnsConserveSelection dontSpazMySelection(mHTMLEditor);
     // contruct a list of nodes to act on.
     res = GetNodesFromSelection(selection, EditAction::makeList,
                                 outArrayOfNodes, aDontTouchContent);
     NS_ENSURE_SUCCESS(res, res);
   }
   // pre process our list of nodes...
   int32_t listCount = outArrayOfNodes.Count();
   int32_t i;
   for (i=listCount-1; i>=0; i--)
   {
     nsCOMPtr<nsIDOMNode> testNode = outArrayOfNodes[i];
     // Remove all non-editable nodes.  Leave them be.
     NS_ENSURE_STATE(mHTMLEditor);
     if (!mHTMLEditor->IsEditable(testNode))
     {
       outArrayOfNodes.RemoveObjectAt(i);
     }
     // scan for table elements and divs.  If we find table elements other than table,
     // replace it with a list of any editable non-table content.
     if (nsHTMLEditUtils::IsTableElementButNotTable(testNode))
     {
       int32_t j=i;
       outArrayOfNodes.RemoveObjectAt(i);
       res = GetInnerContent(testNode, outArrayOfNodes, &j, false);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   // if there is only one node in the array, and it is a list, div, or blockquote,
   // then look inside of it until we find inner list or content.
   res = LookInsideDivBQandList(outArrayOfNodes);
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // LookInsideDivBQandList:
 //
 nsresult
 nsHTMLEditRules::LookInsideDivBQandList(nsCOMArray<nsIDOMNode>& aNodeArray)
 {
   // if there is only one node in the array, and it is a list, div, or blockquote,
   // then look inside of it until we find inner list or content.
   int32_t listCount = aNodeArray.Count();
   if (listCount != 1) {
     return NS_OK;
   }
   nsCOMPtr<nsINode> curNode = do_QueryInterface(aNodeArray[0]);
   NS_ENSURE_STATE(curNode);
   while (curNode->IsElement() &&
          (curNode->AsElement()->IsHTML(nsGkAtoms::div) ||
           nsHTMLEditUtils::IsList(curNode) ||
           curNode->AsElement()->IsHTML(nsGkAtoms::blockquote))) {
     // dive as long as there is only one child, and it is a list, div, blockquote
     NS_ENSURE_STATE(mHTMLEditor);
     uint32_t numChildren = mHTMLEditor->CountEditableChildren(curNode);
     if (numChildren != 1) {
       break;
     }
     // keep diving
     // XXX One would expect to dive into the one editable node.
     nsIContent* tmp = curNode->GetFirstChild();
     if (!tmp->IsElement()) {
       break;
     }
     dom::Element* element = tmp->AsElement();
     if (!element->IsHTML(nsGkAtoms::div) &&
         !nsHTMLEditUtils::IsList(element) &&
         !element->IsHTML(nsGkAtoms::blockquote)) {
       break;
     }
     // check editablility XXX floppy moose
     curNode = tmp;
   }
   // we've found innermost list/blockquote/div:
   // replace the one node in the array with these nodes
   aNodeArray.RemoveObjectAt(0);
   if (curNode->IsElement() &&
       (curNode->AsElement()->IsHTML(nsGkAtoms::div) ||
        curNode->AsElement()->IsHTML(nsGkAtoms::blockquote))) {
     int32_t j = 0;
     return GetInnerContent(curNode->AsDOMNode(), aNodeArray, &j, false, false);
   }
   aNodeArray.AppendObject(curNode->AsDOMNode());
   return NS_OK;
 }
 ///////////////////////////////////////////////////////////////////////////
 // GetDefinitionListItemTypes:
 //
 void
 nsHTMLEditRules::GetDefinitionListItemTypes(dom::Element* aElement, bool* aDT, bool* aDD)
 {
   MOZ_ASSERT(aElement);
   MOZ_ASSERT(aElement->IsHTML(nsGkAtoms::dl));
   MOZ_ASSERT(aDT);
   MOZ_ASSERT(aDD);
   *aDT = *aDD = false;
   for (nsIContent* child = aElement->GetFirstChild();
        child;
        child = child->GetNextSibling()) {
     if (child->IsHTML(nsGkAtoms::dt)) {
       *aDT = true;
     } else if (child->IsHTML(nsGkAtoms::dd)) {
       *aDD = true;
     }
   }
 }
 ///////////////////////////////////////////////////////////////////////////
 // GetParagraphFormatNodes:
 //
 nsresult
 nsHTMLEditRules::GetParagraphFormatNodes(nsCOMArray<nsIDOMNode>& outArrayOfNodes,
                                          bool aDontTouchContent)
 {
   nsCOMPtr<nsISelection>selection;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res = mHTMLEditor->GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   // contruct a list of nodes to act on.
   res = GetNodesFromSelection(selection, EditAction::makeBasicBlock,
                               outArrayOfNodes, aDontTouchContent);
   NS_ENSURE_SUCCESS(res, res);
   // pre process our list of nodes...
   int32_t listCount = outArrayOfNodes.Count();
   int32_t i;
   for (i=listCount-1; i>=0; i--)
   {
     nsCOMPtr<nsIDOMNode> testNode = outArrayOfNodes[i];
     // Remove all non-editable nodes.  Leave them be.
     NS_ENSURE_STATE(mHTMLEditor);
     if (!mHTMLEditor->IsEditable(testNode))
     {
       outArrayOfNodes.RemoveObjectAt(i);
     }
     // scan for table elements.  If we find table elements other than table,
     // replace it with a list of any editable non-table content.  Ditto for list elements.
     if (nsHTMLEditUtils::IsTableElement(testNode) ||
         nsHTMLEditUtils::IsList(testNode) ||
         nsHTMLEditUtils::IsListItem(testNode) )
     {
       int32_t j=i;
       outArrayOfNodes.RemoveObjectAt(i);
       res = GetInnerContent(testNode, outArrayOfNodes, &j);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // BustUpInlinesAtRangeEndpoints:
 //
 nsresult
 nsHTMLEditRules::BustUpInlinesAtRangeEndpoints(nsRangeStore &item)
 {
   nsresult res = NS_OK;
   bool isCollapsed = ((item.startNode == item.endNode) && (item.startOffset == item.endOffset));
   nsCOMPtr<nsIDOMNode> endInline = GetHighestInlineParent(item.endNode);
   // if we have inline parents above range endpoints, split them
   if (endInline && !isCollapsed)
   {
     nsCOMPtr<nsIDOMNode> resultEndNode;
     int32_t resultEndOffset;
     endInline->GetParentNode(getter_AddRefs(resultEndNode));
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->SplitNodeDeep(endInline, item.endNode, item.endOffset,
                           &resultEndOffset, true);
     NS_ENSURE_SUCCESS(res, res);
     // reset range
     item.endNode = resultEndNode; item.endOffset = resultEndOffset;
   }
   nsCOMPtr<nsIDOMNode> startInline = GetHighestInlineParent(item.startNode);
   if (startInline)
   {
     nsCOMPtr<nsIDOMNode> resultStartNode;
     int32_t resultStartOffset;
     startInline->GetParentNode(getter_AddRefs(resultStartNode));
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->SplitNodeDeep(startInline, item.startNode, item.startOffset,
                           &resultStartOffset, true);
     NS_ENSURE_SUCCESS(res, res);
     // reset range
     item.startNode = resultStartNode; item.startOffset = resultStartOffset;
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // BustUpInlinesAtBRs:
 //
 nsresult
 nsHTMLEditRules::BustUpInlinesAtBRs(nsIDOMNode *inNode,
                                     nsCOMArray<nsIDOMNode>& outArrayOfNodes)
 {
   NS_ENSURE_TRUE(inNode, NS_ERROR_NULL_POINTER);
   // first step is to build up a list of all the break nodes inside
   // the inline container.
   nsCOMArray<nsIDOMNode> arrayOfBreaks;
   nsBRNodeFunctor functor;
   nsDOMIterator iter;
   nsresult res = iter.Init(inNode);
   NS_ENSURE_SUCCESS(res, res);
   res = iter.AppendList(functor, arrayOfBreaks);
   NS_ENSURE_SUCCESS(res, res);
   // if there aren't any breaks, just put inNode itself in the array
   int32_t listCount = arrayOfBreaks.Count();
   if (!listCount)
   {
     if (!outArrayOfNodes.AppendObject(inNode))
       return NS_ERROR_FAILURE;
   }
   else
   {
     // else we need to bust up inNode along all the breaks
     nsCOMPtr<nsIDOMNode> breakNode;
     nsCOMPtr<nsIDOMNode> inlineParentNode;
     nsCOMPtr<nsIDOMNode> leftNode;
     nsCOMPtr<nsIDOMNode> rightNode;
     nsCOMPtr<nsIDOMNode> splitDeepNode = inNode;
     nsCOMPtr<nsIDOMNode> splitParentNode;
     int32_t splitOffset, resultOffset, i;
     inNode->GetParentNode(getter_AddRefs(inlineParentNode));
     for (i=0; i< listCount; i++)
     {
       breakNode = arrayOfBreaks[i];
       NS_ENSURE_TRUE(breakNode, NS_ERROR_NULL_POINTER);
       NS_ENSURE_TRUE(splitDeepNode, NS_ERROR_NULL_POINTER);
       splitParentNode = nsEditor::GetNodeLocation(breakNode, &splitOffset);
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->SplitNodeDeep(splitDeepNode, splitParentNode, splitOffset,
                           &resultOffset, false, address_of(leftNode), address_of(rightNode));
       NS_ENSURE_SUCCESS(res, res);
       // put left node in node list
       if (leftNode)
       {
         // might not be a left node.  a break might have been at the very
         // beginning of inline container, in which case splitnodedeep
         // would not actually split anything
         if (!outArrayOfNodes.AppendObject(leftNode))
           return NS_ERROR_FAILURE;
       }
       // move break outside of container and also put in node list
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->MoveNode(breakNode, inlineParentNode, resultOffset);
       NS_ENSURE_SUCCESS(res, res);
       if (!outArrayOfNodes.AppendObject(breakNode))
         return  NS_ERROR_FAILURE;
       // now rightNode becomes the new node to split
       splitDeepNode = rightNode;
     }
     // now tack on remaining rightNode, if any, to the list
     if (rightNode)
     {
       if (!outArrayOfNodes.AppendObject(rightNode))
         return NS_ERROR_FAILURE;
     }
   }
   return res;
 }
 nsCOMPtr<nsIDOMNode>
 nsHTMLEditRules::GetHighestInlineParent(nsIDOMNode* aNode)
 {
   NS_ENSURE_TRUE(aNode, nullptr);
   if (IsBlockNode(aNode)) return nullptr;
   nsCOMPtr<nsIDOMNode> inlineNode, node=aNode;
   while (node && IsInlineNode(node))
   {
     inlineNode = node;
     inlineNode->GetParentNode(getter_AddRefs(node));
   }
   return inlineNode;
 }
 ///////////////////////////////////////////////////////////////////////////
 // GetNodesFromPoint: given a particular operation, construct a list
 //                     of nodes from a point that will be operated on.
 //
 nsresult
 nsHTMLEditRules::GetNodesFromPoint(::DOMPoint point,
                                    EditAction operation,
                                    nsCOMArray<nsIDOMNode> &arrayOfNodes,
                                    bool dontTouchContent)
 {
   nsresult res;
   // get our point
   nsCOMPtr<nsIDOMNode> node;
   int32_t offset;
   point.GetPoint(node, offset);
   // use it to make a range
   nsCOMPtr<nsINode> nativeNode = do_QueryInterface(node);
   NS_ENSURE_STATE(nativeNode);
   nsRefPtr<nsRange> range = new nsRange(nativeNode);
   res = range->SetStart(node, offset);
   NS_ENSURE_SUCCESS(res, res);
   /* SetStart() will also set the end for this new range
   res = range->SetEnd(node, offset);
   NS_ENSURE_SUCCESS(res, res); */
   // expand the range to include adjacent inlines
   res = PromoteRange(range, operation);
   NS_ENSURE_SUCCESS(res, res);
   // make array of ranges
   nsCOMArray<nsIDOMRange> arrayOfRanges;
   // stuff new opRange into array
   arrayOfRanges.AppendObject(range);
   // use these ranges to contruct a list of nodes to act on.
   res = GetNodesForOperation(arrayOfRanges, arrayOfNodes, operation, dontTouchContent);
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // GetNodesFromSelection: given a particular operation, construct a list
 //                     of nodes from the selection that will be operated on.
 //
 nsresult
 nsHTMLEditRules::GetNodesFromSelection(nsISelection *selection,
                                        EditAction operation,
                                        nsCOMArray<nsIDOMNode>& arrayOfNodes,
                                        bool dontTouchContent)
 {
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
   nsresult res;
   // promote selection ranges
   nsCOMArray<nsIDOMRange> arrayOfRanges;
   res = GetPromotedRanges(selection, arrayOfRanges, operation);
   NS_ENSURE_SUCCESS(res, res);
   // use these ranges to contruct a list of nodes to act on.
   res = GetNodesForOperation(arrayOfRanges, arrayOfNodes, operation, dontTouchContent);
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // MakeTransitionList: detect all the transitions in the array, where a
 //                     transition means that adjacent nodes in the array
 //                     don't have the same parent.
 //
 nsresult
 nsHTMLEditRules::MakeTransitionList(nsCOMArray<nsIDOMNode>& inArrayOfNodes,
                                     nsTArray<bool> &inTransitionArray)
 {
   uint32_t listCount = inArrayOfNodes.Count();
   inTransitionArray.EnsureLengthAtLeast(listCount);
   uint32_t i;
   nsCOMPtr<nsIDOMNode> prevElementParent;
   nsCOMPtr<nsIDOMNode> curElementParent;
   for (i=0; i<listCount; i++)
   {
     nsIDOMNode* transNode = inArrayOfNodes[i];
     transNode->GetParentNode(getter_AddRefs(curElementParent));
     if (curElementParent != prevElementParent)
     {
       // different parents, or separated by <br>: transition point
       inTransitionArray[i] = true;
     }
     else
     {
       // same parents: these nodes grew up together
       inTransitionArray[i] = false;
     }
     prevElementParent = curElementParent;
   }
   return NS_OK;
 }
 /********************************************************
  *  main implementation methods
  ********************************************************/
 ///////////////////////////////////////////////////////////////////////////
 // IsInListItem: if aNode is the descendant of a listitem, return that li.
 //               But table element boundaries are stoppers on the search.
 //               Also stops on the active editor host (contenteditable).
 //               Also test if aNode is an li itself.
 //
 already_AddRefed<nsIDOMNode>
 nsHTMLEditRules::IsInListItem(nsIDOMNode* aNode)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   nsCOMPtr<nsIDOMNode> retval = do_QueryInterface(IsInListItem(node));
   return retval.forget();
 }
 nsINode*
 nsHTMLEditRules::IsInListItem(nsINode* aNode)
 {
   NS_ENSURE_TRUE(aNode, nullptr);
   if (nsHTMLEditUtils::IsListItem(aNode)) {
     return aNode;
   }
   nsINode* parent = aNode->GetParentNode();
   while (parent && mHTMLEditor && mHTMLEditor->IsDescendantOfEditorRoot(parent) &&
          !nsHTMLEditUtils::IsTableElement(parent)) {
     if (nsHTMLEditUtils::IsListItem(parent)) {
       return parent;
     }
     parent = parent->GetParentNode();
   }
   return nullptr;
 }
 ///////////////////////////////////////////////////////////////////////////
 // ReturnInHeader: do the right thing for returns pressed in headers
 //
 nsresult
 nsHTMLEditRules::ReturnInHeader(nsISelection *aSelection,
                                 nsIDOMNode *aHeader,
                                 nsIDOMNode *aNode,
                                 int32_t aOffset)
 {
   NS_ENSURE_TRUE(aSelection && aHeader && aNode, NS_ERROR_NULL_POINTER);
   // remeber where the header is
   int32_t offset;
   nsCOMPtr<nsIDOMNode> headerParent = nsEditor::GetNodeLocation(aHeader, &offset);
   // get ws code to adjust any ws
   nsCOMPtr<nsIDOMNode> selNode = aNode;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res = nsWSRunObject::PrepareToSplitAcrossBlocks(mHTMLEditor,
                                                            address_of(selNode),
                                                            &aOffset);
   NS_ENSURE_SUCCESS(res, res);
   // split the header
   int32_t newOffset;
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->SplitNodeDeep( aHeader, selNode, aOffset, &newOffset);
   NS_ENSURE_SUCCESS(res, res);
   // if the leftand heading is empty, put a mozbr in it
   nsCOMPtr<nsIDOMNode> prevItem;
   NS_ENSURE_STATE(mHTMLEditor);
   mHTMLEditor->GetPriorHTMLSibling(aHeader, address_of(prevItem));
   if (prevItem && nsHTMLEditUtils::IsHeader(prevItem))
   {
     bool bIsEmptyNode;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->IsEmptyNode(prevItem, &bIsEmptyNode);
     NS_ENSURE_SUCCESS(res, res);
     if (bIsEmptyNode) {
       res = CreateMozBR(prevItem, 0);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   // if the new (righthand) header node is empty, delete it
   bool isEmpty;
   res = IsEmptyBlock(aHeader, &isEmpty, true);
   NS_ENSURE_SUCCESS(res, res);
   if (isEmpty)
   {
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->DeleteNode(aHeader);
     NS_ENSURE_SUCCESS(res, res);
     // layout tells the caret to blink in a weird place
     // if we don't place a break after the header.
     nsCOMPtr<nsIDOMNode> sibling;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetNextHTMLSibling(headerParent, offset+1, address_of(sibling));
     NS_ENSURE_SUCCESS(res, res);
     if (!sibling || !nsTextEditUtils::IsBreak(sibling))
     {
       ClearCachedStyles();
       NS_ENSURE_STATE(mHTMLEditor);
       mHTMLEditor->mTypeInState->ClearAllProps();
       // create a paragraph
       NS_NAMED_LITERAL_STRING(pType, "p");
       nsCOMPtr<nsIDOMNode> pNode;
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->CreateNode(pType, headerParent, offset+1, getter_AddRefs(pNode));
       NS_ENSURE_SUCCESS(res, res);
       // append a <br> to it
       nsCOMPtr<nsIDOMNode> brNode;
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->CreateBR(pNode, 0, address_of(brNode));
       NS_ENSURE_SUCCESS(res, res);
       // set selection to before the break
       res = aSelection->Collapse(pNode, 0);
     }
     else
     {
       headerParent = nsEditor::GetNodeLocation(sibling, &offset);
       // put selection after break
       res = aSelection->Collapse(headerParent,offset+1);
     }
   }
   else
   {
     // put selection at front of righthand heading
     res = aSelection->Collapse(aHeader,0);
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // ReturnInParagraph: do the right thing for returns pressed in paragraphs
 //
 nsresult
 nsHTMLEditRules::ReturnInParagraph(nsISelection* aSelection,
                                    nsIDOMNode* aPara,
                                    nsIDOMNode* aNode,
                                    int32_t aOffset,
                                    bool* aCancel,
                                    bool* aHandled)
 {
   if (!aSelection || !aPara || !aNode || !aCancel || !aHandled) {
     return NS_ERROR_NULL_POINTER;
   }
   *aCancel = false;
   *aHandled = false;
   nsresult res;
   int32_t offset;
   nsCOMPtr<nsIDOMNode> parent = nsEditor::GetNodeLocation(aNode, &offset);
   NS_ENSURE_STATE(mHTMLEditor);
   bool doesCRCreateNewP = mHTMLEditor->GetReturnInParagraphCreatesNewParagraph();
   bool newBRneeded = false;
   nsCOMPtr<nsIDOMNode> sibling;
   NS_ENSURE_STATE(mHTMLEditor);
   if (aNode == aPara && doesCRCreateNewP) {
     // we are at the edges of the block, newBRneeded not needed!
     sibling = aNode;
   } else if (mHTMLEditor->IsTextNode(aNode)) {
     nsCOMPtr<nsIDOMText> textNode = do_QueryInterface(aNode);
     uint32_t strLength;
     res = textNode->GetLength(&strLength);
     NS_ENSURE_SUCCESS(res, res);
     // at beginning of text node?
     if (!aOffset) {
       // is there a BR prior to it?
       NS_ENSURE_STATE(mHTMLEditor);
       mHTMLEditor->GetPriorHTMLSibling(aNode, address_of(sibling));
       if (!sibling || !mHTMLEditor || !mHTMLEditor->IsVisBreak(sibling) ||
           nsTextEditUtils::HasMozAttr(sibling)) {
         NS_ENSURE_STATE(mHTMLEditor);
         newBRneeded = true;
       }
     } else if (aOffset == (int32_t)strLength) {
       // we're at the end of text node...
       // is there a BR after to it?
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->GetNextHTMLSibling(aNode, address_of(sibling));
       if (!sibling || !mHTMLEditor || !mHTMLEditor->IsVisBreak(sibling) ||
           nsTextEditUtils::HasMozAttr(sibling)) {
         NS_ENSURE_STATE(mHTMLEditor);
         newBRneeded = true;
         offset++;
       }
     } else {
       if (doesCRCreateNewP) {
         nsCOMPtr<nsIDOMNode> tmp;
         res = mEditor->SplitNode(aNode, aOffset, getter_AddRefs(tmp));
         NS_ENSURE_SUCCESS(res, res);
         aNode = tmp;
       }
       newBRneeded = true;
       offset++;
     }
   } else {
     // not in a text node.
     // is there a BR prior to it?
     nsCOMPtr<nsIDOMNode> nearNode, selNode = aNode;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetPriorHTMLNode(aNode, aOffset, address_of(nearNode));
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_STATE(mHTMLEditor);
     if (!nearNode || !mHTMLEditor->IsVisBreak(nearNode) ||
         nsTextEditUtils::HasMozAttr(nearNode)) {
       // is there a BR after it?
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->GetNextHTMLNode(aNode, aOffset, address_of(nearNode));
       NS_ENSURE_SUCCESS(res, res);
       NS_ENSURE_STATE(mHTMLEditor);
       if (!nearNode || !mHTMLEditor->IsVisBreak(nearNode) ||
           nsTextEditUtils::HasMozAttr(nearNode)) {
         newBRneeded = true;
       }
     }
     if (!newBRneeded) {
       sibling = nearNode;
     }
   }
   if (newBRneeded) {
     // if CR does not create a new P, default to BR creation
     NS_ENSURE_TRUE(doesCRCreateNewP, NS_OK);
     nsCOMPtr<nsIDOMNode> brNode;
     NS_ENSURE_STATE(mHTMLEditor);
     res =  mHTMLEditor->CreateBR(parent, offset, address_of(brNode));
     sibling = brNode;
   }
   nsCOMPtr<nsIDOMNode> selNode = aNode;
   *aHandled = true;
   return SplitParagraph(aPara, sibling, aSelection, address_of(selNode), &aOffset);
 }
 ///////////////////////////////////////////////////////////////////////////
 // SplitParagraph: split a paragraph at selection point, possibly deleting a br
 //
 nsresult
 nsHTMLEditRules::SplitParagraph(nsIDOMNode *aPara,
                                 nsIDOMNode *aBRNode,
                                 nsISelection *aSelection,
                                 nsCOMPtr<nsIDOMNode> *aSelNode,
                                 int32_t *aOffset)
 {
   NS_ENSURE_TRUE(aPara && aBRNode && aSelNode && *aSelNode && aOffset && aSelection, NS_ERROR_NULL_POINTER);
   nsresult res = NS_OK;
   // split para
   int32_t newOffset;
   // get ws code to adjust any ws
   nsCOMPtr<nsIDOMNode> leftPara, rightPara;
   NS_ENSURE_STATE(mHTMLEditor);
   res = nsWSRunObject::PrepareToSplitAcrossBlocks(mHTMLEditor, aSelNode, aOffset);
   NS_ENSURE_SUCCESS(res, res);
   // split the paragraph
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->SplitNodeDeep(aPara, *aSelNode, *aOffset, &newOffset, false,
                                    address_of(leftPara), address_of(rightPara));
   NS_ENSURE_SUCCESS(res, res);
   // get rid of the break, if it is visible (otherwise it may be needed to prevent an empty p)
   NS_ENSURE_STATE(mHTMLEditor);
   if (mHTMLEditor->IsVisBreak(aBRNode))
   {
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->DeleteNode(aBRNode);
     NS_ENSURE_SUCCESS(res, res);
   }
   // remove ID attribute on the paragraph we just created
   nsCOMPtr<nsIDOMElement> rightElt = do_QueryInterface(rightPara);
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->RemoveAttribute(rightElt, NS_LITERAL_STRING("id"));
   NS_ENSURE_SUCCESS(res, res);
   // check both halves of para to see if we need mozBR
   res = InsertMozBRIfNeeded(leftPara);
   NS_ENSURE_SUCCESS(res, res);
   res = InsertMozBRIfNeeded(rightPara);
   NS_ENSURE_SUCCESS(res, res);
   // selection to beginning of right hand para;
   // look inside any containers that are up front.
   NS_ENSURE_STATE(mHTMLEditor);
   nsCOMPtr<nsIDOMNode> child = mHTMLEditor->GetLeftmostChild(rightPara, true);
   NS_ENSURE_STATE(mHTMLEditor);
   if (mHTMLEditor->IsTextNode(child) || !mHTMLEditor ||
       mHTMLEditor->IsContainer(child))
   {
     NS_ENSURE_STATE(mHTMLEditor);
     aSelection->Collapse(child,0);
   }
   else
   {
     int32_t offset;
     nsCOMPtr<nsIDOMNode> parent = nsEditor::GetNodeLocation(child, &offset);
     aSelection->Collapse(parent,offset);
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // ReturnInListItem: do the right thing for returns pressed in list items
 //
 nsresult
 nsHTMLEditRules::ReturnInListItem(nsISelection *aSelection,
                                   nsIDOMNode *aListItem,
                                   nsIDOMNode *aNode,
                                   int32_t aOffset)
 {
   NS_ENSURE_TRUE(aSelection && aListItem && aNode, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsISelection> selection(aSelection);
   nsCOMPtr<nsISelectionPrivate> selPriv(do_QueryInterface(selection));
   nsresult res = NS_OK;
   nsCOMPtr<nsIDOMNode> listitem;
   // sanity check
   NS_PRECONDITION(true == nsHTMLEditUtils::IsListItem(aListItem),
                   "expected a list item and didn't get one");
   // get the listitem parent and the active editing host.
   NS_ENSURE_STATE(mHTMLEditor);
   nsIContent* rootContent = mHTMLEditor->GetActiveEditingHost();
   nsCOMPtr<nsIDOMNode> rootNode = do_QueryInterface(rootContent);
   int32_t itemOffset;
   nsCOMPtr<nsIDOMNode> list = nsEditor::GetNodeLocation(aListItem, &itemOffset);
   // if we are in an empty listitem, then we want to pop up out of the list
   // but only if prefs says it's ok and if the parent isn't the active editing host.
   bool isEmpty;
   res = IsEmptyBlock(aListItem, &isEmpty, true, false);
   NS_ENSURE_SUCCESS(res, res);
   if (isEmpty && (rootNode != list) && mReturnInEmptyLIKillsList)
   {
     // get the list offset now -- before we might eventually split the list
     int32_t offset;
     nsCOMPtr<nsIDOMNode> listparent = nsEditor::GetNodeLocation(list, &offset);
     // are we the last list item in the list?
     bool bIsLast;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->IsLastEditableChild(aListItem, &bIsLast);
     NS_ENSURE_SUCCESS(res, res);
     if (!bIsLast)
     {
       // we need to split the list!
       nsCOMPtr<nsIDOMNode> tempNode;
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->SplitNode(list, itemOffset, getter_AddRefs(tempNode));
       NS_ENSURE_SUCCESS(res, res);
     }
     // are we in a sublist?
     if (nsHTMLEditUtils::IsList(listparent))  //in a sublist
     {
       // if so, move this list item out of this list and into the grandparent list
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->MoveNode(aListItem,listparent,offset+1);
       NS_ENSURE_SUCCESS(res, res);
       res = aSelection->Collapse(aListItem,0);
     }
     else
     {
       // otherwise kill this listitem
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->DeleteNode(aListItem);
       NS_ENSURE_SUCCESS(res, res);
       // time to insert a paragraph
       NS_NAMED_LITERAL_STRING(pType, "p");
       nsCOMPtr<nsIDOMNode> pNode;
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->CreateNode(pType, listparent, offset+1, getter_AddRefs(pNode));
       NS_ENSURE_SUCCESS(res, res);
       // append a <br> to it
       nsCOMPtr<nsIDOMNode> brNode;
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->CreateBR(pNode, 0, address_of(brNode));
       NS_ENSURE_SUCCESS(res, res);
       // set selection to before the break
       res = aSelection->Collapse(pNode, 0);
     }
     return res;
   }
   // else we want a new list item at the same list level.
   // get ws code to adjust any ws
   nsCOMPtr<nsIDOMNode> selNode = aNode;
   NS_ENSURE_STATE(mHTMLEditor);
   res = nsWSRunObject::PrepareToSplitAcrossBlocks(mHTMLEditor, address_of(selNode), &aOffset);
   NS_ENSURE_SUCCESS(res, res);
   // now split list item
   int32_t newOffset;
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->SplitNodeDeep( aListItem, selNode, aOffset, &newOffset, false);
   NS_ENSURE_SUCCESS(res, res);
   // hack: until I can change the damaged doc range code back to being
   // extra inclusive, I have to manually detect certain list items that
   // may be left empty.
   nsCOMPtr<nsIDOMNode> prevItem;
   NS_ENSURE_STATE(mHTMLEditor);
   mHTMLEditor->GetPriorHTMLSibling(aListItem, address_of(prevItem));
   if (prevItem && nsHTMLEditUtils::IsListItem(prevItem))
   {
     bool bIsEmptyNode;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->IsEmptyNode(prevItem, &bIsEmptyNode);
     NS_ENSURE_SUCCESS(res, res);
     if (bIsEmptyNode) {
       res = CreateMozBR(prevItem, 0);
       NS_ENSURE_SUCCESS(res, res);
     } else {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->IsEmptyNode(aListItem, &bIsEmptyNode, true);
       NS_ENSURE_SUCCESS(res, res);
       if (bIsEmptyNode)
       {
         nsCOMPtr<nsIAtom> nodeAtom = nsEditor::GetTag(aListItem);
         if (nodeAtom == nsEditProperty::dd || nodeAtom == nsEditProperty::dt)
         {
           int32_t itemOffset;
           nsCOMPtr<nsIDOMNode> list = nsEditor::GetNodeLocation(aListItem, &itemOffset);
           nsAutoString listTag((nodeAtom == nsEditProperty::dt) ? NS_LITERAL_STRING("dd") : NS_LITERAL_STRING("dt"));
           nsCOMPtr<nsIDOMNode> newListItem;
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->CreateNode(listTag, list, itemOffset+1, getter_AddRefs(newListItem));
           NS_ENSURE_SUCCESS(res, res);
           res = mEditor->DeleteNode(aListItem);
           NS_ENSURE_SUCCESS(res, res);
           return aSelection->Collapse(newListItem, 0);
         }
         nsCOMPtr<nsIDOMNode> brNode;
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->CopyLastEditableChildStyles(prevItem, aListItem, getter_AddRefs(brNode));
         NS_ENSURE_SUCCESS(res, res);
         if (brNode)
         {
           int32_t offset;
           nsCOMPtr<nsIDOMNode> brParent = nsEditor::GetNodeLocation(brNode, &offset);
           return aSelection->Collapse(brParent, offset);
         }
       }
       else
       {
         NS_ENSURE_STATE(mHTMLEditor);
         nsWSRunObject wsObj(mHTMLEditor, aListItem, 0);
         nsCOMPtr<nsIDOMNode> visNode;
         int32_t visOffset = 0;
         WSType wsType;
         wsObj.NextVisibleNode(aListItem, 0, address_of(visNode),
                               &visOffset, &wsType);
         if (wsType == WSType::special || wsType == WSType::br ||
             nsHTMLEditUtils::IsHR(visNode)) {
           int32_t offset;
           nsCOMPtr<nsIDOMNode> parent = nsEditor::GetNodeLocation(visNode, &offset);
           return aSelection->Collapse(parent, offset);
         }
         else
         {
           return aSelection->Collapse(visNode, visOffset);
         }
       }
     }
   }
   res = aSelection->Collapse(aListItem,0);
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // MakeBlockquote:  put the list of nodes into one or more blockquotes.
 //
 nsresult
 nsHTMLEditRules::MakeBlockquote(nsCOMArray<nsIDOMNode>& arrayOfNodes)
 {
   // the idea here is to put the nodes into a minimal number of
   // blockquotes.  When the user blockquotes something, they expect
   // one blockquote.  That may not be possible (for instance, if they
   // have two table cells selected, you need two blockquotes inside the cells).
   nsresult res = NS_OK;
   nsCOMPtr<nsIDOMNode> curNode, curParent, curBlock, newBlock;
   int32_t offset;
   int32_t listCount = arrayOfNodes.Count();
   nsCOMPtr<nsIDOMNode> prevParent;
   int32_t i;
   for (i=0; i<listCount; i++)
   {
     // get the node to act on, and its location
     curNode = arrayOfNodes[i];
     curParent = nsEditor::GetNodeLocation(curNode, &offset);
     // if the node is a table element or list item, dive inside
     if (nsHTMLEditUtils::IsTableElementButNotTable(curNode) ||
         nsHTMLEditUtils::IsListItem(curNode))
     {
       curBlock = 0;  // forget any previous block
       // recursion time
       nsCOMArray<nsIDOMNode> childArray;
       res = GetChildNodesForOperation(curNode, childArray);
       NS_ENSURE_SUCCESS(res, res);
       res = MakeBlockquote(childArray);
       NS_ENSURE_SUCCESS(res, res);
     }
     // if the node has different parent than previous node,
     // further nodes in a new parent
     if (prevParent)
     {
       nsCOMPtr<nsIDOMNode> temp;
       curNode->GetParentNode(getter_AddRefs(temp));
       if (temp != prevParent)
       {
         curBlock = 0;  // forget any previous blockquote node we were using
         prevParent = temp;
       }
     }
     else
     {
       curNode->GetParentNode(getter_AddRefs(prevParent));
     }
     // if no curBlock, make one
     if (!curBlock)
     {
       NS_NAMED_LITERAL_STRING(quoteType, "blockquote");
       res = SplitAsNeeded(&quoteType, address_of(curParent), &offset);
       NS_ENSURE_SUCCESS(res, res);
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->CreateNode(quoteType, curParent, offset, getter_AddRefs(curBlock));
       NS_ENSURE_SUCCESS(res, res);
       // remember our new block for postprocessing
       mNewBlock = curBlock;
       // note: doesn't matter if we set mNewBlock multiple times.
     }
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->MoveNode(curNode, curBlock, -1);
     NS_ENSURE_SUCCESS(res, res);
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // RemoveBlockStyle:  make the nodes have no special block type.
 //
 nsresult
 nsHTMLEditRules::RemoveBlockStyle(nsCOMArray<nsIDOMNode>& arrayOfNodes)
 {
   // intent of this routine is to be used for converting to/from
   // headers, paragraphs, pre, and address.  Those blocks
   // that pretty much just contain inline things...
   nsresult res = NS_OK;
   nsCOMPtr<nsIDOMNode> curBlock, firstNode, lastNode;
   int32_t listCount = arrayOfNodes.Count();
   for (int32_t i = 0; i < listCount; ++i) {
     // get the node to act on, and its location
     nsCOMPtr<nsIDOMNode> curNode = arrayOfNodes[i];
     nsCOMPtr<dom::Element> curElement = do_QueryInterface(curNode);
     // if curNode is a address, p, header, address, or pre, remove it
     if (curElement && nsHTMLEditUtils::IsFormatNode(curElement)) {
       // process any partial progress saved
       if (curBlock)
       {
         res = RemovePartOfBlock(curBlock, firstNode, lastNode);
         NS_ENSURE_SUCCESS(res, res);
         curBlock = 0;  firstNode = 0;  lastNode = 0;
       }
       // remove curent block
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->RemoveBlockContainer(curNode);
       NS_ENSURE_SUCCESS(res, res);
     } else if (curElement &&
                (curElement->IsHTML(nsGkAtoms::table)      ||
                 curElement->IsHTML(nsGkAtoms::tr)         ||
                 curElement->IsHTML(nsGkAtoms::tbody)      ||
                 curElement->IsHTML(nsGkAtoms::td)         ||
                 nsHTMLEditUtils::IsList(curElement)       ||
                 curElement->IsHTML(nsGkAtoms::li)         ||
                 curElement->IsHTML(nsGkAtoms::blockquote) ||
                 curElement->IsHTML(nsGkAtoms::div))) {
       // process any partial progress saved
       if (curBlock)
       {
         res = RemovePartOfBlock(curBlock, firstNode, lastNode);
         NS_ENSURE_SUCCESS(res, res);
         curBlock = 0;  firstNode = 0;  lastNode = 0;
       }
       // recursion time
       nsCOMArray<nsIDOMNode> childArray;
       res = GetChildNodesForOperation(curNode, childArray);
       NS_ENSURE_SUCCESS(res, res);
       res = RemoveBlockStyle(childArray);
       NS_ENSURE_SUCCESS(res, res);
     }
     else if (IsInlineNode(curNode))
     {
       if (curBlock)
       {
         // if so, is this node a descendant?
         if (nsEditorUtils::IsDescendantOf(curNode, curBlock))
         {
           lastNode = curNode;
           continue;  // then we don't need to do anything different for this node
         }
         else
         {
           // otherwise, we have progressed beyond end of curBlock,
           // so lets handle it now.  We need to remove the portion of
           // curBlock that contains [firstNode - lastNode].
           res = RemovePartOfBlock(curBlock, firstNode, lastNode);
           NS_ENSURE_SUCCESS(res, res);
           curBlock = 0;  firstNode = 0;  lastNode = 0;
           // fall out and handle curNode
         }
       }
       NS_ENSURE_STATE(mHTMLEditor);
       curBlock = mHTMLEditor->GetBlockNodeParent(curNode);
       if (nsHTMLEditUtils::IsFormatNode(curBlock))
       {
         firstNode = curNode;
         lastNode = curNode;
       }
       else
         curBlock = 0;  // not a block kind that we care about.
     }
     else
     { // some node that is already sans block style.  skip over it and
       // process any partial progress saved
       if (curBlock)
       {
         res = RemovePartOfBlock(curBlock, firstNode, lastNode);
         NS_ENSURE_SUCCESS(res, res);
         curBlock = 0;  firstNode = 0;  lastNode = 0;
       }
     }
   }
   // process any partial progress saved
   if (curBlock)
   {
     res = RemovePartOfBlock(curBlock, firstNode, lastNode);
     NS_ENSURE_SUCCESS(res, res);
     curBlock = 0;  firstNode = 0;  lastNode = 0;
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // ApplyBlockStyle:  do whatever it takes to make the list of nodes into
 //                   one or more blocks of type blockTag.
 //
 nsresult
 nsHTMLEditRules::ApplyBlockStyle(nsCOMArray<nsIDOMNode>& arrayOfNodes, const nsAString *aBlockTag)
 {
   // intent of this routine is to be used for converting to/from
   // headers, paragraphs, pre, and address.  Those blocks
   // that pretty much just contain inline things...
   NS_ENSURE_TRUE(aBlockTag, NS_ERROR_NULL_POINTER);
   nsresult res = NS_OK;
   nsCOMPtr<nsIDOMNode> curNode, curParent, curBlock, newBlock;
   int32_t offset;
   int32_t listCount = arrayOfNodes.Count();
   nsString tString(*aBlockTag);////MJUDGE SCC NEED HELP
   // Remove all non-editable nodes.  Leave them be.
   int32_t j;
   for (j=listCount-1; j>=0; j--)
   {
     NS_ENSURE_STATE(mHTMLEditor);
     if (!mHTMLEditor->IsEditable(arrayOfNodes[j]))
     {
       arrayOfNodes.RemoveObjectAt(j);
     }
   }
   // reset list count
   listCount = arrayOfNodes.Count();
   int32_t i;
   for (i=0; i<listCount; i++)
   {
     // get the node to act on, and its location
     curNode = arrayOfNodes[i];
     curParent = nsEditor::GetNodeLocation(curNode, &offset);
     nsAutoString curNodeTag;
     nsEditor::GetTagString(curNode, curNodeTag);
     ToLowerCase(curNodeTag);
     // is it already the right kind of block?
     if (curNodeTag == *aBlockTag)
     {
       curBlock = 0;  // forget any previous block used for previous inline nodes
       continue;  // do nothing to this block
     }
     // if curNode is a address, p, header, address, or pre, replace
     // it with a new block of correct type.
     // xxx floppy moose: pre can't hold everything the others can
     if (nsHTMLEditUtils::IsMozDiv(curNode)     ||
         nsHTMLEditUtils::IsFormatNode(curNode))
     {
       curBlock = 0;  // forget any previous block used for previous inline nodes
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->ReplaceContainer(curNode, address_of(newBlock), *aBlockTag,
                                           nullptr, nullptr, true);
       NS_ENSURE_SUCCESS(res, res);
     }
     else if (nsHTMLEditUtils::IsTable(curNode)                    ||
              (curNodeTag.EqualsLiteral("tbody"))      ||
              (curNodeTag.EqualsLiteral("tr"))         ||
              (curNodeTag.EqualsLiteral("td"))         ||
              nsHTMLEditUtils::IsList(curNode)                     ||
              (curNodeTag.EqualsLiteral("li"))         ||
              nsHTMLEditUtils::IsBlockquote(curNode)               ||
              nsHTMLEditUtils::IsDiv(curNode))
     {
       curBlock = 0;  // forget any previous block used for previous inline nodes
       // recursion time
       nsCOMArray<nsIDOMNode> childArray;
       res = GetChildNodesForOperation(curNode, childArray);
       NS_ENSURE_SUCCESS(res, res);
       int32_t childCount = childArray.Count();
       if (childCount)
       {
         res = ApplyBlockStyle(childArray, aBlockTag);
         NS_ENSURE_SUCCESS(res, res);
       }
       else
       {
         // make sure we can put a block here
         res = SplitAsNeeded(aBlockTag, address_of(curParent), &offset);
         NS_ENSURE_SUCCESS(res, res);
         nsCOMPtr<nsIDOMNode> theBlock;
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->CreateNode(*aBlockTag, curParent, offset, getter_AddRefs(theBlock));
         NS_ENSURE_SUCCESS(res, res);
         // remember our new block for postprocessing
         mNewBlock = theBlock;
       }
     }
     // if the node is a break, we honor it by putting further nodes in a new parent
     else if (curNodeTag.EqualsLiteral("br"))
     {
       if (curBlock)
       {
         curBlock = 0;  // forget any previous block used for previous inline nodes
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->DeleteNode(curNode);
         NS_ENSURE_SUCCESS(res, res);
       }
       else
       {
         // the break is the first (or even only) node we encountered.  Create a
         // block for it.
         res = SplitAsNeeded(aBlockTag, address_of(curParent), &offset);
         NS_ENSURE_SUCCESS(res, res);
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->CreateNode(*aBlockTag, curParent, offset, getter_AddRefs(curBlock));
         NS_ENSURE_SUCCESS(res, res);
         // remember our new block for postprocessing
         mNewBlock = curBlock;
         // note: doesn't matter if we set mNewBlock multiple times.
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->MoveNode(curNode, curBlock, -1);
         NS_ENSURE_SUCCESS(res, res);
       }
     }
     // if curNode is inline, pull it into curBlock
     // note: it's assumed that consecutive inline nodes in the
     // arrayOfNodes are actually members of the same block parent.
     // this happens to be true now as a side effect of how
     // arrayOfNodes is contructed, but some additional logic should
     // be added here if that should change
     else if (IsInlineNode(curNode))
     {
       // if curNode is a non editable, drop it if we are going to <pre>
       NS_ENSURE_STATE(mHTMLEditor);
       if (tString.LowerCaseEqualsLiteral("pre")
         && (!mHTMLEditor->IsEditable(curNode)))
         continue; // do nothing to this block
       // if no curBlock, make one
       if (!curBlock)
       {
         res = SplitAsNeeded(aBlockTag, address_of(curParent), &offset);
         NS_ENSURE_SUCCESS(res, res);
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->CreateNode(*aBlockTag, curParent, offset, getter_AddRefs(curBlock));
         NS_ENSURE_SUCCESS(res, res);
         // remember our new block for postprocessing
         mNewBlock = curBlock;
         // note: doesn't matter if we set mNewBlock multiple times.
       }
       // if curNode is a Break, replace it with a return if we are going to <pre>
       // xxx floppy moose
       // this is a continuation of some inline nodes that belong together in
       // the same block item.  use curBlock
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->MoveNode(curNode, curBlock, -1);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // SplitAsNeeded:  given a tag name, split inOutParent up to the point
 //                 where we can insert the tag.  Adjust inOutParent and
 //                 inOutOffset to pint to new location for tag.
 nsresult
 nsHTMLEditRules::SplitAsNeeded(const nsAString *aTag,
                                nsCOMPtr<nsIDOMNode> *inOutParent,
                                int32_t *inOutOffset)
 {
   NS_ENSURE_TRUE(aTag && inOutParent && inOutOffset, NS_ERROR_NULL_POINTER);
   NS_ENSURE_TRUE(*inOutParent, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIDOMNode> tagParent, temp, splitNode, parent = *inOutParent;
   nsresult res = NS_OK;
   nsCOMPtr<nsIAtom> tagAtom = do_GetAtom(*aTag);
   // check that we have a place that can legally contain the tag
   while (!tagParent)
   {
     // sniffing up the parent tree until we find
     // a legal place for the block
     if (!parent) break;
     // Don't leave the active editing host
     NS_ENSURE_STATE(mHTMLEditor);
     if (!mHTMLEditor->IsDescendantOfEditorRoot(parent)) {
       nsCOMPtr<nsIContent> parentContent = do_QueryInterface(parent);
       NS_ENSURE_STATE(mHTMLEditor);
       if (parentContent != mHTMLEditor->GetActiveEditingHost()) {
         break;
       }
     }
     NS_ENSURE_STATE(mHTMLEditor);
     if (mHTMLEditor->CanContainTag(parent, tagAtom)) {
       tagParent = parent;
       break;
     }
     splitNode = parent;
     parent->GetParentNode(getter_AddRefs(temp));
     parent = temp;
   }
   if (!tagParent)
   {
     // could not find a place to build tag!
     return NS_ERROR_FAILURE;
   }
   if (splitNode)
   {
     // we found a place for block, but above inOutParent.  We need to split nodes.
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->SplitNodeDeep(splitNode, *inOutParent, *inOutOffset, inOutOffset);
     NS_ENSURE_SUCCESS(res, res);
     *inOutParent = tagParent;
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // JoinNodesSmart:  join two nodes, doing whatever makes sense for their
 //                  children (which often means joining them, too).
 //                  aNodeLeft & aNodeRight must be same type of node.
 nsresult
 nsHTMLEditRules::JoinNodesSmart( nsIDOMNode *aNodeLeft,
                                  nsIDOMNode *aNodeRight,
                                  nsCOMPtr<nsIDOMNode> *aOutMergeParent,
                                  int32_t *aOutMergeOffset)
 {
   // check parms
   NS_ENSURE_TRUE(aNodeLeft &&
       aNodeRight &&
       aOutMergeParent &&
       aOutMergeOffset, NS_ERROR_NULL_POINTER);
   nsresult res = NS_OK;
   // caller responsible for:
   //   left & right node are same type
   int32_t parOffset;
   nsCOMPtr<nsIDOMNode> rightParent;
   nsCOMPtr<nsIDOMNode> parent = nsEditor::GetNodeLocation(aNodeLeft, &parOffset);
   aNodeRight->GetParentNode(getter_AddRefs(rightParent));
   // if they don't have the same parent, first move the 'right' node
   // to after the 'left' one
   if (parent != rightParent)
   {
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->MoveNode(aNodeRight, parent, parOffset);
     NS_ENSURE_SUCCESS(res, res);
   }
   // defaults for outParams
   *aOutMergeParent = aNodeRight;
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetLengthOfDOMNode(aNodeLeft, *((uint32_t*)aOutMergeOffset));
   NS_ENSURE_SUCCESS(res, res);
   // separate join rules for differing blocks
   if (nsHTMLEditUtils::IsList(aNodeLeft) ||
       !mHTMLEditor ||
       mHTMLEditor->IsTextNode(aNodeLeft))
   {
     // for list's, merge shallow (wouldn't want to combine list items)
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->JoinNodes(aNodeLeft, aNodeRight, parent);
     NS_ENSURE_SUCCESS(res, res);
     return res;
   }
   else
   {
     // remember the last left child, and firt right child
     nsCOMPtr<nsIDOMNode> lastLeft, firstRight;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetLastEditableChild(aNodeLeft, address_of(lastLeft));
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetFirstEditableChild(aNodeRight, address_of(firstRight));
     NS_ENSURE_SUCCESS(res, res);
     // for list items, divs, etc, merge smart
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->JoinNodes(aNodeLeft, aNodeRight, parent);
     NS_ENSURE_SUCCESS(res, res);
     if (lastLeft && firstRight && mHTMLEditor &&
         mHTMLEditor->NodesSameType(lastLeft, firstRight) &&
         (nsEditor::IsTextNode(lastLeft) ||
          !mHTMLEditor ||
          mHTMLEditor->mHTMLCSSUtils->ElementsSameStyle(lastLeft, firstRight))) {
       NS_ENSURE_STATE(mHTMLEditor);
       return JoinNodesSmart(lastLeft, firstRight, aOutMergeParent, aOutMergeOffset);
     }
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::GetTopEnclosingMailCite(nsIDOMNode *aNode,
                                          nsCOMPtr<nsIDOMNode> *aOutCiteNode,
                                          bool aPlainText)
 {
   // check parms
   NS_ENSURE_TRUE(aNode && aOutCiteNode, NS_ERROR_NULL_POINTER);
   nsresult res = NS_OK;
   nsCOMPtr<nsIDOMNode> node, parentNode;
   node = do_QueryInterface(aNode);
   while (node)
   {
     if ( (aPlainText && nsHTMLEditUtils::IsPre(node)) ||
          nsHTMLEditUtils::IsMailCite(node) )
       *aOutCiteNode = node;
     if (nsTextEditUtils::IsBody(node)) break;
     res = node->GetParentNode(getter_AddRefs(parentNode));
     NS_ENSURE_SUCCESS(res, res);
     node = parentNode;
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::CacheInlineStyles(nsIDOMNode *aNode)
 {
   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
   NS_ENSURE_STATE(mHTMLEditor);
   bool useCSS = mHTMLEditor->IsCSSEnabled();
   for (int32_t j = 0; j < SIZE_STYLE_TABLE; ++j)
   {
     bool isSet = false;
     nsAutoString outValue;
     // Don't use CSS for <font size>, we don't support it usefully (bug 780035)
     if (!useCSS || (mCachedStyles[j].tag == nsGkAtoms::font &&
                     mCachedStyles[j].attr.EqualsLiteral("size"))) {
       NS_ENSURE_STATE(mHTMLEditor);
       mHTMLEditor->IsTextPropertySetByContent(aNode, mCachedStyles[j].tag,
                                               &(mCachedStyles[j].attr), nullptr,
                                               isSet, &outValue);
     }
     else
     {
       NS_ENSURE_STATE(mHTMLEditor);
       mHTMLEditor->mHTMLCSSUtils->IsCSSEquivalentToHTMLInlineStyleSet(aNode,
         mCachedStyles[j].tag, &(mCachedStyles[j].attr), isSet, outValue,
         nsHTMLCSSUtils::eComputed);
     }
     if (isSet)
     {
       mCachedStyles[j].mPresent = true;
       mCachedStyles[j].value.Assign(outValue);
     }
   }
   return NS_OK;
 }
 nsresult
 nsHTMLEditRules::ReapplyCachedStyles()
 {
   // The idea here is to examine our cached list of styles and see if any have
   // been removed.  If so, add typeinstate for them, so that they will be
   // reinserted when new content is added.
   // remember if we are in css mode
   NS_ENSURE_STATE(mHTMLEditor);
   bool useCSS = mHTMLEditor->IsCSSEnabled();
   // get selection point; if it doesn't exist, we have nothing to do
   NS_ENSURE_STATE(mHTMLEditor);
   nsRefPtr<Selection> selection = mHTMLEditor->GetSelection();
   MOZ_ASSERT(selection);
   if (!selection->GetRangeCount()) {
     // Nothing to do
     return NS_OK;
   }
   nsCOMPtr<nsIContent> selNode =
     do_QueryInterface(selection->GetRangeAt(0)->GetStartParent());
   if (!selNode) {
     // Nothing to do
     return NS_OK;
   }
   for (int32_t i = 0; i < SIZE_STYLE_TABLE; ++i) {
     if (mCachedStyles[i].mPresent) {
       bool bFirst, bAny, bAll;
       bFirst = bAny = bAll = false;
       nsAutoString curValue;
       if (useCSS) {
         // check computed style first in css case
         NS_ENSURE_STATE(mHTMLEditor);
         bAny = mHTMLEditor->mHTMLCSSUtils->IsCSSEquivalentToHTMLInlineStyleSet(
           selNode, mCachedStyles[i].tag, &(mCachedStyles[i].attr), curValue,
           nsHTMLCSSUtils::eComputed);
       }
       if (!bAny) {
         // then check typeinstate and html style
         NS_ENSURE_STATE(mHTMLEditor);
         nsresult res = mHTMLEditor->GetInlinePropertyBase(mCachedStyles[i].tag,
                                                      &(mCachedStyles[i].attr),
                                                      &(mCachedStyles[i].value),
                                                      &bFirst, &bAny, &bAll,
                                                      &curValue, false);
         NS_ENSURE_SUCCESS(res, res);
       }
       // this style has disappeared through deletion.  Add to our typeinstate:
       if (!bAny || IsStyleCachePreservingAction(mTheAction)) {
         NS_ENSURE_STATE(mHTMLEditor);
         mHTMLEditor->mTypeInState->SetProp(mCachedStyles[i].tag,
                                            mCachedStyles[i].attr,
                                            mCachedStyles[i].value);
       }
     }
   }
   return NS_OK;
 }
 void
 nsHTMLEditRules::ClearCachedStyles()
 {
   // clear the mPresent bits in mCachedStyles array
   for (uint32_t j = 0; j < SIZE_STYLE_TABLE; j++) {
     mCachedStyles[j].mPresent = false;
     mCachedStyles[j].value.Truncate();
   }
 }
 nsresult
 nsHTMLEditRules::AdjustSpecialBreaks(bool aSafeToAskFrames)
 {
   nsCOMArray<nsIDOMNode> arrayOfNodes;
   nsCOMPtr<nsISupports> isupports;
   int32_t nodeCount,j;
   // gather list of empty nodes
   NS_ENSURE_STATE(mHTMLEditor);
   nsEmptyEditableFunctor functor(mHTMLEditor);
   nsDOMIterator iter;
   nsresult res = iter.Init(mDocChangeRange);
   NS_ENSURE_SUCCESS(res, res);
   res = iter.AppendList(functor, arrayOfNodes);
   NS_ENSURE_SUCCESS(res, res);
   // put moz-br's into these empty li's and td's
   nodeCount = arrayOfNodes.Count();
   for (j = 0; j < nodeCount; j++)
   {
     // need to put br at END of node.  It may have
     // empty containers in it and still pass the "IsEmptynode" test,
     // and we want the br's to be after them.  Also, we want the br
     // to be after the selection if the selection is in this node.
     uint32_t len;
     nsCOMPtr<nsIDOMNode> theNode = arrayOfNodes[0];
     arrayOfNodes.RemoveObjectAt(0);
     res = nsEditor::GetLengthOfDOMNode(theNode, len);
     NS_ENSURE_SUCCESS(res, res);
     res = CreateMozBR(theNode, (int32_t)len);
     NS_ENSURE_SUCCESS(res, res);
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::AdjustWhitespace(nsISelection *aSelection)
 {
   // get selection point
   nsCOMPtr<nsIDOMNode> selNode;
   int32_t selOffset;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(selNode), &selOffset);
   NS_ENSURE_SUCCESS(res, res);
   // ask whitespace object to tweak nbsp's
   NS_ENSURE_STATE(mHTMLEditor);
   return nsWSRunObject(mHTMLEditor, selNode, selOffset).AdjustWhitespace();
 }
 nsresult
 nsHTMLEditRules::PinSelectionToNewBlock(nsISelection *aSelection)
 {
   NS_ENSURE_TRUE(aSelection, NS_ERROR_NULL_POINTER);
   if (!aSelection->Collapsed()) {
     return NS_OK;
   }
   // get the (collapsed) selection location
   nsCOMPtr<nsIDOMNode> selNode, temp;
   int32_t selOffset;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(selNode), &selOffset);
   NS_ENSURE_SUCCESS(res, res);
   temp = selNode;
   // use ranges and sRangeHelper to compare sel point to new block
   nsCOMPtr<nsINode> node = do_QueryInterface(selNode);
   NS_ENSURE_STATE(node);
   nsRefPtr<nsRange> range = new nsRange(node);
   res = range->SetStart(selNode, selOffset);
   NS_ENSURE_SUCCESS(res, res);
   res = range->SetEnd(selNode, selOffset);
   NS_ENSURE_SUCCESS(res, res);
   nsCOMPtr<nsIContent> block (do_QueryInterface(mNewBlock));
   NS_ENSURE_TRUE(block, NS_ERROR_NO_INTERFACE);
   bool nodeBefore, nodeAfter;
   res = nsRange::CompareNodeToRange(block, range, &nodeBefore, &nodeAfter);
   NS_ENSURE_SUCCESS(res, res);
   if (nodeBefore && nodeAfter)
     return NS_OK;  // selection is inside block
   else if (nodeBefore)
   {
     // selection is after block.  put at end of block.
     nsCOMPtr<nsIDOMNode> tmp = mNewBlock;
     NS_ENSURE_STATE(mHTMLEditor);
     mHTMLEditor->GetLastEditableChild(mNewBlock, address_of(tmp));
     uint32_t endPoint;
     NS_ENSURE_STATE(mHTMLEditor);
     if (mHTMLEditor->IsTextNode(tmp) || !mHTMLEditor ||
         mHTMLEditor->IsContainer(tmp))
     {
       NS_ENSURE_STATE(mHTMLEditor);
       res = nsEditor::GetLengthOfDOMNode(tmp, endPoint);
       NS_ENSURE_SUCCESS(res, res);
     }
     else
     {
       tmp = nsEditor::GetNodeLocation(tmp, (int32_t*)&endPoint);
       endPoint++;  // want to be after this node
     }
     return aSelection->Collapse(tmp, (int32_t)endPoint);
   }
   else
   {
     // selection is before block.  put at start of block.
     nsCOMPtr<nsIDOMNode> tmp = mNewBlock;
     NS_ENSURE_STATE(mHTMLEditor);
     mHTMLEditor->GetFirstEditableChild(mNewBlock, address_of(tmp));
     int32_t offset;
     if (!(mHTMLEditor->IsTextNode(tmp) || !mHTMLEditor ||
           mHTMLEditor->IsContainer(tmp)))
     {
       tmp = nsEditor::GetNodeLocation(tmp, &offset);
     }
     NS_ENSURE_STATE(mHTMLEditor);
     return aSelection->Collapse(tmp, 0);
   }
 }
 nsresult
 nsHTMLEditRules::CheckInterlinePosition(nsISelection *aSelection)
 {
   NS_ENSURE_TRUE(aSelection, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsISelection> selection(aSelection);
   nsCOMPtr<nsISelectionPrivate> selPriv(do_QueryInterface(selection));
   // if the selection isn't collapsed, do nothing.
   if (!aSelection->Collapsed()) {
     return NS_OK;
   }
   // get the (collapsed) selection location
   nsCOMPtr<nsIDOMNode> selNode, node;
   int32_t selOffset;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(selNode), &selOffset);
   NS_ENSURE_SUCCESS(res, res);
   // First, let's check to see if we are after a <br>.  We take care of this
   // special-case first so that we don't accidentally fall through into one
   // of the other conditionals.
   NS_ENSURE_STATE(mHTMLEditor);
   mHTMLEditor->GetPriorHTMLNode(selNode, selOffset, address_of(node), true);
   if (node && nsTextEditUtils::IsBreak(node))
   {
     selPriv->SetInterlinePosition(true);
     return NS_OK;
   }
   // are we after a block?  If so try set caret to following content
   NS_ENSURE_STATE(mHTMLEditor);
   mHTMLEditor->GetPriorHTMLSibling(selNode, selOffset, address_of(node));
   if (node && IsBlockNode(node))
   {
     selPriv->SetInterlinePosition(true);
     return NS_OK;
   }
   // are we before a block?  If so try set caret to prior content
   NS_ENSURE_STATE(mHTMLEditor);
   mHTMLEditor->GetNextHTMLSibling(selNode, selOffset, address_of(node));
   if (node && IsBlockNode(node))
     selPriv->SetInterlinePosition(false);
   return NS_OK;
 }
 nsresult
 nsHTMLEditRules::AdjustSelection(nsISelection *aSelection, nsIEditor::EDirection aAction)
 {
   NS_ENSURE_TRUE(aSelection, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsISelection> selection(aSelection);
   nsCOMPtr<nsISelectionPrivate> selPriv(do_QueryInterface(selection));
   // if the selection isn't collapsed, do nothing.
   // moose: one thing to do instead is check for the case of
   // only a single break selected, and collapse it.  Good thing?  Beats me.
   if (!aSelection->Collapsed()) {
     return NS_OK;
   }
   // get the (collapsed) selection location
   nsCOMPtr<nsIDOMNode> selNode, temp;
   int32_t selOffset;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(selNode), &selOffset);
   NS_ENSURE_SUCCESS(res, res);
   temp = selNode;
   // are we in an editable node?
   NS_ENSURE_STATE(mHTMLEditor);
   while (!mHTMLEditor->IsEditable(selNode))
   {
     // scan up the tree until we find an editable place to be
     selNode = nsEditor::GetNodeLocation(temp, &selOffset);
     NS_ENSURE_TRUE(selNode, NS_ERROR_FAILURE);
     temp = selNode;
     NS_ENSURE_STATE(mHTMLEditor);
   }
   // make sure we aren't in an empty block - user will see no cursor.  If this
   // is happening, put a <br> in the block if allowed.
   nsCOMPtr<nsIDOMNode> theblock;
   if (IsBlockNode(selNode)) {
     theblock = selNode;
   } else {
     NS_ENSURE_STATE(mHTMLEditor);
     theblock = mHTMLEditor->GetBlockNodeParent(selNode);
   }
   NS_ENSURE_STATE(mHTMLEditor);
   if (theblock && mHTMLEditor->IsEditable(theblock)) {
     bool bIsEmptyNode;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->IsEmptyNode(theblock, &bIsEmptyNode, false, false);
     NS_ENSURE_SUCCESS(res, res);
     // check if br can go into the destination node
     NS_ENSURE_STATE(mHTMLEditor);
     if (bIsEmptyNode && mHTMLEditor->CanContainTag(selNode, nsGkAtoms::br)) {
       NS_ENSURE_STATE(mHTMLEditor);
       nsCOMPtr<nsIDOMNode> rootNode = do_QueryInterface(mHTMLEditor->GetRoot());
       NS_ENSURE_TRUE(rootNode, NS_ERROR_FAILURE);
       if (selNode == rootNode)
       {
         // Our root node is completely empty. Don't add a <br> here.
         // AfterEditInner() will add one for us when it calls
         // CreateBogusNodeIfNeeded()!
         return NS_OK;
       }
       // we know we can skip the rest of this routine given the cirumstance
       return CreateMozBR(selNode, selOffset);
     }
   }
   // are we in a text node?
   nsCOMPtr<nsIDOMCharacterData> textNode = do_QueryInterface(selNode);
   if (textNode)
     return NS_OK; // we LIKE it when we are in a text node.  that RULZ
   // do we need to insert a special mozBR?  We do if we are:
   // 1) prior node is in same block where selection is AND
   // 2) prior node is a br AND
   // 3) that br is not visible
   nsCOMPtr<nsIDOMNode> nearNode;
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetPriorHTMLNode(selNode, selOffset, address_of(nearNode));
   NS_ENSURE_SUCCESS(res, res);
   if (nearNode)
   {
     // is nearNode also a descendant of same block?
     nsCOMPtr<nsIDOMNode> block, nearBlock;
     if (IsBlockNode(selNode)) {
       block = selNode;
     } else {
       NS_ENSURE_STATE(mHTMLEditor);
       block = mHTMLEditor->GetBlockNodeParent(selNode);
     }
     NS_ENSURE_STATE(mHTMLEditor);
     nearBlock = mHTMLEditor->GetBlockNodeParent(nearNode);
     if (block == nearBlock)
     {
       if (nearNode && nsTextEditUtils::IsBreak(nearNode) )
       {
         NS_ENSURE_STATE(mHTMLEditor);
         if (!mHTMLEditor->IsVisBreak(nearNode))
         {
           // need to insert special moz BR. Why?  Because if we don't
           // the user will see no new line for the break.  Also, things
           // like table cells won't grow in height.
           nsCOMPtr<nsIDOMNode> brNode;
           res = CreateMozBR(selNode, selOffset, getter_AddRefs(brNode));
           NS_ENSURE_SUCCESS(res, res);
           selNode = nsEditor::GetNodeLocation(brNode, &selOffset);
           // selection stays *before* moz-br, sticking to it
           selPriv->SetInterlinePosition(true);
           res = aSelection->Collapse(selNode,selOffset);
           NS_ENSURE_SUCCESS(res, res);
         }
         else
         {
           nsCOMPtr<nsIDOMNode> nextNode;
           NS_ENSURE_STATE(mHTMLEditor);
           mHTMLEditor->GetNextHTMLNode(nearNode, address_of(nextNode), true);
           if (nextNode && nsTextEditUtils::IsMozBR(nextNode))
           {
             // selection between br and mozbr.  make it stick to mozbr
             // so that it will be on blank line.
             selPriv->SetInterlinePosition(true);
           }
         }
       }
     }
   }
   // we aren't in a textnode: are we adjacent to text or a break or an image?
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetPriorHTMLNode(selNode, selOffset, address_of(nearNode), true);
   NS_ENSURE_SUCCESS(res, res);
   if (nearNode && (nsTextEditUtils::IsBreak(nearNode)
                    || nsEditor::IsTextNode(nearNode)
                    || nsHTMLEditUtils::IsImage(nearNode)
                    || nsHTMLEditUtils::IsHR(nearNode)))
     return NS_OK; // this is a good place for the caret to be
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetNextHTMLNode(selNode, selOffset, address_of(nearNode), true);
   NS_ENSURE_SUCCESS(res, res);
   if (nearNode && (nsTextEditUtils::IsBreak(nearNode)
                    || nsEditor::IsTextNode(nearNode)
                    || nsHTMLEditUtils::IsImage(nearNode)
                    || nsHTMLEditUtils::IsHR(nearNode)))
     return NS_OK; // this is a good place for the caret to be
   // look for a nearby text node.
   // prefer the correct direction.
   res = FindNearSelectableNode(selNode, selOffset, aAction, address_of(nearNode));
   NS_ENSURE_SUCCESS(res, res);
   if (nearNode)
   {
     // is the nearnode a text node?
     textNode = do_QueryInterface(nearNode);
     if (textNode)
     {
       int32_t offset = 0;
       // put selection in right place:
       if (aAction == nsIEditor::ePrevious)
         textNode->GetLength((uint32_t*)&offset);
       res = aSelection->Collapse(nearNode,offset);
     }
     else  // must be break or image
     {
       selNode = nsEditor::GetNodeLocation(nearNode, &selOffset);
       if (aAction == nsIEditor::ePrevious) selOffset++;  // want to be beyond it if we backed up to it
       res = aSelection->Collapse(selNode, selOffset);
     }
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::FindNearSelectableNode(nsIDOMNode *aSelNode,
                                         int32_t aSelOffset,
                                         nsIEditor::EDirection &aDirection,
                                         nsCOMPtr<nsIDOMNode> *outSelectableNode)
 {
   NS_ENSURE_TRUE(aSelNode && outSelectableNode, NS_ERROR_NULL_POINTER);
   *outSelectableNode = nullptr;
   nsresult res = NS_OK;
   nsCOMPtr<nsIDOMNode> nearNode, curNode;
   if (aDirection == nsIEditor::ePrevious) {
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetPriorHTMLNode(aSelNode, aSelOffset, address_of(nearNode));
   } else {
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetNextHTMLNode(aSelNode, aSelOffset, address_of(nearNode));
   }
   NS_ENSURE_SUCCESS(res, res);
   if (!nearNode) // try the other direction then
   {
     if (aDirection == nsIEditor::ePrevious)
       aDirection = nsIEditor::eNext;
     else
       aDirection = nsIEditor::ePrevious;
     if (aDirection == nsIEditor::ePrevious) {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->GetPriorHTMLNode(aSelNode, aSelOffset, address_of(nearNode));
     } else {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->GetNextHTMLNode(aSelNode, aSelOffset, address_of(nearNode));
     }
     NS_ENSURE_SUCCESS(res, res);
   }
   // scan in the right direction until we find an eligible text node,
   // but don't cross any breaks, images, or table elements.
   NS_ENSURE_STATE(mHTMLEditor);
   while (nearNode && !(mHTMLEditor->IsTextNode(nearNode)
                        || nsTextEditUtils::IsBreak(nearNode)
                        || nsHTMLEditUtils::IsImage(nearNode)))
   {
     curNode = nearNode;
     if (aDirection == nsIEditor::ePrevious) {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->GetPriorHTMLNode(curNode, address_of(nearNode));
     } else {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->GetNextHTMLNode(curNode, address_of(nearNode));
     }
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_STATE(mHTMLEditor);
   }
   if (nearNode)
   {
     // don't cross any table elements
     if (InDifferentTableElements(nearNode, aSelNode)) {
       return NS_OK;
     }
     // otherwise, ok, we have found a good spot to put the selection
     *outSelectableNode = do_QueryInterface(nearNode);
   }
   return res;
 }
 bool nsHTMLEditRules::InDifferentTableElements(nsIDOMNode* aNode1,
                                                nsIDOMNode* aNode2)
 {
   nsCOMPtr<nsINode> node1 = do_QueryInterface(aNode1);
   nsCOMPtr<nsINode> node2 = do_QueryInterface(aNode2);
   return InDifferentTableElements(node1, node2);
 }
 bool
 nsHTMLEditRules::InDifferentTableElements(nsINode* aNode1, nsINode* aNode2)
 {
   MOZ_ASSERT(aNode1 && aNode2);
   while (aNode1 && !nsHTMLEditUtils::IsTableElement(aNode1)) {
     aNode1 = aNode1->GetParentNode();
   }
   while (aNode2 && !nsHTMLEditUtils::IsTableElement(aNode2)) {
     aNode2 = aNode2->GetParentNode();
   }
   return aNode1 != aNode2;
 }
 nsresult
 nsHTMLEditRules::RemoveEmptyNodes()
 {
   // some general notes on the algorithm used here: the goal is to examine all the
   // nodes in mDocChangeRange, and remove the empty ones.  We do this by using a
   // content iterator to traverse all the nodes in the range, and placing the empty
   // nodes into an array.  After finishing the iteration, we delete the empty nodes
   // in the array.  (they cannot be deleted as we find them becasue that would
   // invalidate the iterator.)
   // Since checking to see if a node is empty can be costly for nodes with many
   // descendants, there are some optimizations made.  I rely on the fact that the
   // iterator is post-order: it will visit children of a node before visiting the
   // parent node.  So if I find that a child node is not empty, I know that its
   // parent is not empty without even checking.  So I put the parent on a "skipList"
   // which is just a voidArray of nodes I can skip the empty check on.  If I
   // encounter a node on the skiplist, i skip the processing for that node and replace
   // its slot in the skiplist with that node's parent.
   // An interseting idea is to go ahead and regard parent nodes that are NOT on the
   // skiplist as being empty (without even doing the IsEmptyNode check) on the theory
   // that if they weren't empty, we would have encountered a non-empty child earlier
   // and thus put this parent node on the skiplist.
   // Unfortunately I can't use that strategy here, because the range may include
   // some children of a node while excluding others.  Thus I could find all the
   // _examined_ children empty, but still not have an empty parent.
   // need an iterator
   nsCOMPtr<nsIContentIterator> iter =
                   do_CreateInstance("@mozilla.org/content/post-content-iterator;1");
   NS_ENSURE_TRUE(iter, NS_ERROR_NULL_POINTER);
   nsresult res = iter->Init(mDocChangeRange);
   NS_ENSURE_SUCCESS(res, res);
   nsCOMArray<nsINode> arrayOfEmptyNodes, arrayOfEmptyCites;
   nsTArray<nsCOMPtr<nsINode> > skipList;
   // check for empty nodes
   while (!iter->IsDone()) {
     nsINode* node = iter->GetCurrentNode();
     NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
     nsINode* parent = node->GetParentNode();
     uint32_t idx = skipList.IndexOf(node);
     if (idx != skipList.NoIndex) {
       // this node is on our skip list.  Skip processing for this node,
       // and replace its value in the skip list with the value of its parent
       skipList[idx] = parent;
     } else {
       bool bIsCandidate = false;
       bool bIsEmptyNode = false;
       bool bIsMailCite = false;
       if (node->IsElement()) {
         dom::Element* element = node->AsElement();
         if (element->IsHTML(nsGkAtoms::body)) {
           // don't delete the body
         } else if ((bIsMailCite = nsHTMLEditUtils::IsMailCite(element))  ||
                    element->IsHTML(nsGkAtoms::a)                         ||
                    nsHTMLEditUtils::IsInlineStyle(element)               ||
                    nsHTMLEditUtils::IsList(element)                      ||
                    element->IsHTML(nsGkAtoms::div)) {
           // only consider certain nodes to be empty for purposes of removal
           bIsCandidate = true;
         } else if (nsHTMLEditUtils::IsFormatNode(element) ||
                    nsHTMLEditUtils::IsListItem(element)   ||
                    element->IsHTML(nsGkAtoms::blockquote)) {
           // these node types are candidates if selection is not in them
           // if it is one of these, don't delete if selection inside.
           // this is so we can create empty headings, etc, for the
           // user to type into.
           bool bIsSelInNode;
           res = SelectionEndpointInNode(node, &bIsSelInNode);
           NS_ENSURE_SUCCESS(res, res);
           if (!bIsSelInNode)
           {
             bIsCandidate = true;
           }
         }
       }
       if (bIsCandidate) {
         // we delete mailcites even if they have a solo br in them
         // other nodes we require to be empty
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->IsEmptyNode(node->AsDOMNode(), &bIsEmptyNode,
                                        bIsMailCite, true);
         NS_ENSURE_SUCCESS(res, res);
         if (bIsEmptyNode) {
           if (bIsMailCite) {
             // mailcites go on a separate list from other empty nodes
             arrayOfEmptyCites.AppendObject(node);
           } else {
             arrayOfEmptyNodes.AppendObject(node);
           }
         }
       }
       if (!bIsEmptyNode) {
         // put parent on skip list
         skipList.AppendElement(parent);
       }
     }
     iter->Next();
   }
   // now delete the empty nodes
   int32_t nodeCount = arrayOfEmptyNodes.Count();
   for (int32_t j = 0; j < nodeCount; j++) {
     nsCOMPtr<nsIDOMNode> delNode = arrayOfEmptyNodes[0]->AsDOMNode();
     arrayOfEmptyNodes.RemoveObjectAt(0);
     NS_ENSURE_STATE(mHTMLEditor);
     if (mHTMLEditor->IsModifiableNode(delNode)) {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->DeleteNode(delNode);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   // now delete the empty mailcites
   // this is a separate step because we want to pull out any br's and preserve them.
   nodeCount = arrayOfEmptyCites.Count();
   for (int32_t j = 0; j < nodeCount; j++) {
     nsCOMPtr<nsIDOMNode> delNode = arrayOfEmptyCites[0]->AsDOMNode();
     arrayOfEmptyCites.RemoveObjectAt(0);
     bool bIsEmptyNode;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->IsEmptyNode(delNode, &bIsEmptyNode, false, true);
     NS_ENSURE_SUCCESS(res, res);
     if (!bIsEmptyNode)
     {
       // we are deleting a cite that has just a br.  We want to delete cite,
       // but preserve br.
       nsCOMPtr<nsIDOMNode> parent, brNode;
       int32_t offset;
       parent = nsEditor::GetNodeLocation(delNode, &offset);
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->CreateBR(parent, offset, address_of(brNode));
       NS_ENSURE_SUCCESS(res, res);
     }
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->DeleteNode(delNode);
     NS_ENSURE_SUCCESS(res, res);
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::SelectionEndpointInNode(nsINode* aNode, bool* aResult)
 {
   NS_ENSURE_TRUE(aNode && aResult, NS_ERROR_NULL_POINTER);
   nsIDOMNode* node = aNode->AsDOMNode();
   *aResult = false;
   nsCOMPtr<nsISelection>selection;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res = mHTMLEditor->GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   Selection* sel = static_cast<Selection*>(selection.get());
   uint32_t rangeCount = sel->GetRangeCount();
   for (uint32_t rangeIdx = 0; rangeIdx < rangeCount; ++rangeIdx) {
     nsRefPtr<nsRange> range = sel->GetRangeAt(rangeIdx);
     nsCOMPtr<nsIDOMNode> startParent, endParent;
     range->GetStartContainer(getter_AddRefs(startParent));
     if (startParent)
     {
       if (node == startParent) {
         *aResult = true;
         return NS_OK;
       }
       if (nsEditorUtils::IsDescendantOf(startParent, node)) {
         *aResult = true;
         return NS_OK;
       }
     }
     range->GetEndContainer(getter_AddRefs(endParent));
     if (startParent == endParent) continue;
     if (endParent)
     {
       if (node == endParent) {
         *aResult = true;
         return NS_OK;
       }
       if (nsEditorUtils::IsDescendantOf(endParent, node)) {
         *aResult = true;
         return NS_OK;
       }
     }
   }
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // IsEmptyInline:  return true if aNode is an empty inline container
 //
 //
 bool
 nsHTMLEditRules::IsEmptyInline(nsIDOMNode *aNode)
 {
   if (aNode && IsInlineNode(aNode) && mHTMLEditor &&
       mHTMLEditor->IsContainer(aNode))
   {
     bool bEmpty;
     NS_ENSURE_TRUE(mHTMLEditor, false);
     mHTMLEditor->IsEmptyNode(aNode, &bEmpty);
     return bEmpty;
   }
   return false;
 }
 bool
 nsHTMLEditRules::ListIsEmptyLine(nsCOMArray<nsIDOMNode> &arrayOfNodes)
 {
   // we have a list of nodes which we are candidates for being moved
   // into a new block.  Determine if it's anything more than a blank line.
   // Look for editable content above and beyond one single BR.
   int32_t listCount = arrayOfNodes.Count();
   NS_ENSURE_TRUE(listCount, true);
   nsCOMPtr<nsIDOMNode> somenode;
   int32_t j, brCount=0;
   for (j = 0; j < listCount; j++)
   {
     somenode = arrayOfNodes[j];
     NS_ENSURE_TRUE(mHTMLEditor, false);
     if (somenode && mHTMLEditor->IsEditable(somenode))
     {
       if (nsTextEditUtils::IsBreak(somenode))
       {
         // first break doesn't count
         if (brCount) return false;
         brCount++;
       }
       else if (IsEmptyInline(somenode))
       {
         // empty inline, keep looking
       }
       else return false;
     }
   }
   return true;
 }
 nsresult
 nsHTMLEditRules::PopListItem(nsIDOMNode *aListItem, bool *aOutOfList)
 {
   // check parms
   NS_ENSURE_TRUE(aListItem && aOutOfList, NS_ERROR_NULL_POINTER);
   // init out params
   *aOutOfList = false;
   nsCOMPtr<nsIDOMNode> curNode( do_QueryInterface(aListItem));
   int32_t offset;
   nsCOMPtr<nsIDOMNode> curParent = nsEditor::GetNodeLocation(curNode, &offset);
   if (!nsHTMLEditUtils::IsListItem(curNode))
     return NS_ERROR_FAILURE;
   // if it's first or last list item, don't need to split the list
   // otherwise we do.
   int32_t parOffset;
   nsCOMPtr<nsIDOMNode> curParPar = nsEditor::GetNodeLocation(curParent, &parOffset);
   bool bIsFirstListItem;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res = mHTMLEditor->IsFirstEditableChild(curNode, &bIsFirstListItem);
   NS_ENSURE_SUCCESS(res, res);
   bool bIsLastListItem;
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->IsLastEditableChild(curNode, &bIsLastListItem);
   NS_ENSURE_SUCCESS(res, res);
   if (!bIsFirstListItem && !bIsLastListItem)
   {
     // split the list
     nsCOMPtr<nsIDOMNode> newBlock;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->SplitNode(curParent, offset, getter_AddRefs(newBlock));
     NS_ENSURE_SUCCESS(res, res);
   }
   if (!bIsFirstListItem) parOffset++;
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->MoveNode(curNode, curParPar, parOffset);
   NS_ENSURE_SUCCESS(res, res);
   // unwrap list item contents if they are no longer in a list
   if (!nsHTMLEditUtils::IsList(curParPar)
       && nsHTMLEditUtils::IsListItem(curNode))
   {
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->RemoveBlockContainer(curNode);
     NS_ENSURE_SUCCESS(res, res);
     *aOutOfList = true;
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::RemoveListStructure(nsIDOMNode *aList)
 {
   NS_ENSURE_ARG_POINTER(aList);
   nsresult res;
   nsCOMPtr<nsIDOMNode> child;
   aList->GetFirstChild(getter_AddRefs(child));
   while (child)
   {
     if (nsHTMLEditUtils::IsListItem(child))
     {
       bool bOutOfList;
       do
       {
         res = PopListItem(child, &bOutOfList);
         NS_ENSURE_SUCCESS(res, res);
       } while (!bOutOfList);   // keep popping it out until it's not in a list anymore
     }
     else if (nsHTMLEditUtils::IsList(child))
     {
       res = RemoveListStructure(child);
       NS_ENSURE_SUCCESS(res, res);
     }
     else
     {
       // delete any non- list items for now
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->DeleteNode(child);
       NS_ENSURE_SUCCESS(res, res);
     }
     aList->GetFirstChild(getter_AddRefs(child));
   }
   // delete the now-empty list
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->RemoveBlockContainer(aList);
   NS_ENSURE_SUCCESS(res, res);
   return res;
 }
 nsresult
 nsHTMLEditRules::ConfirmSelectionInBody()
 {
   nsresult res = NS_OK;
   // get the body
   NS_ENSURE_STATE(mHTMLEditor);
   nsCOMPtr<nsIDOMElement> rootElement = do_QueryInterface(mHTMLEditor->GetRoot());
   NS_ENSURE_TRUE(rootElement, NS_ERROR_UNEXPECTED);
   // get the selection
   nsCOMPtr<nsISelection>selection;
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   // get the selection start location
   nsCOMPtr<nsIDOMNode> selNode, temp, parent;
   int32_t selOffset;
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetStartNodeAndOffset(selection, getter_AddRefs(selNode), &selOffset);
   NS_ENSURE_SUCCESS(res, res);
   temp = selNode;
   // check that selNode is inside body
   while (temp && !nsTextEditUtils::IsBody(temp))
   {
     res = temp->GetParentNode(getter_AddRefs(parent));
     temp = parent;
   }
   // if we aren't in the body, force the issue
   if (!temp)
   {
 //    uncomment this to see when we get bad selections
 //    NS_NOTREACHED("selection not in body");
     selection->Collapse(rootElement, 0);
   }
   // get the selection end location
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetEndNodeAndOffset(selection, getter_AddRefs(selNode), &selOffset);
   NS_ENSURE_SUCCESS(res, res);
   temp = selNode;
   // check that selNode is inside body
   while (temp && !nsTextEditUtils::IsBody(temp))
   {
     res = temp->GetParentNode(getter_AddRefs(parent));
     temp = parent;
   }
   // if we aren't in the body, force the issue
   if (!temp)
   {
 //    uncomment this to see when we get bad selections
 //    NS_NOTREACHED("selection not in body");
     selection->Collapse(rootElement, 0);
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::UpdateDocChangeRange(nsIDOMRange *aRange)
 {
   nsresult res = NS_OK;
   // first make sure aRange is in the document.  It might not be if
   // portions of our editting action involved manipulating nodes
   // prior to placing them in the document (e.g., populating a list item
   // before placing it in its list)
   nsCOMPtr<nsIDOMNode> startNode;
   res = aRange->GetStartContainer(getter_AddRefs(startNode));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_STATE(mHTMLEditor);
   if (!mHTMLEditor->IsDescendantOfRoot(startNode)) {
     // just return - we don't need to adjust mDocChangeRange in this case
     return NS_OK;
   }
   if (!mDocChangeRange)
   {
     // clone aRange.
     nsCOMPtr<nsIDOMRange> range;
     res = aRange->CloneRange(getter_AddRefs(range));
     mDocChangeRange = static_cast<nsRange*>(range.get());
   }
   else
   {
     int16_t result;
     // compare starts of ranges
     res = mDocChangeRange->CompareBoundaryPoints(nsIDOMRange::START_TO_START, aRange, &result);
     if (res == NS_ERROR_NOT_INITIALIZED) {
       // This will happen is mDocChangeRange is non-null, but the range is
       // uninitialized. In this case we'll set the start to aRange start.
       // The same test won't be needed further down since after we've set
       // the start the range will be collapsed to that point.
       result = 1;
       res = NS_OK;
     }
     NS_ENSURE_SUCCESS(res, res);
     if (result > 0)  // positive result means mDocChangeRange start is after aRange start
     {
       int32_t startOffset;
       res = aRange->GetStartOffset(&startOffset);
       NS_ENSURE_SUCCESS(res, res);
       res = mDocChangeRange->SetStart(startNode, startOffset);
       NS_ENSURE_SUCCESS(res, res);
     }
     // compare ends of ranges
     res = mDocChangeRange->CompareBoundaryPoints(nsIDOMRange::END_TO_END, aRange, &result);
     NS_ENSURE_SUCCESS(res, res);
     if (result < 0)  // negative result means mDocChangeRange end is before aRange end
     {
       nsCOMPtr<nsIDOMNode> endNode;
       int32_t endOffset;
       res = aRange->GetEndContainer(getter_AddRefs(endNode));
       NS_ENSURE_SUCCESS(res, res);
       res = aRange->GetEndOffset(&endOffset);
       NS_ENSURE_SUCCESS(res, res);
       res = mDocChangeRange->SetEnd(endNode, endOffset);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::InsertMozBRIfNeeded(nsIDOMNode *aNode)
 {
   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
   if (!IsBlockNode(aNode)) return NS_OK;
   bool isEmpty;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res = mHTMLEditor->IsEmptyNode(aNode, &isEmpty);
   NS_ENSURE_SUCCESS(res, res);
   if (!isEmpty) {
     return NS_OK;
   }
   return CreateMozBR(aNode, 0);
 }
 NS_IMETHODIMP
 nsHTMLEditRules::WillCreateNode(const nsAString& aTag, nsIDOMNode *aParent, int32_t aPosition)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::DidCreateNode(const nsAString& aTag,
                                nsIDOMNode *aNode,
                                nsIDOMNode *aParent,
                                int32_t aPosition,
                                nsresult aResult)
 {
   if (!mListenerEnabled) {
     return NS_OK;
   }
   // assumption that Join keeps the righthand node
   nsresult res = mUtilRange->SelectNode(aNode);
   NS_ENSURE_SUCCESS(res, res);
   res = UpdateDocChangeRange(mUtilRange);
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::WillInsertNode(nsIDOMNode *aNode, nsIDOMNode *aParent, int32_t aPosition)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::DidInsertNode(nsIDOMNode *aNode,
                                nsIDOMNode *aParent,
                                int32_t aPosition,
                                nsresult aResult)
 {
   if (!mListenerEnabled) {
     return NS_OK;
   }
   nsresult res = mUtilRange->SelectNode(aNode);
   NS_ENSURE_SUCCESS(res, res);
   res = UpdateDocChangeRange(mUtilRange);
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::WillDeleteNode(nsIDOMNode *aChild)
 {
   if (!mListenerEnabled) {
     return NS_OK;
   }
   nsresult res = mUtilRange->SelectNode(aChild);
   NS_ENSURE_SUCCESS(res, res);
   res = UpdateDocChangeRange(mUtilRange);
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::DidDeleteNode(nsIDOMNode *aChild, nsresult aResult)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::WillSplitNode(nsIDOMNode *aExistingRightNode, int32_t aOffset)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::DidSplitNode(nsIDOMNode *aExistingRightNode,
                               int32_t aOffset,
                               nsIDOMNode *aNewLeftNode,
                               nsresult aResult)
 {
   if (!mListenerEnabled) {
     return NS_OK;
   }
   nsresult res = mUtilRange->SetStart(aNewLeftNode, 0);
   NS_ENSURE_SUCCESS(res, res);
   res = mUtilRange->SetEnd(aExistingRightNode, 0);
   NS_ENSURE_SUCCESS(res, res);
   res = UpdateDocChangeRange(mUtilRange);
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::WillJoinNodes(nsIDOMNode *aLeftNode, nsIDOMNode *aRightNode, nsIDOMNode *aParent)
 {
   if (!mListenerEnabled) {
     return NS_OK;
   }
   // remember split point
   nsresult res = nsEditor::GetLengthOfDOMNode(aLeftNode, mJoinOffset);
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::DidJoinNodes(nsIDOMNode  *aLeftNode,
                               nsIDOMNode *aRightNode,
                               nsIDOMNode *aParent,
                               nsresult aResult)
 {
   if (!mListenerEnabled) {
     return NS_OK;
   }
   // assumption that Join keeps the righthand node
   nsresult res = mUtilRange->SetStart(aRightNode, mJoinOffset);
   NS_ENSURE_SUCCESS(res, res);
   res = mUtilRange->SetEnd(aRightNode, mJoinOffset);
   NS_ENSURE_SUCCESS(res, res);
   res = UpdateDocChangeRange(mUtilRange);
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::WillInsertText(nsIDOMCharacterData *aTextNode, int32_t aOffset, const nsAString &aString)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::DidInsertText(nsIDOMCharacterData *aTextNode,
                                   int32_t aOffset,
                                   const nsAString &aString,
                                   nsresult aResult)
 {
   if (!mListenerEnabled) {
     return NS_OK;
   }
   int32_t length = aString.Length();
   nsCOMPtr<nsIDOMNode> theNode = do_QueryInterface(aTextNode);
   nsresult res = mUtilRange->SetStart(theNode, aOffset);
   NS_ENSURE_SUCCESS(res, res);
   res = mUtilRange->SetEnd(theNode, aOffset+length);
   NS_ENSURE_SUCCESS(res, res);
   res = UpdateDocChangeRange(mUtilRange);
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::WillDeleteText(nsIDOMCharacterData *aTextNode, int32_t aOffset, int32_t aLength)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::DidDeleteText(nsIDOMCharacterData *aTextNode,
                                   int32_t aOffset,
                                   int32_t aLength,
                                   nsresult aResult)
 {
   if (!mListenerEnabled) {
     return NS_OK;
   }
   nsCOMPtr<nsIDOMNode> theNode = do_QueryInterface(aTextNode);
   nsresult res = mUtilRange->SetStart(theNode, aOffset);
   NS_ENSURE_SUCCESS(res, res);
   res = mUtilRange->SetEnd(theNode, aOffset);
   NS_ENSURE_SUCCESS(res, res);
   res = UpdateDocChangeRange(mUtilRange);
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::WillDeleteSelection(nsISelection *aSelection)
 {
   if (!mListenerEnabled) {
     return NS_OK;
   }
   // get the (collapsed) selection location
   nsCOMPtr<nsIDOMNode> selNode;
   int32_t selOffset;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(selNode), &selOffset);
   NS_ENSURE_SUCCESS(res, res);
   res = mUtilRange->SetStart(selNode, selOffset);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetEndNodeAndOffset(aSelection, getter_AddRefs(selNode), &selOffset);
   NS_ENSURE_SUCCESS(res, res);
   res = mUtilRange->SetEnd(selNode, selOffset);
   NS_ENSURE_SUCCESS(res, res);
   res = UpdateDocChangeRange(mUtilRange);
   return res;
 }
 NS_IMETHODIMP
 nsHTMLEditRules::DidDeleteSelection(nsISelection *aSelection)
 {
   return NS_OK;
 }
 // Let's remove all alignment hints in the children of aNode; it can
 // be an ALIGN attribute (in case we just remove it) or a CENTER
 // element (here we have to remove the container and keep its
 // children). We break on tables and don't look at their children.
 nsresult
 nsHTMLEditRules::RemoveAlignment(nsIDOMNode * aNode, const nsAString & aAlignType, bool aChildrenOnly)
 {
   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
   NS_ENSURE_STATE(mHTMLEditor);
   if (mHTMLEditor->IsTextNode(aNode) || nsHTMLEditUtils::IsTable(aNode)) return NS_OK;
   nsresult res = NS_OK;
   nsCOMPtr<nsIDOMNode> child = aNode,tmp;
   if (aChildrenOnly)
   {
     aNode->GetFirstChild(getter_AddRefs(child));
   }
   NS_ENSURE_STATE(mHTMLEditor);
   bool useCSS = mHTMLEditor->IsCSSEnabled();
   while (child)
   {
     if (aChildrenOnly) {
       // get the next sibling right now because we could have to remove child
       child->GetNextSibling(getter_AddRefs(tmp));
     }
     else
     {
       tmp = nullptr;
     }
     bool isBlock;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->NodeIsBlockStatic(child, &isBlock);
     NS_ENSURE_SUCCESS(res, res);
     if (nsEditor::NodeIsType(child, nsEditProperty::center))
     {
       // the current node is a CENTER element
       // first remove children's alignment
       res = RemoveAlignment(child, aAlignType, true);
       NS_ENSURE_SUCCESS(res, res);
       // we may have to insert BRs in first and last position of element's children
       // if the nodes before/after are not blocks and not BRs
       res = MakeSureElemStartsOrEndsOnCR(child);
       NS_ENSURE_SUCCESS(res, res);
       // now remove the CENTER container
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->RemoveContainer(child);
       NS_ENSURE_SUCCESS(res, res);
     }
     else if (isBlock || nsHTMLEditUtils::IsHR(child))
     {
       // the current node is a block element
       nsCOMPtr<nsIDOMElement> curElem = do_QueryInterface(child);
       if (nsHTMLEditUtils::SupportsAlignAttr(child))
       {
         // remove the ALIGN attribute if this element can have it
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->RemoveAttribute(curElem, NS_LITERAL_STRING("align"));
         NS_ENSURE_SUCCESS(res, res);
       }
       if (useCSS)
       {
         if (nsHTMLEditUtils::IsTable(child) || nsHTMLEditUtils::IsHR(child))
         {
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->SetAttributeOrEquivalent(curElem, NS_LITERAL_STRING("align"), aAlignType, false);
         }
         else
         {
           nsAutoString dummyCssValue;
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->mHTMLCSSUtils->RemoveCSSInlineStyle(child, nsEditProperty::cssTextAlign, dummyCssValue);
         }
         NS_ENSURE_SUCCESS(res, res);
       }
       if (!nsHTMLEditUtils::IsTable(child))
       {
         // unless this is a table, look at children
         res = RemoveAlignment(child, aAlignType, true);
         NS_ENSURE_SUCCESS(res, res);
       }
     }
     child = tmp;
   }
   return NS_OK;
 }
 // Let's insert a BR as first (resp. last) child of aNode if its
 // first (resp. last) child is not a block nor a BR, and if the
 // previous (resp. next) sibling is not a block nor a BR
 nsresult
 nsHTMLEditRules::MakeSureElemStartsOrEndsOnCR(nsIDOMNode *aNode, bool aStarts)
 {
   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIDOMNode> child;
   nsresult res;
   if (aStarts)
   {
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetFirstEditableChild(aNode, address_of(child));
   }
   else
   {
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetLastEditableChild(aNode, address_of(child));
   }
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(child, NS_OK);
   bool isChildBlock;
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->NodeIsBlockStatic(child, &isChildBlock);
   NS_ENSURE_SUCCESS(res, res);
   bool foundCR = false;
   if (isChildBlock || nsTextEditUtils::IsBreak(child))
   {
     foundCR = true;
   }
   else
   {
     nsCOMPtr<nsIDOMNode> sibling;
     if (aStarts)
     {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->GetPriorHTMLSibling(aNode, address_of(sibling));
     }
     else
     {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->GetNextHTMLSibling(aNode, address_of(sibling));
     }
     NS_ENSURE_SUCCESS(res, res);
     if (sibling)
     {
       bool isBlock;
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->NodeIsBlockStatic(sibling, &isBlock);
       NS_ENSURE_SUCCESS(res, res);
       if (isBlock || nsTextEditUtils::IsBreak(sibling))
       {
         foundCR = true;
       }
     }
     else
     {
       foundCR = true;
     }
   }
   if (!foundCR)
   {
     int32_t offset = 0;
     if (!aStarts) {
       nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
       NS_ENSURE_STATE(node);
       offset = node->GetChildCount();
     }
     nsCOMPtr<nsIDOMNode> brNode;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->CreateBR(aNode, offset, address_of(brNode));
     NS_ENSURE_SUCCESS(res, res);
   }
   return NS_OK;
 }
 nsresult
 nsHTMLEditRules::MakeSureElemStartsOrEndsOnCR(nsIDOMNode *aNode)
 {
   nsresult res = MakeSureElemStartsOrEndsOnCR(aNode, false);
   NS_ENSURE_SUCCESS(res, res);
   res = MakeSureElemStartsOrEndsOnCR(aNode, true);
   return res;
 }
 nsresult
 nsHTMLEditRules::AlignBlock(nsIDOMElement * aElement, const nsAString * aAlignType, bool aContentsOnly)
 {
   NS_ENSURE_TRUE(aElement, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIDOMNode> node = do_QueryInterface(aElement);
   bool isBlock = IsBlockNode(node);
   if (!isBlock && !nsHTMLEditUtils::IsHR(node)) {
     // we deal only with blocks; early way out
     return NS_OK;
   }
   nsresult res = RemoveAlignment(node, *aAlignType, aContentsOnly);
   NS_ENSURE_SUCCESS(res, res);
   NS_NAMED_LITERAL_STRING(attr, "align");
   NS_ENSURE_STATE(mHTMLEditor);
   if (mHTMLEditor->IsCSSEnabled()) {
     // let's use CSS alignment; we use margin-left and margin-right for tables
     // and text-align for other block-level elements
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->SetAttributeOrEquivalent(aElement, attr, *aAlignType, false);
     NS_ENSURE_SUCCESS(res, res);
   }
   else {
     // HTML case; this code is supposed to be called ONLY if the element
     // supports the align attribute but we'll never know...
     if (nsHTMLEditUtils::SupportsAlignAttr(node)) {
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->SetAttribute(aElement, attr, *aAlignType);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   return NS_OK;
 }
 nsresult
 nsHTMLEditRules::RelativeChangeIndentationOfElementNode(nsIDOMNode *aNode, int8_t aRelativeChange)
 {
   NS_ENSURE_ARG_POINTER(aNode);
   if (aRelativeChange != 1 && aRelativeChange != -1) {
     return NS_ERROR_ILLEGAL_VALUE;
   }
   nsCOMPtr<nsIDOMElement> element = do_QueryInterface(aNode);
   if (!element) {
     return NS_OK;
   }
   NS_ENSURE_STATE(mHTMLEditor);
   nsIAtom* marginProperty = MarginPropertyAtomForIndent(mHTMLEditor->mHTMLCSSUtils, element);
   nsAutoString value;
   NS_ENSURE_STATE(mHTMLEditor);
   mHTMLEditor->mHTMLCSSUtils->GetSpecifiedProperty(aNode, marginProperty, value);
   float f;
   nsCOMPtr<nsIAtom> unit;
   NS_ENSURE_STATE(mHTMLEditor);
   mHTMLEditor->mHTMLCSSUtils->ParseLength(value, &f, getter_AddRefs(unit));
   if (0 == f) {
     nsAutoString defaultLengthUnit;
     NS_ENSURE_STATE(mHTMLEditor);
     mHTMLEditor->mHTMLCSSUtils->GetDefaultLengthUnit(defaultLengthUnit);
     unit = do_GetAtom(defaultLengthUnit);
   }
   if      (nsEditProperty::cssInUnit == unit)
             f += NS_EDITOR_INDENT_INCREMENT_IN * aRelativeChange;
   else if (nsEditProperty::cssCmUnit == unit)
             f += NS_EDITOR_INDENT_INCREMENT_CM * aRelativeChange;
   else if (nsEditProperty::cssMmUnit == unit)
             f += NS_EDITOR_INDENT_INCREMENT_MM * aRelativeChange;
   else if (nsEditProperty::cssPtUnit == unit)
             f += NS_EDITOR_INDENT_INCREMENT_PT * aRelativeChange;
   else if (nsEditProperty::cssPcUnit == unit)
             f += NS_EDITOR_INDENT_INCREMENT_PC * aRelativeChange;
   else if (nsEditProperty::cssEmUnit == unit)
             f += NS_EDITOR_INDENT_INCREMENT_EM * aRelativeChange;
   else if (nsEditProperty::cssExUnit == unit)
             f += NS_EDITOR_INDENT_INCREMENT_EX * aRelativeChange;
   else if (nsEditProperty::cssPxUnit == unit)
             f += NS_EDITOR_INDENT_INCREMENT_PX * aRelativeChange;
   else if (nsEditProperty::cssPercentUnit == unit)
             f += NS_EDITOR_INDENT_INCREMENT_PERCENT * aRelativeChange;
   if (0 < f) {
     nsAutoString newValue;
     newValue.AppendFloat(f);
     newValue.Append(nsDependentAtomString(unit));
     NS_ENSURE_STATE(mHTMLEditor);
     mHTMLEditor->mHTMLCSSUtils->SetCSSProperty(element, marginProperty, newValue, false);
     return NS_OK;
   }
   NS_ENSURE_STATE(mHTMLEditor);
   mHTMLEditor->mHTMLCSSUtils->RemoveCSSProperty(element, marginProperty, value, false);
   // remove unnecessary DIV blocks:
   // we could skip this section but that would cause a FAIL in
   // editor/libeditor/html/tests/browserscope/richtext.html, which expects
   // to unapply a CSS "indent" (<div style="margin-left: 40px;">) by
   // removing the DIV container instead of just removing the CSS property.
   nsCOMPtr<dom::Element> node = do_QueryInterface(aNode);
   if (!node || !node->IsHTML(nsGkAtoms::div) ||
       !mHTMLEditor ||
       node == mHTMLEditor->GetActiveEditingHost() ||
       !mHTMLEditor->IsDescendantOfEditorRoot(node) ||
       nsHTMLEditor::HasAttributes(node)) {
     NS_ENSURE_STATE(mHTMLEditor);
     return NS_OK;
   }
   NS_ENSURE_STATE(mHTMLEditor);
   return mHTMLEditor->RemoveContainer(element);
 }
 //
 // Support for Absolute Positioning
 //
 nsresult
 nsHTMLEditRules::WillAbsolutePosition(Selection* aSelection,
                                       bool* aCancel, bool* aHandled)
 {
   if (!aSelection || !aCancel || !aHandled) { return NS_ERROR_NULL_POINTER; }
   nsresult res = WillInsert(aSelection, aCancel);
   NS_ENSURE_SUCCESS(res, res);
   // initialize out param
   // we want to ignore result of WillInsert()
   *aCancel = false;
   *aHandled = true;
   nsCOMPtr<nsIDOMElement> focusElement;
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetSelectionContainer(getter_AddRefs(focusElement));
   if (focusElement) {
     nsCOMPtr<nsIDOMNode> node = do_QueryInterface(focusElement);
     if (nsHTMLEditUtils::IsImage(node)) {
       mNewBlock = node;
       return NS_OK;
     }
   }
   res = NormalizeSelection(aSelection);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_STATE(mHTMLEditor);
   nsAutoSelectionReset selectionResetter(aSelection, mHTMLEditor);
   // convert the selection ranges into "promoted" selection ranges:
   // this basically just expands the range to include the immediate
   // block parent, and then further expands to include any ancestors
   // whose children are all in the range
   nsCOMArray<nsIDOMRange> arrayOfRanges;
   res = GetPromotedRanges(aSelection, arrayOfRanges,
                           EditAction::setAbsolutePosition);
   NS_ENSURE_SUCCESS(res, res);
   // use these ranges to contruct a list of nodes to act on.
   nsCOMArray<nsIDOMNode> arrayOfNodes;
   res = GetNodesForOperation(arrayOfRanges, arrayOfNodes,
                              EditAction::setAbsolutePosition);
   NS_ENSURE_SUCCESS(res, res);
   NS_NAMED_LITERAL_STRING(divType, "div");
   // if nothing visible in list, make an empty block
   if (ListIsEmptyLine(arrayOfNodes))
   {
     nsCOMPtr<nsIDOMNode> parent, thePositionedDiv;
     int32_t offset;
     // get selection location
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(parent), &offset);
     NS_ENSURE_SUCCESS(res, res);
     // make sure we can put a block here
     res = SplitAsNeeded(&divType, address_of(parent), &offset);
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->CreateNode(divType, parent, offset, getter_AddRefs(thePositionedDiv));
     NS_ENSURE_SUCCESS(res, res);
     // remember our new block for postprocessing
     mNewBlock = thePositionedDiv;
     // delete anything that was in the list of nodes
     for (int32_t j = arrayOfNodes.Count() - 1; j >= 0; --j)
     {
       nsCOMPtr<nsIDOMNode> curNode = arrayOfNodes[0];
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->DeleteNode(curNode);
       NS_ENSURE_SUCCESS(res, res);
       arrayOfNodes.RemoveObjectAt(0);
     }
     // put selection in new block
     res = aSelection->Collapse(thePositionedDiv,0);
     selectionResetter.Abort();  // to prevent selection reseter from overriding us.
     *aHandled = true;
     return res;
   }
   // Ok, now go through all the nodes and put them in a blockquote,
   // or whatever is appropriate.  Wohoo!
   int32_t i;
   nsCOMPtr<nsIDOMNode> curParent, curPositionedDiv, curList, indentedLI, sibling;
   int32_t listCount = arrayOfNodes.Count();
   for (i=0; i<listCount; i++)
   {
     // here's where we actually figure out what to do
     nsCOMPtr<nsIDOMNode> curNode = arrayOfNodes[i];
     // Ignore all non-editable nodes.  Leave them be.
     NS_ENSURE_STATE(mHTMLEditor);
     if (!mHTMLEditor->IsEditable(curNode)) continue;
     int32_t offset;
     curParent = nsEditor::GetNodeLocation(curNode, &offset);
     // some logic for putting list items into nested lists...
     if (nsHTMLEditUtils::IsList(curParent))
     {
       // check to see if curList is still appropriate.  Which it is if
       // curNode is still right after it in the same list.
       if (curList)
       {
         sibling = nullptr;
         NS_ENSURE_STATE(mHTMLEditor);
         mHTMLEditor->GetPriorHTMLSibling(curNode, address_of(sibling));
       }
       if (!curList || (sibling && sibling != curList) )
       {
         nsAutoString listTag;
         nsEditor::GetTagString(curParent,listTag);
         ToLowerCase(listTag);
         // create a new nested list of correct type
         res = SplitAsNeeded(&listTag, address_of(curParent), &offset);
         NS_ENSURE_SUCCESS(res, res);
         if (!curPositionedDiv) {
           int32_t parentOffset;
           nsCOMPtr<nsIDOMNode> curParentParent = nsEditor::GetNodeLocation(curParent, &parentOffset);
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->CreateNode(divType, curParentParent, parentOffset, getter_AddRefs(curPositionedDiv));
           mNewBlock = curPositionedDiv;
         }
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->CreateNode(listTag, curPositionedDiv, -1, getter_AddRefs(curList));
         NS_ENSURE_SUCCESS(res, res);
         // curList is now the correct thing to put curNode in
         // remember our new block for postprocessing
         // mNewBlock = curList;
       }
       // tuck the node into the end of the active list
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->MoveNode(curNode, curList, -1);
       NS_ENSURE_SUCCESS(res, res);
       // forget curPositionedDiv, if any
       // curPositionedDiv = nullptr;
     }
     else // not a list item, use blockquote?
     {
       // if we are inside a list item, we don't want to blockquote, we want
       // to sublist the list item.  We may have several nodes listed in the
       // array of nodes to act on, that are in the same list item.  Since
       // we only want to indent that li once, we must keep track of the most
       // recent indented list item, and not indent it if we find another node
       // to act on that is still inside the same li.
       nsCOMPtr<nsIDOMNode> listitem=IsInListItem(curNode);
       if (listitem)
       {
         if (indentedLI == listitem) continue;  // already indented this list item
         curParent = nsEditor::GetNodeLocation(listitem, &offset);
         // check to see if curList is still appropriate.  Which it is if
         // curNode is still right after it in the same list.
         if (curList)
         {
           sibling = nullptr;
           NS_ENSURE_STATE(mHTMLEditor);
           mHTMLEditor->GetPriorHTMLSibling(curNode, address_of(sibling));
         }
         if (!curList || (sibling && sibling != curList) )
         {
           nsAutoString listTag;
           nsEditor::GetTagString(curParent,listTag);
           ToLowerCase(listTag);
           // create a new nested list of correct type
           res = SplitAsNeeded(&listTag, address_of(curParent), &offset);
           NS_ENSURE_SUCCESS(res, res);
           if (!curPositionedDiv) {
           int32_t parentOffset;
           nsCOMPtr<nsIDOMNode> curParentParent = nsEditor::GetNodeLocation(curParent, &parentOffset);
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->CreateNode(divType, curParentParent, parentOffset, getter_AddRefs(curPositionedDiv));
             mNewBlock = curPositionedDiv;
           }
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->CreateNode(listTag, curPositionedDiv, -1, getter_AddRefs(curList));
           NS_ENSURE_SUCCESS(res, res);
         }
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->MoveNode(listitem, curList, -1);
         NS_ENSURE_SUCCESS(res, res);
         // remember we indented this li
         indentedLI = listitem;
       }
       else
       {
         // need to make a div to put things in if we haven't already
         if (!curPositionedDiv)
         {
           if (nsHTMLEditUtils::IsDiv(curNode))
           {
             curPositionedDiv = curNode;
             mNewBlock = curPositionedDiv;
             curList = nullptr;
             continue;
           }
           res = SplitAsNeeded(&divType, address_of(curParent), &offset);
           NS_ENSURE_SUCCESS(res, res);
           NS_ENSURE_STATE(mHTMLEditor);
           res = mHTMLEditor->CreateNode(divType, curParent, offset, getter_AddRefs(curPositionedDiv));
           NS_ENSURE_SUCCESS(res, res);
           // remember our new block for postprocessing
           mNewBlock = curPositionedDiv;
           // curPositionedDiv is now the correct thing to put curNode in
         }
         // tuck the node into the end of the active blockquote
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->MoveNode(curNode, curPositionedDiv, -1);
         NS_ENSURE_SUCCESS(res, res);
         // forget curList, if any
         curList = nullptr;
       }
     }
   }
   return res;
 }
 nsresult
 nsHTMLEditRules::DidAbsolutePosition()
 {
   NS_ENSURE_STATE(mHTMLEditor);
   nsCOMPtr<nsIHTMLAbsPosEditor> absPosHTMLEditor = mHTMLEditor;
   nsCOMPtr<nsIDOMElement> elt = do_QueryInterface(mNewBlock);
   return absPosHTMLEditor->AbsolutelyPositionElement(elt, true);
 }
 nsresult
 nsHTMLEditRules::WillRemoveAbsolutePosition(Selection* aSelection,
                                             bool* aCancel, bool* aHandled) {
   if (!aSelection || !aCancel || !aHandled) { return NS_ERROR_NULL_POINTER; }
   nsresult res = WillInsert(aSelection, aCancel);
   NS_ENSURE_SUCCESS(res, res);
   // initialize out param
   // we want to ignore aCancel from WillInsert()
   *aCancel = false;
   *aHandled = true;
   nsCOMPtr<nsIDOMElement>  elt;
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetAbsolutelyPositionedSelectionContainer(getter_AddRefs(elt));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_STATE(mHTMLEditor);
   nsAutoSelectionReset selectionResetter(aSelection, mHTMLEditor);
   NS_ENSURE_STATE(mHTMLEditor);
   nsCOMPtr<nsIHTMLAbsPosEditor> absPosHTMLEditor = mHTMLEditor;
   return absPosHTMLEditor->AbsolutelyPositionElement(elt, false);
 }
 nsresult
 nsHTMLEditRules::WillRelativeChangeZIndex(Selection* aSelection,
                                           int32_t aChange,
                                           bool *aCancel,
                                           bool * aHandled)
 {
   if (!aSelection || !aCancel || !aHandled) { return NS_ERROR_NULL_POINTER; }
   nsresult res = WillInsert(aSelection, aCancel);
   NS_ENSURE_SUCCESS(res, res);
   // initialize out param
   // we want to ignore aCancel from WillInsert()
   *aCancel = false;
   *aHandled = true;
   nsCOMPtr<nsIDOMElement>  elt;
   NS_ENSURE_STATE(mHTMLEditor);
   res = mHTMLEditor->GetAbsolutelyPositionedSelectionContainer(getter_AddRefs(elt));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_STATE(mHTMLEditor);
   nsAutoSelectionReset selectionResetter(aSelection, mHTMLEditor);
   NS_ENSURE_STATE(mHTMLEditor);
   nsCOMPtr<nsIHTMLAbsPosEditor> absPosHTMLEditor = mHTMLEditor;
   int32_t zIndex;
   return absPosHTMLEditor->RelativeChangeElementZIndex(elt, aChange, &zIndex);
 }
 NS_IMETHODIMP
 nsHTMLEditRules::DocumentModified()
 {
   nsContentUtils::AddScriptRunner(NS_NewRunnableMethod(this, &nsHTMLEditRules::DocumentModifiedWorker));
   return NS_OK;
 }
 void
 nsHTMLEditRules::DocumentModifiedWorker()
 {
   if (!mHTMLEditor) {
     return;
   }
   // DeleteNode below may cause a flush, which could destroy the editor
   nsAutoScriptBlockerSuppressNodeRemoved scriptBlocker;
   nsCOMPtr<nsIHTMLEditor> kungFuDeathGrip(mHTMLEditor);
   nsCOMPtr<nsISelection> selection;
   nsresult rv = mHTMLEditor->GetSelection(getter_AddRefs(selection));
   if (NS_FAILED(rv)) {
     return;
   }
   // Delete our bogus node, if we have one, since the document might not be
   // empty any more.
   if (mBogusNode) {
     mEditor->DeleteNode(mBogusNode);
     mBogusNode = nullptr;
   }
   // Try to recreate the bogus node if needed.
   CreateBogusNodeIfNeeded(selection);
 }

The Tor Browser / annotate

editor/libeditor/html/nsHTMLEditRules.cpp@129ffea94266 (annotated)

editor/libeditor/html/nsHTMLEditRules.cpp