The Tor Browser: editor/libeditor/base/nsEditor.cpp@6474c204b198 (annotated)

editor/libeditor/base/nsEditor.cpp@6474c204b198 (annotated)

editor/libeditor/base/nsEditor.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "mozilla/DebugOnly.h"          // for DebugOnly
 #include <stdio.h>                      // for nullptr, stdout
 #include <string.h>                     // for strcmp
 #include "ChangeAttributeTxn.h"         // for ChangeAttributeTxn
 #include "CreateElementTxn.h"           // for CreateElementTxn
 #include "DeleteNodeTxn.h"              // for DeleteNodeTxn
 #include "DeleteRangeTxn.h"             // for DeleteRangeTxn
 #include "DeleteTextTxn.h"              // for DeleteTextTxn
 #include "EditAggregateTxn.h"           // for EditAggregateTxn
 #include "EditTxn.h"                    // for EditTxn
 #include "IMETextTxn.h"                 // for IMETextTxn
 #include "InsertElementTxn.h"           // for InsertElementTxn
 #include "InsertTextTxn.h"              // for InsertTextTxn
 #include "JoinElementTxn.h"             // for JoinElementTxn
 #include "PlaceholderTxn.h"             // for PlaceholderTxn
 #include "SplitElementTxn.h"            // for SplitElementTxn
 #include "mozFlushType.h"               // for mozFlushType::Flush_Frames
 #include "mozISpellCheckingEngine.h"
 #include "mozInlineSpellChecker.h"      // for mozInlineSpellChecker
 #include "mozilla/IMEStateManager.h"    // for IMEStateManager
 #include "mozilla/Preferences.h"        // for Preferences
 #include "mozilla/dom/Selection.h"      // for Selection, etc
 #include "mozilla/Services.h"           // for GetObserverService
 #include "mozilla/TextComposition.h"    // for TextComposition
 #include "mozilla/TextEvents.h"
 #include "mozilla/dom/Element.h"        // for Element, nsINode::AsElement
 #include "mozilla/mozalloc.h"           // for operator new, etc
 #include "nsAString.h"                  // for nsAString_internal::Length, etc
 #include "nsCCUncollectableMarker.h"    // for nsCCUncollectableMarker
 #include "nsCaret.h"                    // for nsCaret
 #include "nsCaseTreatment.h"
 #include "nsCharTraits.h"               // for NS_IS_HIGH_SURROGATE, etc
 #include "nsComponentManagerUtils.h"    // for do_CreateInstance
 #include "nsComputedDOMStyle.h"         // for nsComputedDOMStyle
 #include "nsContentUtils.h"             // for nsContentUtils
 #include "nsDOMString.h"                // for DOMStringIsNull
 #include "nsDebug.h"                    // for NS_ENSURE_TRUE, etc
 #include "nsEditProperty.h"             // for nsEditProperty, etc
 #include "nsEditor.h"
 #include "nsEditorEventListener.h"      // for nsEditorEventListener
 #include "nsEditorUtils.h"              // for nsAutoRules, etc
 #include "nsError.h"                    // for NS_OK, etc
 #include "nsFocusManager.h"             // for nsFocusManager
 #include "nsFrameSelection.h"           // for nsFrameSelection
 #include "nsGkAtoms.h"                  // for nsGkAtoms, nsGkAtoms::dir
 #include "nsIAbsorbingTransaction.h"    // for nsIAbsorbingTransaction
 #include "nsIAtom.h"                    // for nsIAtom
 #include "nsIContent.h"                 // for nsIContent
 #include "nsIDOMAttr.h"                 // for nsIDOMAttr
 #include "nsIDOMCharacterData.h"        // for nsIDOMCharacterData
 #include "nsIDOMDocument.h"             // for nsIDOMDocument
 #include "nsIDOMElement.h"              // for nsIDOMElement
 #include "nsIDOMEvent.h"                // for nsIDOMEvent
 #include "nsIDOMEventListener.h"        // for nsIDOMEventListener
 #include "nsIDOMEventTarget.h"          // for nsIDOMEventTarget
 #include "nsIDOMHTMLElement.h"          // for nsIDOMHTMLElement
 #include "nsIDOMKeyEvent.h"             // for nsIDOMKeyEvent, etc
 #include "nsIDOMMozNamedAttrMap.h"      // for nsIDOMMozNamedAttrMap
 #include "nsIDOMMouseEvent.h"           // for nsIDOMMouseEvent
 #include "nsIDOMNode.h"                 // for nsIDOMNode, etc
 #include "nsIDOMNodeList.h"             // for nsIDOMNodeList
 #include "nsIDOMRange.h"                // for nsIDOMRange
 #include "nsIDOMText.h"                 // for nsIDOMText
 #include "nsIDocument.h"                // for nsIDocument
 #include "nsIDocumentStateListener.h"   // for nsIDocumentStateListener
 #include "nsIEditActionListener.h"      // for nsIEditActionListener
 #include "nsIEditorObserver.h"          // for nsIEditorObserver
 #include "nsIEditorSpellCheck.h"        // for nsIEditorSpellCheck
 #include "nsIFrame.h"                   // for nsIFrame
 #include "nsIHTMLDocument.h"            // for nsIHTMLDocument
 #include "nsIInlineSpellChecker.h"      // for nsIInlineSpellChecker, etc
 #include "nsNameSpaceManager.h"        // for kNameSpaceID_None, etc
 #include "nsINode.h"                    // for nsINode, etc
 #include "nsIObserverService.h"         // for nsIObserverService
 #include "nsIPlaintextEditor.h"         // for nsIPlaintextEditor, etc
 #include "nsIPresShell.h"               // for nsIPresShell
 #include "nsISelection.h"               // for nsISelection, etc
 #include "nsISelectionController.h"     // for nsISelectionController, etc
 #include "nsISelectionDisplay.h"        // for nsISelectionDisplay, etc
 #include "nsISelectionPrivate.h"        // for nsISelectionPrivate, etc
 #include "nsISupportsBase.h"            // for nsISupports
 #include "nsISupportsUtils.h"           // for NS_ADDREF, NS_IF_ADDREF
 #include "nsITransaction.h"             // for nsITransaction
 #include "nsITransactionManager.h"
 #include "nsIWeakReference.h"           // for nsISupportsWeakReference
 #include "nsIWidget.h"                  // for nsIWidget, IMEState, etc
 #include "nsPIDOMWindow.h"              // for nsPIDOMWindow
 #include "nsPresContext.h"              // for nsPresContext
 #include "nsRange.h"                    // for nsRange
 #include "nsReadableUtils.h"            // for EmptyString, ToNewCString
 #include "nsString.h"                   // for nsAutoString, nsString, etc
 #include "nsStringFwd.h"                // for nsAFlatString
 #include "nsStyleConsts.h"              // for NS_STYLE_DIRECTION_RTL, etc
 #include "nsStyleContext.h"             // for nsStyleContext
 #include "nsStyleSheetTxns.h"           // for AddStyleSheetTxn, etc
 #include "nsStyleStruct.h"              // for nsStyleDisplay, nsStyleText, etc
 #include "nsStyleStructFwd.h"           // for nsIFrame::StyleUIReset, etc
 #include "nsTextEditUtils.h"            // for nsTextEditUtils
 #include "nsTextNode.h"                 // for nsTextNode
 #include "nsThreadUtils.h"              // for nsRunnable
 #include "nsTransactionManager.h"       // for nsTransactionManager
 #include "prtime.h"                     // for PR_Now
 class nsIOutputStream;
 class nsIParserService;
 class nsITransferable;
 #ifdef DEBUG
 #include "nsIDOMHTMLDocument.h"         // for nsIDOMHTMLDocument
 #endif
 using namespace mozilla;
 using namespace mozilla::dom;
 using namespace mozilla::widget;
 // Defined in nsEditorRegistration.cpp
 extern nsIParserService *sParserService;
 //---------------------------------------------------------------------------
 //
 // nsEditor: base editor class implementation
 //
 //---------------------------------------------------------------------------
 nsEditor::nsEditor()
 :  mPlaceHolderName(nullptr)
 ,  mSelState(nullptr)
 ,  mPhonetic(nullptr)
 ,  mModCount(0)
 ,  mFlags(0)
 ,  mUpdateCount(0)
 ,  mPlaceHolderBatch(0)
 ,  mAction(EditAction::none)
 ,  mIMETextOffset(0)
 ,  mDirection(eNone)
 ,  mDocDirtyState(-1)
 ,  mSpellcheckCheckboxState(eTriUnset)
 ,  mShouldTxnSetSelection(true)
 ,  mDidPreDestroy(false)
 ,  mDidPostCreate(false)
 ,  mDispatchInputEvent(true)
 {
 }
 nsEditor::~nsEditor()
 {
   NS_ASSERTION(!mDocWeak || mDidPreDestroy, "Why PreDestroy hasn't been called?");
   mTxnMgr = nullptr;
   delete mPhonetic;
 }
 NS_IMPL_CYCLE_COLLECTION_CLASS(nsEditor)
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsEditor)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mRootElement)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mInlineSpellChecker)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mTxnMgr)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mIMETextNode)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mActionListeners)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mEditorObservers)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocStateListeners)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mEventTarget)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mEventListener)
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsEditor)
  nsIDocument* currentDoc =
    tmp->mRootElement ? tmp->mRootElement->GetCurrentDoc() : nullptr;
  if (currentDoc &&
      nsCCUncollectableMarker::InGeneration(cb, currentDoc->GetMarkedCCGeneration())) {
    return NS_SUCCESS_INTERRUPTED_TRAVERSE;
  }
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRootElement)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mInlineSpellChecker)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTxnMgr)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mIMETextNode)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mActionListeners)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEditorObservers)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocStateListeners)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEventTarget)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEventListener)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsEditor)
  NS_INTERFACE_MAP_ENTRY(nsIPhonetic)
  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
  NS_INTERFACE_MAP_ENTRY(nsIEditorIMESupport)
  NS_INTERFACE_MAP_ENTRY(nsIEditor)
  NS_INTERFACE_MAP_ENTRY(nsIObserver)
  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIEditor)
 NS_INTERFACE_MAP_END
 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsEditor)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsEditor)
 NS_IMETHODIMP
 nsEditor::Init(nsIDOMDocument *aDoc, nsIContent *aRoot,
                nsISelectionController *aSelCon, uint32_t aFlags,
                const nsAString& aValue)
 {
   NS_PRECONDITION(aDoc, "bad arg");
   if (!aDoc)
     return NS_ERROR_NULL_POINTER;
   // First only set flags, but other stuff shouldn't be initialized now.
   // Don't move this call after initializing mDocWeak.
   // SetFlags() can check whether it's called during initialization or not by
   // them.  Note that SetFlags() will be called by PostCreate().
 #ifdef DEBUG
   nsresult rv =
 #endif
   SetFlags(aFlags);
   NS_ASSERTION(NS_SUCCEEDED(rv), "SetFlags() failed");
   mDocWeak = do_GetWeakReference(aDoc);  // weak reference to doc
   // HTML editors currently don't have their own selection controller,
   // so they'll pass null as aSelCon, and we'll get the selection controller
   // off of the presshell.
   nsCOMPtr<nsISelectionController> selCon;
   if (aSelCon) {
     mSelConWeak = do_GetWeakReference(aSelCon);   // weak reference to selectioncontroller
     selCon = aSelCon;
   } else {
     nsCOMPtr<nsIPresShell> presShell = GetPresShell();
     selCon = do_QueryInterface(presShell);
   }
   NS_ASSERTION(selCon, "Selection controller should be available at this point");
   //set up root element if we are passed one.
   if (aRoot)
     mRootElement = do_QueryInterface(aRoot);
   mUpdateCount=0;
   /* initialize IME stuff */
   mIMETextNode = nullptr;
   mIMETextOffset = 0;
   /* Show the caret */
   selCon->SetCaretReadOnly(false);
   selCon->SetDisplaySelection(nsISelectionController::SELECTION_ON);
   selCon->SetSelectionFlags(nsISelectionDisplay::DISPLAY_ALL);//we want to see all the selection reflected to user
   NS_POSTCONDITION(mDocWeak, "bad state");
   // Make sure that the editor will be destroyed properly
   mDidPreDestroy = false;
   // Make sure that the ediotr will be created properly
   mDidPostCreate = false;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::PostCreate()
 {
   // Synchronize some stuff for the flags.  SetFlags() will initialize
   // something by the flag difference.  This is first time of that, so, all
   // initializations must be run.  For such reason, we need to invert mFlags
   // value first.
   mFlags = ~mFlags;
   nsresult rv = SetFlags(~mFlags);
   NS_ENSURE_SUCCESS(rv, rv);
   // These operations only need to happen on the first PostCreate call
   if (!mDidPostCreate) {
     mDidPostCreate = true;
     // Set up listeners
     CreateEventListeners();
     rv = InstallEventListeners();
     NS_ENSURE_SUCCESS(rv, rv);
     // nuke the modification count, so the doc appears unmodified
     // do this before we notify listeners
     ResetModificationCount();
     // update the UI with our state
     NotifyDocumentListeners(eDocumentCreated);
     NotifyDocumentListeners(eDocumentStateChanged);
     nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
     if (obs) {
       obs->AddObserver(this,
                        SPELLCHECK_DICTIONARY_UPDATE_NOTIFICATION,
                        false);
     }
   }
   // update nsTextStateManager and caret if we have focus
   nsCOMPtr<nsIContent> focusedContent = GetFocusedContent();
   if (focusedContent) {
     nsCOMPtr<nsIDOMEventTarget> target = do_QueryInterface(focusedContent);
     if (target) {
       InitializeSelection(target);
     }
     // If the text control gets reframed during focus, Focus() would not be
     // called, so take a chance here to see if we need to spell check the text
     // control.
     nsEditorEventListener* listener =
       reinterpret_cast<nsEditorEventListener*> (mEventListener.get());
     listener->SpellCheckIfNeeded();
     IMEState newState;
     rv = GetPreferredIMEState(&newState);
     NS_ENSURE_SUCCESS(rv, NS_OK);
     nsCOMPtr<nsIContent> content = GetFocusedContentForIME();
     IMEStateManager::UpdateIMEState(newState, content);
   }
   return NS_OK;
 }
 /* virtual */
 void
 nsEditor::CreateEventListeners()
 {
   // Don't create the handler twice
   if (!mEventListener) {
     mEventListener = new nsEditorEventListener();
   }
 }
 nsresult
 nsEditor::InstallEventListeners()
 {
   NS_ENSURE_TRUE(mDocWeak && mEventListener,
                  NS_ERROR_NOT_INITIALIZED);
   // Initialize the event target.
   nsCOMPtr<nsIContent> rootContent = GetRoot();
   NS_ENSURE_TRUE(rootContent, NS_ERROR_NOT_AVAILABLE);
   mEventTarget = do_QueryInterface(rootContent->GetParent());
   NS_ENSURE_TRUE(mEventTarget, NS_ERROR_NOT_AVAILABLE);
   nsEditorEventListener* listener =
     reinterpret_cast<nsEditorEventListener*>(mEventListener.get());
   return listener->Connect(this);
 }
 void
 nsEditor::RemoveEventListeners()
 {
   if (!mDocWeak || !mEventListener) {
     return;
   }
   reinterpret_cast<nsEditorEventListener*>(mEventListener.get())->Disconnect();
   if (mComposition) {
     mComposition->EndHandlingComposition(this);
     mComposition = nullptr;
   }
   mEventTarget = nullptr;
 }
 bool
 nsEditor::GetDesiredSpellCheckState()
 {
   // Check user override on this element
   if (mSpellcheckCheckboxState != eTriUnset) {
     return (mSpellcheckCheckboxState == eTriTrue);
   }
   // Check user preferences
   int32_t spellcheckLevel = Preferences::GetInt("layout.spellcheckDefault", 1);
   if (spellcheckLevel == 0) {
     return false;                    // Spellchecking forced off globally
   }
   if (!CanEnableSpellCheck()) {
     return false;
   }
   nsCOMPtr<nsIPresShell> presShell = GetPresShell();
   if (presShell) {
     nsPresContext* context = presShell->GetPresContext();
     if (context && !context->IsDynamic()) {
       return false;
     }
   }
   // Check DOM state
   nsCOMPtr<nsIContent> content = GetExposedRoot();
   if (!content) {
     return false;
   }
   nsCOMPtr<nsIDOMHTMLElement> element = do_QueryInterface(content);
   if (!element) {
     return false;
   }
   if (!IsPlaintextEditor()) {
     // Some of the page content might be editable and some not, if spellcheck=
     // is explicitly set anywhere, so if there's anything editable on the page,
     // return true and let the spellchecker figure it out.
     nsCOMPtr<nsIHTMLDocument> doc = do_QueryInterface(content->GetCurrentDoc());
     return doc && doc->IsEditingOn();
   }
   bool enable;
   element->GetSpellcheck(&enable);
   return enable;
 }
 NS_IMETHODIMP
 nsEditor::PreDestroy(bool aDestroyingFrames)
 {
   if (mDidPreDestroy)
     return NS_OK;
   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
   if (obs) {
     obs->RemoveObserver(this,
                         SPELLCHECK_DICTIONARY_UPDATE_NOTIFICATION);
   }
   // Let spellchecker clean up its observers etc. It is important not to
   // actually free the spellchecker here, since the spellchecker could have
   // caused flush notifications, which could have gotten here if a textbox
   // is being removed. Setting the spellchecker to nullptr could free the
   // object that is still in use! It will be freed when the editor is
   // destroyed.
   if (mInlineSpellChecker)
     mInlineSpellChecker->Cleanup(aDestroyingFrames);
   // tell our listeners that the doc is going away
   NotifyDocumentListeners(eDocumentToBeDestroyed);
   // Unregister event listeners
   RemoveEventListeners();
   mActionListeners.Clear();
   mEditorObservers.Clear();
   mDocStateListeners.Clear();
   mInlineSpellChecker = nullptr;
   mSpellcheckCheckboxState = eTriUnset;
   mRootElement = nullptr;
   mDidPreDestroy = true;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::GetFlags(uint32_t *aFlags)
 {
   *aFlags = mFlags;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::SetFlags(uint32_t aFlags)
 {
   if (mFlags == aFlags) {
     return NS_OK;
   }
   bool spellcheckerWasEnabled = CanEnableSpellCheck();
   mFlags = aFlags;
   if (!mDocWeak) {
     // If we're initializing, we shouldn't do anything now.
     // SetFlags() will be called by PostCreate(),
     // we should synchronize some stuff for the flags at that time.
     return NS_OK;
   }
   // The flag change may cause the spellchecker state change
   if (CanEnableSpellCheck() != spellcheckerWasEnabled) {
     nsresult rv = SyncRealTimeSpell();
     NS_ENSURE_SUCCESS(rv, rv);
   }
   // If this is called from PostCreate(), it will update the IME state if it's
   // necessary.
   if (!mDidPostCreate) {
     return NS_OK;
   }
   // Might be changing editable state, so, we need to reset current IME state
   // if we're focused and the flag change causes IME state change.
   nsCOMPtr<nsIContent> focusedContent = GetFocusedContent();
   if (focusedContent) {
     IMEState newState;
     nsresult rv = GetPreferredIMEState(&newState);
     if (NS_SUCCEEDED(rv)) {
       // NOTE: When the enabled state isn't going to be modified, this method
       // is going to do nothing.
       nsCOMPtr<nsIContent> content = GetFocusedContentForIME();
       IMEStateManager::UpdateIMEState(newState, content);
     }
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::GetIsSelectionEditable(bool *aIsSelectionEditable)
 {
   NS_ENSURE_ARG_POINTER(aIsSelectionEditable);
   // get current selection
   nsCOMPtr<nsISelection> selection;
   nsresult res = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
   // XXX we just check that the anchor node is editable at the moment
   //     we should check that all nodes in the selection are editable
   nsCOMPtr<nsIDOMNode> anchorNode;
   selection->GetAnchorNode(getter_AddRefs(anchorNode));
   *aIsSelectionEditable = anchorNode && IsEditable(anchorNode);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::GetIsDocumentEditable(bool *aIsDocumentEditable)
 {
   NS_ENSURE_ARG_POINTER(aIsDocumentEditable);
   nsCOMPtr<nsIDOMDocument> doc = GetDOMDocument();
   *aIsDocumentEditable = !!doc;
   return NS_OK;
 }
 already_AddRefed<nsIDocument>
 nsEditor::GetDocument()
 {
   NS_PRECONDITION(mDocWeak, "bad state, mDocWeak weak pointer not initialized");
   nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
   return doc.forget();
 }
 already_AddRefed<nsIDOMDocument>
 nsEditor::GetDOMDocument()
 {
   NS_PRECONDITION(mDocWeak, "bad state, mDocWeak weak pointer not initialized");
   nsCOMPtr<nsIDOMDocument> doc = do_QueryReferent(mDocWeak);
   return doc.forget();
 }
 NS_IMETHODIMP
 nsEditor::GetDocument(nsIDOMDocument **aDoc)
 {
   nsCOMPtr<nsIDOMDocument> doc = GetDOMDocument();
   doc.forget(aDoc);
   return *aDoc ? NS_OK : NS_ERROR_NOT_INITIALIZED;
 }
 already_AddRefed<nsIPresShell>
 nsEditor::GetPresShell()
 {
   NS_PRECONDITION(mDocWeak, "bad state, null mDocWeak");
   nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
   NS_ENSURE_TRUE(doc, nullptr);
   nsCOMPtr<nsIPresShell> ps = doc->GetShell();
   return ps.forget();
 }
 already_AddRefed<nsIWidget>
 nsEditor::GetWidget()
 {
   nsCOMPtr<nsIPresShell> ps = GetPresShell();
   NS_ENSURE_TRUE(ps, nullptr);
   nsPresContext* pc = ps->GetPresContext();
   NS_ENSURE_TRUE(pc, nullptr);
   nsCOMPtr<nsIWidget> widget = pc->GetRootWidget();
   NS_ENSURE_TRUE(widget.get(), nullptr);
   return widget.forget();
 }
 /* attribute string contentsMIMEType; */
 NS_IMETHODIMP
 nsEditor::GetContentsMIMEType(char * *aContentsMIMEType)
 {
   NS_ENSURE_ARG_POINTER(aContentsMIMEType);
   *aContentsMIMEType = ToNewCString(mContentMIMEType);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::SetContentsMIMEType(const char * aContentsMIMEType)
 {
   mContentMIMEType.Assign(aContentsMIMEType ? aContentsMIMEType : "");
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::GetSelectionController(nsISelectionController **aSel)
 {
   NS_ENSURE_TRUE(aSel, NS_ERROR_NULL_POINTER);
   *aSel = nullptr; // init out param
   nsCOMPtr<nsISelectionController> selCon;
   if (mSelConWeak) {
     selCon = do_QueryReferent(mSelConWeak);
   } else {
     nsCOMPtr<nsIPresShell> presShell = GetPresShell();
     selCon = do_QueryInterface(presShell);
   }
   NS_ENSURE_TRUE(selCon, NS_ERROR_NOT_INITIALIZED);
   NS_ADDREF(*aSel = selCon);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::DeleteSelection(EDirection aAction, EStripWrappers aStripWrappers)
 {
   MOZ_ASSERT(aStripWrappers == eStrip || aStripWrappers == eNoStrip);
   return DeleteSelectionImpl(aAction, aStripWrappers);
 }
 NS_IMETHODIMP
 nsEditor::GetSelection(nsISelection **aSelection)
 {
   NS_ENSURE_TRUE(aSelection, NS_ERROR_NULL_POINTER);
   *aSelection = nullptr;
   nsCOMPtr<nsISelectionController> selcon;
   GetSelectionController(getter_AddRefs(selcon));
   NS_ENSURE_TRUE(selcon, NS_ERROR_NOT_INITIALIZED);
   return selcon->GetSelection(nsISelectionController::SELECTION_NORMAL, aSelection);  // does an addref
 }
 Selection*
 nsEditor::GetSelection()
 {
   nsCOMPtr<nsISelection> sel;
   nsresult res = GetSelection(getter_AddRefs(sel));
   NS_ENSURE_SUCCESS(res, nullptr);
   return static_cast<Selection*>(sel.get());
 }
 NS_IMETHODIMP
 nsEditor::DoTransaction(nsITransaction* aTxn)
 {
   if (mPlaceHolderBatch && !mPlaceHolderTxn) {
     nsCOMPtr<nsIAbsorbingTransaction> plcTxn = new PlaceholderTxn();
     // save off weak reference to placeholder txn
     mPlaceHolderTxn = do_GetWeakReference(plcTxn);
     plcTxn->Init(mPlaceHolderName, mSelState, this);
     // placeholder txn took ownership of this pointer
     mSelState = nullptr;
     // QI to an nsITransaction since that's what DoTransaction() expects
     nsCOMPtr<nsITransaction> theTxn = do_QueryInterface(plcTxn);
     // we will recurse, but will not hit this case in the nested call
     DoTransaction(theTxn);
     if (mTxnMgr) {
       nsCOMPtr<nsITransaction> topTxn = mTxnMgr->PeekUndoStack();
       if (topTxn) {
         plcTxn = do_QueryInterface(topTxn);
         if (plcTxn) {
           // there is a placeholder transaction on top of the undo stack.  It
           // is either the one we just created, or an earlier one that we are
           // now merging into.  From here on out remember this placeholder
           // instead of the one we just created.
           mPlaceHolderTxn = do_GetWeakReference(plcTxn);
         }
       }
     }
   }
   if (aTxn) {
     // XXX: Why are we doing selection specific batching stuff here?
     // XXX: Most entry points into the editor have auto variables that
     // XXX: should trigger Begin/EndUpdateViewBatch() calls that will make
     // XXX: these selection batch calls no-ops.
     // XXX:
     // XXX: I suspect that this was placed here to avoid multiple
     // XXX: selection changed notifications from happening until after
     // XXX: the transaction was done. I suppose that can still happen
     // XXX: if an embedding application called DoTransaction() directly
     // XXX: to pump its own transactions through the system, but in that
     // XXX: case, wouldn't we want to use Begin/EndUpdateViewBatch() or
     // XXX: its auto equivalent nsAutoUpdateViewBatch to ensure that
     // XXX: selection listeners have access to accurate frame data?
     // XXX:
     // XXX: Note that if we did add Begin/EndUpdateViewBatch() calls
     // XXX: we will need to make sure that they are disabled during
     // XXX: the init of the editor for text widgets to avoid layout
     // XXX: re-entry during initial reflow. - kin
     // get the selection and start a batch change
     nsRefPtr<Selection> selection = GetSelection();
     NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
     selection->StartBatchChanges();
     nsresult res;
     if (mTxnMgr) {
       res = mTxnMgr->DoTransaction(aTxn);
     } else {
       res = aTxn->DoTransaction();
     }
     if (NS_SUCCEEDED(res)) {
       DoAfterDoTransaction(aTxn);
     }
     // no need to check res here, don't lose result of operation
     selection->EndBatchChanges();
     NS_ENSURE_SUCCESS(res, res);
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::EnableUndo(bool aEnable)
 {
   if (aEnable) {
     if (!mTxnMgr) {
       mTxnMgr = new nsTransactionManager();
     }
     mTxnMgr->SetMaxTransactionCount(-1);
   } else if (mTxnMgr) {
     // disable the transaction manager if it is enabled
     mTxnMgr->Clear();
     mTxnMgr->SetMaxTransactionCount(0);
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::GetNumberOfUndoItems(int32_t* aNumItems)
 {
   *aNumItems = 0;
   return mTxnMgr ? mTxnMgr->GetNumberOfUndoItems(aNumItems) : NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::GetNumberOfRedoItems(int32_t* aNumItems)
 {
   *aNumItems = 0;
   return mTxnMgr ? mTxnMgr->GetNumberOfRedoItems(aNumItems) : NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::GetTransactionManager(nsITransactionManager* *aTxnManager)
 {
   NS_ENSURE_ARG_POINTER(aTxnManager);
   *aTxnManager = nullptr;
   NS_ENSURE_TRUE(mTxnMgr, NS_ERROR_FAILURE);
   NS_ADDREF(*aTxnManager = mTxnMgr);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::SetTransactionManager(nsITransactionManager *aTxnManager)
 {
   NS_ENSURE_TRUE(aTxnManager, NS_ERROR_FAILURE);
   // nsITransactionManager is builtinclass, so this is safe
   mTxnMgr = static_cast<nsTransactionManager*>(aTxnManager);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::Undo(uint32_t aCount)
 {
   ForceCompositionEnd();
   bool hasTxnMgr, hasTransaction = false;
   CanUndo(&hasTxnMgr, &hasTransaction);
   NS_ENSURE_TRUE(hasTransaction, NS_OK);
   nsAutoRules beginRulesSniffing(this, EditAction::undo, nsIEditor::eNone);
   if (!mTxnMgr) {
     return NS_OK;
   }
   for (uint32_t i = 0; i < aCount; ++i) {
     nsresult rv = mTxnMgr->UndoTransaction();
     NS_ENSURE_SUCCESS(rv, rv);
     DoAfterUndoTransaction();
   }
   return NS_OK;
 }
 NS_IMETHODIMP nsEditor::CanUndo(bool *aIsEnabled, bool *aCanUndo)
 {
   NS_ENSURE_TRUE(aIsEnabled && aCanUndo, NS_ERROR_NULL_POINTER);
   *aIsEnabled = !!mTxnMgr;
   if (*aIsEnabled) {
     int32_t numTxns = 0;
     mTxnMgr->GetNumberOfUndoItems(&numTxns);
     *aCanUndo = !!numTxns;
   } else {
     *aCanUndo = false;
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::Redo(uint32_t aCount)
 {
   bool hasTxnMgr, hasTransaction = false;
   CanRedo(&hasTxnMgr, &hasTransaction);
   NS_ENSURE_TRUE(hasTransaction, NS_OK);
   nsAutoRules beginRulesSniffing(this, EditAction::redo, nsIEditor::eNone);
   if (!mTxnMgr) {
     return NS_OK;
   }
   for (uint32_t i = 0; i < aCount; ++i) {
     nsresult rv = mTxnMgr->RedoTransaction();
     NS_ENSURE_SUCCESS(rv, rv);
     DoAfterRedoTransaction();
   }
   return NS_OK;
 }
 NS_IMETHODIMP nsEditor::CanRedo(bool *aIsEnabled, bool *aCanRedo)
 {
   NS_ENSURE_TRUE(aIsEnabled && aCanRedo, NS_ERROR_NULL_POINTER);
   *aIsEnabled = !!mTxnMgr;
   if (*aIsEnabled) {
     int32_t numTxns = 0;
     mTxnMgr->GetNumberOfRedoItems(&numTxns);
     *aCanRedo = !!numTxns;
   } else {
     *aCanRedo = false;
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::BeginTransaction()
 {
   BeginUpdateViewBatch();
   if (mTxnMgr) {
     mTxnMgr->BeginBatch(nullptr);
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::EndTransaction()
 {
   if (mTxnMgr) {
     mTxnMgr->EndBatch(false);
   }
   EndUpdateViewBatch();
   return NS_OK;
 }
 // These two routines are similar to the above, but do not use
 // the transaction managers batching feature.  Instead we use
 // a placeholder transaction to wrap up any further transaction
 // while the batch is open.  The advantage of this is that
 // placeholder transactions can later merge, if needed.  Merging
 // is unavailable between transaction manager batches.
 NS_IMETHODIMP
 nsEditor::BeginPlaceHolderTransaction(nsIAtom *aName)
 {
   NS_PRECONDITION(mPlaceHolderBatch >= 0, "negative placeholder batch count!");
   if (!mPlaceHolderBatch)
   {
     // time to turn on the batch
     BeginUpdateViewBatch();
     mPlaceHolderTxn = nullptr;
     mPlaceHolderName = aName;
     nsRefPtr<Selection> selection = GetSelection();
     if (selection) {
       mSelState = new nsSelectionState();
       mSelState->SaveSelection(selection);
     }
   }
   mPlaceHolderBatch++;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::EndPlaceHolderTransaction()
 {
   NS_PRECONDITION(mPlaceHolderBatch > 0, "zero or negative placeholder batch count when ending batch!");
   if (mPlaceHolderBatch == 1)
   {
     nsCOMPtr<nsISelection>selection;
     GetSelection(getter_AddRefs(selection));
     nsCOMPtr<nsISelectionPrivate>selPrivate(do_QueryInterface(selection));
     // By making the assumption that no reflow happens during the calls
     // to EndUpdateViewBatch and ScrollSelectionIntoView, we are able to
     // allow the selection to cache a frame offset which is used by the
     // caret drawing code. We only enable this cache here; at other times,
     // we have no way to know whether reflow invalidates it
     // See bugs 35296 and 199412.
     if (selPrivate) {
       selPrivate->SetCanCacheFrameOffset(true);
     }
     {
       // Hide the caret here to avoid hiding it twice, once in EndUpdateViewBatch
       // and once in ScrollSelectionIntoView.
       nsRefPtr<nsCaret> caret;
       nsCOMPtr<nsIPresShell> presShell = GetPresShell();
       if (presShell)
         caret = presShell->GetCaret();
       // time to turn off the batch
       EndUpdateViewBatch();
       // make sure selection is in view
       // After ScrollSelectionIntoView(), the pending notifications might be
       // flushed and PresShell/PresContext/Frames may be dead. See bug 418470.
       ScrollSelectionIntoView(false);
     }
     // cached for frame offset are Not available now
     if (selPrivate) {
       selPrivate->SetCanCacheFrameOffset(false);
     }
     if (mSelState)
     {
       // we saved the selection state, but never got to hand it to placeholder
       // (else we ould have nulled out this pointer), so destroy it to prevent leaks.
       delete mSelState;
       mSelState = nullptr;
     }
     if (mPlaceHolderTxn)  // we might have never made a placeholder if no action took place
     {
       nsCOMPtr<nsIAbsorbingTransaction> plcTxn = do_QueryReferent(mPlaceHolderTxn);
       if (plcTxn)
       {
         plcTxn->EndPlaceHolderBatch();
       }
       else
       {
         // in the future we will check to make sure undo is off here,
         // since that is the only known case where the placeholdertxn would disappear on us.
         // For now just removing the assert.
       }
       // notify editor observers of action but if composing, it's done by
       // text event handler.
       if (!mComposition) {
         NotifyEditorObservers();
       }
     }
   }
   mPlaceHolderBatch--;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::ShouldTxnSetSelection(bool *aResult)
 {
   NS_ENSURE_TRUE(aResult, NS_ERROR_NULL_POINTER);
   *aResult = mShouldTxnSetSelection;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::SetShouldTxnSetSelection(bool aShould)
 {
   mShouldTxnSetSelection = aShould;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::GetDocumentIsEmpty(bool *aDocumentIsEmpty)
 {
   *aDocumentIsEmpty = true;
   dom::Element* root = GetRoot();
   NS_ENSURE_TRUE(root, NS_ERROR_NULL_POINTER);
   *aDocumentIsEmpty = !root->HasChildren();
   return NS_OK;
 }
 // XXX: the rule system should tell us which node to select all on (ie, the root, or the body)
 NS_IMETHODIMP nsEditor::SelectAll()
 {
   if (!mDocWeak) { return NS_ERROR_NOT_INITIALIZED; }
   ForceCompositionEnd();
   nsCOMPtr<nsISelectionController> selCon;
   GetSelectionController(getter_AddRefs(selCon));
   NS_ENSURE_TRUE(selCon, NS_ERROR_NOT_INITIALIZED);
   nsCOMPtr<nsISelection> selection;
   nsresult result = selCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));
   if (NS_SUCCEEDED(result) && selection)
   {
     result = SelectEntireDocument(selection);
   }
   return result;
 }
 NS_IMETHODIMP nsEditor::BeginningOfDocument()
 {
   if (!mDocWeak) { return NS_ERROR_NOT_INITIALIZED; }
   // get the selection
   nsCOMPtr<nsISelection> selection;
   nsresult result = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(result, result);
   NS_ENSURE_TRUE(selection, NS_ERROR_NOT_INITIALIZED);
   // get the root element
   dom::Element* rootElement = GetRoot();
   NS_ENSURE_TRUE(rootElement, NS_ERROR_NULL_POINTER);
   // find first editable thingy
   nsCOMPtr<nsINode> firstNode = GetFirstEditableNode(rootElement);
   if (!firstNode) {
     // just the root node, set selection to inside the root
     return selection->CollapseNative(rootElement, 0);
   }
   if (firstNode->NodeType() == nsIDOMNode::TEXT_NODE) {
     // If firstNode is text, set selection to beginning of the text node.
     return selection->CollapseNative(firstNode, 0);
   }
   // Otherwise, it's a leaf node and we set the selection just in front of it.
   nsCOMPtr<nsIContent> parent = firstNode->GetParent();
   if (!parent) {
     return NS_ERROR_NULL_POINTER;
   }
   int32_t offsetInParent = parent->IndexOf(firstNode);
   return selection->CollapseNative(parent, offsetInParent);
 }
 NS_IMETHODIMP
 nsEditor::EndOfDocument()
 {
   NS_ENSURE_TRUE(mDocWeak, NS_ERROR_NOT_INITIALIZED);
   // get selection
   nsCOMPtr<nsISelection> selection;
   nsresult rv = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(rv, rv);
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
   // get the root element
   nsINode* node = GetRoot();
   NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
   nsINode* child = node->GetLastChild();
   while (child && IsContainer(child->AsDOMNode())) {
     node = child;
     child = node->GetLastChild();
   }
   uint32_t length = node->Length();
   return selection->CollapseNative(node, int32_t(length));
 }
 NS_IMETHODIMP
 nsEditor::GetDocumentModified(bool *outDocModified)
 {
   NS_ENSURE_TRUE(outDocModified, NS_ERROR_NULL_POINTER);
   int32_t  modCount = 0;
   GetModificationCount(&modCount);
   *outDocModified = (modCount != 0);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::GetDocumentCharacterSet(nsACString &characterSet)
 {
   nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
   NS_ENSURE_TRUE(doc, NS_ERROR_UNEXPECTED);
   characterSet = doc->GetDocumentCharacterSet();
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::SetDocumentCharacterSet(const nsACString& characterSet)
 {
   nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
   NS_ENSURE_TRUE(doc, NS_ERROR_UNEXPECTED);
   doc->SetDocumentCharacterSet(characterSet);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::Cut()
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 NS_IMETHODIMP
 nsEditor::CanCut(bool *aCanCut)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 NS_IMETHODIMP
 nsEditor::Copy()
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 NS_IMETHODIMP
 nsEditor::CanCopy(bool *aCanCut)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 NS_IMETHODIMP
 nsEditor::Paste(int32_t aSelectionType)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 NS_IMETHODIMP
 nsEditor::PasteTransferable(nsITransferable *aTransferable)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 NS_IMETHODIMP
 nsEditor::CanPaste(int32_t aSelectionType, bool *aCanPaste)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 NS_IMETHODIMP
 nsEditor::CanPasteTransferable(nsITransferable *aTransferable, bool *aCanPaste)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 NS_IMETHODIMP
 nsEditor::SetAttribute(nsIDOMElement *aElement, const nsAString & aAttribute, const nsAString & aValue)
 {
   nsRefPtr<ChangeAttributeTxn> txn;
   nsresult result = CreateTxnForSetAttribute(aElement, aAttribute, aValue,
                                              getter_AddRefs(txn));
   if (NS_SUCCEEDED(result))  {
     result = DoTransaction(txn);
   }
   return result;
 }
 NS_IMETHODIMP
 nsEditor::GetAttributeValue(nsIDOMElement *aElement,
                             const nsAString & aAttribute,
                             nsAString & aResultValue,
                             bool *aResultIsSet)
 {
   NS_ENSURE_TRUE(aResultIsSet, NS_ERROR_NULL_POINTER);
   *aResultIsSet = false;
   if (!aElement) {
     return NS_OK;
   }
   nsAutoString value;
   nsresult rv = aElement->GetAttribute(aAttribute, value);
   NS_ENSURE_SUCCESS(rv, rv);
   if (!DOMStringIsNull(value)) {
     *aResultIsSet = true;
     aResultValue = value;
   }
   return rv;
 }
 NS_IMETHODIMP
 nsEditor::RemoveAttribute(nsIDOMElement *aElement, const nsAString& aAttribute)
 {
   nsRefPtr<ChangeAttributeTxn> txn;
   nsresult result = CreateTxnForRemoveAttribute(aElement, aAttribute,
                                                 getter_AddRefs(txn));
   if (NS_SUCCEEDED(result))  {
     result = DoTransaction(txn);
   }
   return result;
 }
 bool
 nsEditor::OutputsMozDirty()
 {
   // Return true for Composer (!eEditorAllowInteraction) or mail
   // (eEditorMailMask), but false for webpages.
   return !(mFlags & nsIPlaintextEditor::eEditorAllowInteraction) ||
           (mFlags & nsIPlaintextEditor::eEditorMailMask);
 }
 NS_IMETHODIMP
 nsEditor::MarkNodeDirty(nsIDOMNode* aNode)
 {
   // Mark the node dirty, but not for webpages (bug 599983)
   if (!OutputsMozDirty()) {
     return NS_OK;
   }
   nsCOMPtr<dom::Element> element = do_QueryInterface(aNode);
   if (element) {
     element->SetAttr(kNameSpaceID_None, nsEditProperty::mozdirty,
                      EmptyString(), false);
   }
   return NS_OK;
 }
 NS_IMETHODIMP nsEditor::GetInlineSpellChecker(bool autoCreate,
                                               nsIInlineSpellChecker ** aInlineSpellChecker)
 {
   NS_ENSURE_ARG_POINTER(aInlineSpellChecker);
   if (mDidPreDestroy) {
     // Don't allow people to get or create the spell checker once the editor
     // is going away.
     *aInlineSpellChecker = nullptr;
     return autoCreate ? NS_ERROR_NOT_AVAILABLE : NS_OK;
   }
   // We don't want to show the spell checking UI if there are no spell check dictionaries available.
   bool canSpell = mozInlineSpellChecker::CanEnableInlineSpellChecking();
   if (!canSpell) {
     *aInlineSpellChecker = nullptr;
     return NS_ERROR_FAILURE;
   }
   nsresult rv;
   if (!mInlineSpellChecker && autoCreate) {
     mInlineSpellChecker = do_CreateInstance(MOZ_INLINESPELLCHECKER_CONTRACTID, &rv);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   if (mInlineSpellChecker) {
     rv = mInlineSpellChecker->Init(this);
     if (NS_FAILED(rv))
       mInlineSpellChecker = nullptr;
     NS_ENSURE_SUCCESS(rv, rv);
   }
   NS_IF_ADDREF(*aInlineSpellChecker = mInlineSpellChecker);
   return NS_OK;
 }
 NS_IMETHODIMP nsEditor::Observe(nsISupports* aSubj, const char *aTopic,
                                 const char16_t *aData)
 {
   NS_ASSERTION(!strcmp(aTopic,
                        SPELLCHECK_DICTIONARY_UPDATE_NOTIFICATION),
                "Unexpected observer topic");
   // When mozInlineSpellChecker::CanEnableInlineSpellChecking changes
   SyncRealTimeSpell();
   // When nsIEditorSpellCheck::GetCurrentDictionary changes
   if (mInlineSpellChecker) {
     // if the current dictionary is no longer available, find another one
     nsCOMPtr<nsIEditorSpellCheck> editorSpellCheck;
     mInlineSpellChecker->GetSpellChecker(getter_AddRefs(editorSpellCheck));
     if (editorSpellCheck) {
       // Note: This might change the current dictionary, which may call
       // this observer recursively.
       editorSpellCheck->CheckCurrentDictionary();
     }
     // update the inline spell checker to reflect the new current dictionary
     mInlineSpellChecker->SpellCheckRange(nullptr); // causes recheck
   }
   return NS_OK;
 }
 NS_IMETHODIMP nsEditor::SyncRealTimeSpell()
 {
   bool enable = GetDesiredSpellCheckState();
   // Initializes mInlineSpellChecker
   nsCOMPtr<nsIInlineSpellChecker> spellChecker;
   GetInlineSpellChecker(enable, getter_AddRefs(spellChecker));
   if (mInlineSpellChecker) {
     // We might have a mInlineSpellChecker even if there are no dictionaries
     // available since we don't destroy the mInlineSpellChecker when the last
     // dictionariy is removed, but in that case spellChecker is null
     mInlineSpellChecker->SetEnableRealTimeSpell(enable && spellChecker);
   }
   return NS_OK;
 }
 NS_IMETHODIMP nsEditor::SetSpellcheckUserOverride(bool enable)
 {
   mSpellcheckCheckboxState = enable ? eTriTrue : eTriFalse;
   return SyncRealTimeSpell();
 }
 NS_IMETHODIMP nsEditor::CreateNode(const nsAString& aTag,
                                    nsIDOMNode *    aParent,
                                    int32_t         aPosition,
                                    nsIDOMNode **   aNewNode)
 {
   int32_t i;
   nsAutoRules beginRulesSniffing(this, EditAction::createNode, nsIEditor::eNext);
   for (i = 0; i < mActionListeners.Count(); i++)
     mActionListeners[i]->WillCreateNode(aTag, aParent, aPosition);
   nsRefPtr<CreateElementTxn> txn;
   nsresult result = CreateTxnForCreateElement(aTag, aParent, aPosition,
                                               getter_AddRefs(txn));
   if (NS_SUCCEEDED(result))
   {
     result = DoTransaction(txn);
     if (NS_SUCCEEDED(result))
     {
       result = txn->GetNewNode(aNewNode);
       NS_ASSERTION((NS_SUCCEEDED(result)), "GetNewNode can't fail if txn::DoTransaction succeeded.");
     }
   }
   mRangeUpdater.SelAdjCreateNode(aParent, aPosition);
   for (i = 0; i < mActionListeners.Count(); i++)
     mActionListeners[i]->DidCreateNode(aTag, *aNewNode, aParent, aPosition, result);
   return result;
 }
 NS_IMETHODIMP nsEditor::InsertNode(nsIDOMNode * aNode,
                                    nsIDOMNode * aParent,
                                    int32_t      aPosition)
 {
   int32_t i;
   nsAutoRules beginRulesSniffing(this, EditAction::insertNode, nsIEditor::eNext);
   for (i = 0; i < mActionListeners.Count(); i++)
     mActionListeners[i]->WillInsertNode(aNode, aParent, aPosition);
   nsRefPtr<InsertElementTxn> txn;
   nsresult result = CreateTxnForInsertElement(aNode, aParent, aPosition,
                                               getter_AddRefs(txn));
   if (NS_SUCCEEDED(result))  {
     result = DoTransaction(txn);
   }
   mRangeUpdater.SelAdjInsertNode(aParent, aPosition);
   for (i = 0; i < mActionListeners.Count(); i++)
     mActionListeners[i]->DidInsertNode(aNode, aParent, aPosition, result);
   return result;
 }
 NS_IMETHODIMP
 nsEditor::SplitNode(nsIDOMNode * aNode,
                     int32_t      aOffset,
                     nsIDOMNode **aNewLeftNode)
 {
   int32_t i;
   nsAutoRules beginRulesSniffing(this, EditAction::splitNode, nsIEditor::eNext);
   for (i = 0; i < mActionListeners.Count(); i++)
     mActionListeners[i]->WillSplitNode(aNode, aOffset);
   nsRefPtr<SplitElementTxn> txn;
   nsresult result = CreateTxnForSplitNode(aNode, aOffset, getter_AddRefs(txn));
   if (NS_SUCCEEDED(result))
   {
     result = DoTransaction(txn);
     if (NS_SUCCEEDED(result))
     {
       result = txn->GetNewNode(aNewLeftNode);
       NS_ASSERTION((NS_SUCCEEDED(result)), "result must succeeded for GetNewNode");
     }
   }
   mRangeUpdater.SelAdjSplitNode(aNode, aOffset, *aNewLeftNode);
   for (i = 0; i < mActionListeners.Count(); i++)
   {
     nsIDOMNode *ptr = *aNewLeftNode;
     mActionListeners[i]->DidSplitNode(aNode, aOffset, ptr, result);
   }
   return result;
 }
 nsresult
 nsEditor::JoinNodes(nsINode* aNodeToKeep, nsIContent* aNodeToMove)
 {
   // We don't really need aNodeToMove's parent to be non-null -- we could just
   // skip adjusting any ranges in aNodeToMove's parent if there is none.  But
   // the current implementation requires it.
   MOZ_ASSERT(aNodeToKeep && aNodeToMove && aNodeToMove->GetParentNode());
   nsresult res = JoinNodes(aNodeToKeep->AsDOMNode(), aNodeToMove->AsDOMNode(),
                            aNodeToMove->GetParentNode()->AsDOMNode());
   NS_ASSERTION(NS_SUCCEEDED(res), "JoinNodes failed");
   NS_ENSURE_SUCCESS(res, res);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::JoinNodes(nsIDOMNode * aLeftNode,
                     nsIDOMNode * aRightNode,
                     nsIDOMNode * aParent)
 {
   int32_t i;
   nsAutoRules beginRulesSniffing(this, EditAction::joinNode, nsIEditor::ePrevious);
   // remember some values; later used for saved selection updating.
   // find the offset between the nodes to be joined.
   int32_t offset = GetChildOffset(aRightNode, aParent);
   // find the number of children of the lefthand node
   uint32_t oldLeftNodeLen;
   nsresult result = GetLengthOfDOMNode(aLeftNode, oldLeftNodeLen);
   NS_ENSURE_SUCCESS(result, result);
   for (i = 0; i < mActionListeners.Count(); i++)
     mActionListeners[i]->WillJoinNodes(aLeftNode, aRightNode, aParent);
   nsRefPtr<JoinElementTxn> txn;
   result = CreateTxnForJoinNode(aLeftNode, aRightNode, getter_AddRefs(txn));
   if (NS_SUCCEEDED(result))  {
     result = DoTransaction(txn);
   }
   mRangeUpdater.SelAdjJoinNodes(aLeftNode, aRightNode, aParent, offset, (int32_t)oldLeftNodeLen);
   for (i = 0; i < mActionListeners.Count(); i++)
     mActionListeners[i]->DidJoinNodes(aLeftNode, aRightNode, aParent, result);
   return result;
 }
 NS_IMETHODIMP
 nsEditor::DeleteNode(nsIDOMNode* aNode)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   NS_ENSURE_STATE(node);
   return DeleteNode(node);
 }
 nsresult
 nsEditor::DeleteNode(nsINode* aNode)
 {
   nsAutoRules beginRulesSniffing(this, EditAction::createNode, nsIEditor::ePrevious);
   // save node location for selection updating code.
   for (int32_t i = 0; i < mActionListeners.Count(); i++) {
     mActionListeners[i]->WillDeleteNode(aNode->AsDOMNode());
   }
   nsRefPtr<DeleteNodeTxn> txn;
   nsresult res = CreateTxnForDeleteNode(aNode, getter_AddRefs(txn));
   if (NS_SUCCEEDED(res))  {
     res = DoTransaction(txn);
   }
   for (int32_t i = 0; i < mActionListeners.Count(); i++) {
     mActionListeners[i]->DidDeleteNode(aNode->AsDOMNode(), res);
   }
   NS_ENSURE_SUCCESS(res, res);
   return NS_OK;
 }
 ///////////////////////////////////////////////////////////////////////////
 // ReplaceContainer: replace inNode with a new node (outNode) which is contructed
 //                   to be of type aNodeType.  Put inNodes children into outNode.
 //                   Callers responsibility to make sure inNode's children can
 //                   go in outNode.
 nsresult
 nsEditor::ReplaceContainer(nsIDOMNode *inNode,
                            nsCOMPtr<nsIDOMNode> *outNode,
                            const nsAString &aNodeType,
                            const nsAString *aAttribute,
                            const nsAString *aValue,
                            bool aCloneAttributes)
 {
   NS_ENSURE_TRUE(inNode && outNode, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsINode> node = do_QueryInterface(inNode);
   NS_ENSURE_STATE(node);
   nsCOMPtr<dom::Element> element;
   nsresult rv = ReplaceContainer(node, getter_AddRefs(element), aNodeType,
                                  aAttribute, aValue, aCloneAttributes);
   *outNode = element ? element->AsDOMNode() : nullptr;
   return rv;
 }
 nsresult
 nsEditor::ReplaceContainer(nsINode* aNode,
                            dom::Element** outNode,
                            const nsAString& aNodeType,
                            const nsAString* aAttribute,
                            const nsAString* aValue,
                            bool aCloneAttributes)
 {
   MOZ_ASSERT(aNode);
   MOZ_ASSERT(outNode);
   *outNode = nullptr;
   nsCOMPtr<nsIContent> parent = aNode->GetParent();
   NS_ENSURE_STATE(parent);
   int32_t offset = parent->IndexOf(aNode);
   // create new container
   //new call to use instead to get proper HTML element, bug# 39919
   nsresult res = CreateHTMLContent(aNodeType, outNode);
   NS_ENSURE_SUCCESS(res, res);
   nsCOMPtr<nsIDOMElement> elem = do_QueryInterface(*outNode);
   nsIDOMNode* inNode = aNode->AsDOMNode();
   // set attribute if needed
   if (aAttribute && aValue && !aAttribute->IsEmpty()) {
     res = elem->SetAttribute(*aAttribute, *aValue);
     NS_ENSURE_SUCCESS(res, res);
   }
   if (aCloneAttributes) {
     res = CloneAttributes(elem, inNode);
     NS_ENSURE_SUCCESS(res, res);
   }
   // notify our internal selection state listener
   // (Note: A nsAutoSelectionReset object must be created
   //  before calling this to initialize mRangeUpdater)
   nsAutoReplaceContainerSelNotify selStateNotify(mRangeUpdater, inNode, elem);
   {
     nsAutoTxnsConserveSelection conserveSelection(this);
     while (aNode->HasChildren()) {
       nsCOMPtr<nsIDOMNode> child = aNode->GetFirstChild()->AsDOMNode();
       res = DeleteNode(child);
       NS_ENSURE_SUCCESS(res, res);
       res = InsertNode(child, elem, -1);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   // insert new container into tree
   res = InsertNode(elem, parent->AsDOMNode(), offset);
   NS_ENSURE_SUCCESS(res, res);
   // delete old container
   return DeleteNode(inNode);
 }
 ///////////////////////////////////////////////////////////////////////////
 // RemoveContainer: remove inNode, reparenting its children into their
 //                  the parent of inNode
 //
 nsresult
 nsEditor::RemoveContainer(nsIDOMNode* aNode)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   return RemoveContainer(node);
 }
 nsresult
 nsEditor::RemoveContainer(nsINode* aNode)
 {
   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsINode> parent = aNode->GetParentNode();
   NS_ENSURE_STATE(parent);
   int32_t offset = parent->IndexOf(aNode);
   // loop through the child nodes of inNode and promote them
   // into inNode's parent.
   uint32_t nodeOrigLen = aNode->GetChildCount();
   // notify our internal selection state listener
   nsAutoRemoveContainerSelNotify selNotify(mRangeUpdater, aNode, parent, offset, nodeOrigLen);
   while (aNode->HasChildren()) {
     nsCOMPtr<nsIContent> child = aNode->GetLastChild();
     nsresult rv = DeleteNode(child->AsDOMNode());
     NS_ENSURE_SUCCESS(rv, rv);
     rv = InsertNode(child->AsDOMNode(), parent->AsDOMNode(), offset);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   return DeleteNode(aNode->AsDOMNode());
 }
 ///////////////////////////////////////////////////////////////////////////
 // InsertContainerAbove:  insert a new parent for inNode, returned in outNode,
 //                   which is contructed to be of type aNodeType.  outNode becomes
 //                   a child of inNode's earlier parent.
 //                   Callers responsibility to make sure inNode's can be child
 //                   of outNode, and outNode can be child of old parent.
 nsresult
 nsEditor::InsertContainerAbove( nsIDOMNode *inNode,
                                 nsCOMPtr<nsIDOMNode> *outNode,
                                 const nsAString &aNodeType,
                                 const nsAString *aAttribute,
                                 const nsAString *aValue)
 {
   NS_ENSURE_TRUE(inNode && outNode, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIContent> node = do_QueryInterface(inNode);
   NS_ENSURE_STATE(node);
   nsCOMPtr<dom::Element> element;
   nsresult rv = InsertContainerAbove(node, getter_AddRefs(element), aNodeType,
                                      aAttribute, aValue);
   *outNode = element ? element->AsDOMNode() : nullptr;
   return rv;
 }
 nsresult
 nsEditor::InsertContainerAbove(nsIContent* aNode,
                                dom::Element** aOutNode,
                                const nsAString& aNodeType,
                                const nsAString* aAttribute,
                                const nsAString* aValue)
 {
   MOZ_ASSERT(aNode);
   nsCOMPtr<nsIContent> parent = aNode->GetParent();
   NS_ENSURE_STATE(parent);
   int32_t offset = parent->IndexOf(aNode);
   // create new container
   nsCOMPtr<dom::Element> newContent;
   //new call to use instead to get proper HTML element, bug# 39919
   nsresult res = CreateHTMLContent(aNodeType, getter_AddRefs(newContent));
   NS_ENSURE_SUCCESS(res, res);
   // set attribute if needed
   if (aAttribute && aValue && !aAttribute->IsEmpty()) {
     nsIDOMNode* elem = newContent->AsDOMNode();
     res = static_cast<nsIDOMElement*>(elem)->SetAttribute(*aAttribute, *aValue);
     NS_ENSURE_SUCCESS(res, res);
   }
   // notify our internal selection state listener
   nsAutoInsertContainerSelNotify selNotify(mRangeUpdater);
   // put inNode in new parent, outNode
   res = DeleteNode(aNode->AsDOMNode());
   NS_ENSURE_SUCCESS(res, res);
   {
     nsAutoTxnsConserveSelection conserveSelection(this);
     res = InsertNode(aNode->AsDOMNode(), newContent->AsDOMNode(), 0);
     NS_ENSURE_SUCCESS(res, res);
   }
   // put new parent in doc
   res = InsertNode(newContent->AsDOMNode(), parent->AsDOMNode(), offset);
   newContent.forget(aOutNode);
   return res;
 }
 ///////////////////////////////////////////////////////////////////////////
 // MoveNode:  move aNode to {aParent,aOffset}
 nsresult
 nsEditor::MoveNode(nsIDOMNode* aNode, nsIDOMNode* aParent, int32_t aOffset)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   NS_ENSURE_STATE(node);
   nsCOMPtr<nsINode> parent = do_QueryInterface(aParent);
   NS_ENSURE_STATE(parent);
   return MoveNode(node, parent, aOffset);
 }
 nsresult
 nsEditor::MoveNode(nsINode* aNode, nsINode* aParent, int32_t aOffset)
 {
   MOZ_ASSERT(aNode);
   MOZ_ASSERT(aParent);
   MOZ_ASSERT(aOffset == -1 ||
              (0 <= aOffset && SafeCast<uint32_t>(aOffset) <= aParent->Length()));
   int32_t oldOffset;
   nsCOMPtr<nsINode> oldParent = GetNodeLocation(aNode, &oldOffset);
   if (aOffset == -1) {
     // Magic value meaning "move to end of aParent".
     aOffset = SafeCast<int32_t>(aParent->Length());
   }
   // Don't do anything if it's already in right place.
   if (aParent == oldParent && aOffset == oldOffset) {
     return NS_OK;
   }
   // Notify our internal selection state listener.
   nsAutoMoveNodeSelNotify selNotify(mRangeUpdater, oldParent, oldOffset,
                                     aParent, aOffset);
   // Need to adjust aOffset if we are moving aNode further along in its current
   // parent.
   if (aParent == oldParent && oldOffset < aOffset) {
     // This is because when we delete aNode, it will make the offsets after it
     // off by one.
     aOffset--;
   }
   // Hold a reference so aNode doesn't go away when we remove it (bug 772282).
   nsCOMPtr<nsINode> kungFuDeathGrip = aNode;
   nsresult rv = DeleteNode(aNode);
   NS_ENSURE_SUCCESS(rv, rv);
   return InsertNode(aNode->AsDOMNode(), aParent->AsDOMNode(), aOffset);
 }
 NS_IMETHODIMP
 nsEditor::AddEditorObserver(nsIEditorObserver *aObserver)
 {
   // we don't keep ownership of the observers.  They must
   // remove themselves as observers before they are destroyed.
   NS_ENSURE_TRUE(aObserver, NS_ERROR_NULL_POINTER);
   // Make sure the listener isn't already on the list
   if (mEditorObservers.IndexOf(aObserver) == -1)
   {
     if (!mEditorObservers.AppendObject(aObserver))
       return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::RemoveEditorObserver(nsIEditorObserver *aObserver)
 {
   NS_ENSURE_TRUE(aObserver, NS_ERROR_FAILURE);
   if (!mEditorObservers.RemoveObject(aObserver))
     return NS_ERROR_FAILURE;
   return NS_OK;
 }
 class EditorInputEventDispatcher : public nsRunnable
 {
 public:
   EditorInputEventDispatcher(nsEditor* aEditor,
                              nsIContent* aTarget,
                              bool aIsComposing)
     : mEditor(aEditor)
     , mTarget(aTarget)
     , mIsComposing(aIsComposing)
   {
   }
   NS_IMETHOD Run()
   {
     // Note that we don't need to check mDispatchInputEvent here.  We need
     // to check it only when the editor requests to dispatch the input event.
     if (!mTarget->IsInDoc()) {
       return NS_OK;
     }
     nsCOMPtr<nsIPresShell> ps = mEditor->GetPresShell();
     if (!ps) {
       return NS_OK;
     }
     nsCOMPtr<nsIWidget> widget = mEditor->GetWidget();
     if (!widget) {
       return NS_OK;
     }
     // Even if the change is caused by untrusted event, we need to dispatch
     // trusted input event since it's a fact.
     InternalEditorInputEvent inputEvent(true, NS_EDITOR_INPUT, widget);
     inputEvent.time = static_cast<uint64_t>(PR_Now() / 1000);
     inputEvent.mIsComposing = mIsComposing;
     nsEventStatus status = nsEventStatus_eIgnore;
     nsresult rv =
       ps->HandleEventWithTarget(&inputEvent, nullptr, mTarget, &status);
     NS_ENSURE_SUCCESS(rv, NS_OK); // print the warning if error
     return NS_OK;
   }
 private:
   nsRefPtr<nsEditor> mEditor;
   nsCOMPtr<nsIContent> mTarget;
   bool mIsComposing;
 };
 void nsEditor::NotifyEditorObservers(void)
 {
   for (int32_t i = 0; i < mEditorObservers.Count(); i++) {
     mEditorObservers[i]->EditAction();
   }
   if (!mDispatchInputEvent) {
     return;
   }
   FireInputEvent();
 }
 void
 nsEditor::FireInputEvent()
 {
   // We don't need to dispatch multiple input events if there is a pending
   // input event.  However, it may have different event target.  If we resolved
   // this issue, we need to manage the pending events in an array.  But it's
   // overwork.  We don't need to do it for the very rare case.
   nsCOMPtr<nsIContent> target = GetInputEventTargetContent();
   NS_ENSURE_TRUE_VOID(target);
   // NOTE: Don't refer IsIMEComposing() because it returns false even before
   //       compositionend.  However, DOM Level 3 Events defines it should be
   //       true after compositionstart and before compositionend.
   nsContentUtils::AddScriptRunner(
     new EditorInputEventDispatcher(this, target, !!GetComposition()));
 }
 NS_IMETHODIMP
 nsEditor::AddEditActionListener(nsIEditActionListener *aListener)
 {
   NS_ENSURE_TRUE(aListener, NS_ERROR_NULL_POINTER);
   // Make sure the listener isn't already on the list
   if (mActionListeners.IndexOf(aListener) == -1)
   {
     if (!mActionListeners.AppendObject(aListener))
       return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::RemoveEditActionListener(nsIEditActionListener *aListener)
 {
   NS_ENSURE_TRUE(aListener, NS_ERROR_FAILURE);
   if (!mActionListeners.RemoveObject(aListener))
     return NS_ERROR_FAILURE;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::AddDocumentStateListener(nsIDocumentStateListener *aListener)
 {
   NS_ENSURE_TRUE(aListener, NS_ERROR_NULL_POINTER);
   if (mDocStateListeners.IndexOf(aListener) == -1)
   {
     if (!mDocStateListeners.AppendObject(aListener))
       return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::RemoveDocumentStateListener(nsIDocumentStateListener *aListener)
 {
   NS_ENSURE_TRUE(aListener, NS_ERROR_NULL_POINTER);
   if (!mDocStateListeners.RemoveObject(aListener))
     return NS_ERROR_FAILURE;
   return NS_OK;
 }
 NS_IMETHODIMP nsEditor::OutputToString(const nsAString& aFormatType,
                                        uint32_t aFlags,
                                        nsAString& aOutputString)
 {
   // these should be implemented by derived classes.
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 NS_IMETHODIMP
 nsEditor::OutputToStream(nsIOutputStream* aOutputStream,
                          const nsAString& aFormatType,
                          const nsACString& aCharsetOverride,
                          uint32_t aFlags)
 {
   // these should be implemented by derived classes.
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 NS_IMETHODIMP
 nsEditor::DumpContentTree()
 {
 #ifdef DEBUG
   if (mRootElement) {
     mRootElement->List(stdout);
   }
 #endif
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::DebugDumpContent()
 {
 #ifdef DEBUG
   nsCOMPtr<nsIDOMHTMLDocument> doc = do_QueryReferent(mDocWeak);
   NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);
   nsCOMPtr<nsIDOMHTMLElement>bodyElem;
   doc->GetBody(getter_AddRefs(bodyElem));
   nsCOMPtr<nsIContent> content = do_QueryInterface(bodyElem);
   if (content)
     content->List();
 #endif
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::DebugUnitTests(int32_t *outNumTests, int32_t *outNumTestsFailed)
 {
 #ifdef DEBUG
   NS_NOTREACHED("This should never get called. Overridden by subclasses");
 #endif
   return NS_OK;
 }
 bool
 nsEditor::ArePreservingSelection()
 {
   return !(mSavedSel.IsEmpty());
 }
 void
 nsEditor::PreserveSelectionAcrossActions(Selection* aSel)
 {
   mSavedSel.SaveSelection(aSel);
   mRangeUpdater.RegisterSelectionState(mSavedSel);
 }
 nsresult
 nsEditor::RestorePreservedSelection(nsISelection *aSel)
 {
   if (mSavedSel.IsEmpty()) return NS_ERROR_FAILURE;
   mSavedSel.RestoreSelection(aSel);
   StopPreservingSelection();
   return NS_OK;
 }
 void
 nsEditor::StopPreservingSelection()
 {
   mRangeUpdater.DropSelectionState(mSavedSel);
   mSavedSel.MakeEmpty();
 }
 void
 nsEditor::EnsureComposition(mozilla::WidgetGUIEvent* aEvent)
 {
   if (mComposition) {
     return;
   }
   // The compositionstart event must cause creating new TextComposition
   // instance at being dispatched by IMEStateManager.
   mComposition = IMEStateManager::GetTextCompositionFor(aEvent);
   if (!mComposition) {
     MOZ_CRASH("IMEStateManager doesn't return proper composition");
   }
   mComposition->StartHandlingComposition(this);
 }
 nsresult
 nsEditor::BeginIMEComposition(WidgetCompositionEvent* aCompositionEvent)
 {
   MOZ_ASSERT(!mComposition, "There is composition already");
   EnsureComposition(aCompositionEvent);
   if (mPhonetic) {
     mPhonetic->Truncate(0);
   }
   return NS_OK;
 }
 void
 nsEditor::EndIMEComposition()
 {
   NS_ENSURE_TRUE_VOID(mComposition); // nothing to do
   // commit the IME transaction..we can get at it via the transaction mgr.
   // Note that this means IME won't work without an undo stack!
   if (mTxnMgr) {
     nsCOMPtr<nsITransaction> txn = mTxnMgr->PeekUndoStack();
     nsCOMPtr<nsIAbsorbingTransaction> plcTxn = do_QueryInterface(txn);
     if (plcTxn) {
       DebugOnly<nsresult> rv = plcTxn->Commit();
       NS_ASSERTION(NS_SUCCEEDED(rv),
                    "nsIAbsorbingTransaction::Commit() failed");
     }
   }
   /* reset the data we need to construct a transaction */
   mIMETextNode = nullptr;
   mIMETextOffset = 0;
   mComposition->EndHandlingComposition(this);
   mComposition = nullptr;
   // notify editor observers of action
   NotifyEditorObservers();
 }
 NS_IMETHODIMP
 nsEditor::GetPhonetic(nsAString& aPhonetic)
 {
   if (mPhonetic)
     aPhonetic = *mPhonetic;
   else
     aPhonetic.Truncate(0);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::ForceCompositionEnd()
 {
   nsCOMPtr<nsIPresShell> ps = GetPresShell();
   if (!ps) {
     return NS_ERROR_NOT_AVAILABLE;
   }
   nsPresContext* pc = ps->GetPresContext();
   if (!pc) {
     return NS_ERROR_NOT_AVAILABLE;
   }
   if (!mComposition) {
     // XXXmnakano see bug 558976, ResetInputState() has two meaning which are
     // "commit the composition" and "cursor is moved".  This method name is
     // "ForceCompositionEnd", so, ResetInputState() should be used only for the
     // former here.  However, ResetInputState() is also used for the latter here
     // because even if we don't have composition, we call ResetInputState() on
     // Linux.  Currently, nsGtkIMModule can know the timing of the cursor move,
     // so, the latter meaning should be gone.
     // XXX This may commit a composition in another editor.
     return IMEStateManager::NotifyIME(NOTIFY_IME_OF_CURSOR_POS_CHANGED, pc);
   }
   return IMEStateManager::NotifyIME(REQUEST_TO_COMMIT_COMPOSITION, pc);
 }
 NS_IMETHODIMP
 nsEditor::GetPreferredIMEState(IMEState *aState)
 {
   NS_ENSURE_ARG_POINTER(aState);
   aState->mEnabled = IMEState::ENABLED;
   aState->mOpen = IMEState::DONT_CHANGE_OPEN_STATE;
   if (IsReadonly() || IsDisabled()) {
     aState->mEnabled = IMEState::DISABLED;
     return NS_OK;
   }
   nsCOMPtr<nsIContent> content = GetRoot();
   NS_ENSURE_TRUE(content, NS_ERROR_FAILURE);
   nsIFrame* frame = content->GetPrimaryFrame();
   NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE);
   switch (frame->StyleUIReset()->mIMEMode) {
     case NS_STYLE_IME_MODE_AUTO:
       if (IsPasswordEditor())
         aState->mEnabled = IMEState::PASSWORD;
       break;
     case NS_STYLE_IME_MODE_DISABLED:
       // we should use password state for |ime-mode: disabled;|.
       aState->mEnabled = IMEState::PASSWORD;
       break;
     case NS_STYLE_IME_MODE_ACTIVE:
       aState->mOpen = IMEState::OPEN;
       break;
     case NS_STYLE_IME_MODE_INACTIVE:
       aState->mOpen = IMEState::CLOSED;
       break;
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::GetComposing(bool* aResult)
 {
   NS_ENSURE_ARG_POINTER(aResult);
   *aResult = IsIMEComposing();
   return NS_OK;
 }
 /* Non-interface, public methods */
 NS_IMETHODIMP
 nsEditor::GetRootElement(nsIDOMElement **aRootElement)
 {
   NS_ENSURE_ARG_POINTER(aRootElement);
   NS_ENSURE_TRUE(mRootElement, NS_ERROR_NOT_AVAILABLE);
   nsCOMPtr<nsIDOMElement> rootElement = do_QueryInterface(mRootElement);
   rootElement.forget(aRootElement);
   return NS_OK;
 }
 /** All editor operations which alter the doc should be prefaced
  *  with a call to StartOperation, naming the action and direction */
 NS_IMETHODIMP
 nsEditor::StartOperation(EditAction opID, nsIEditor::EDirection aDirection)
 {
   mAction = opID;
   mDirection = aDirection;
   return NS_OK;
 }
 /** All editor operations which alter the doc should be followed
  *  with a call to EndOperation */
 NS_IMETHODIMP
 nsEditor::EndOperation()
 {
   mAction = EditAction::none;
   mDirection = eNone;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::CloneAttribute(const nsAString & aAttribute,
                          nsIDOMNode *aDestNode, nsIDOMNode *aSourceNode)
 {
   NS_ENSURE_TRUE(aDestNode && aSourceNode, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIDOMElement> destElement = do_QueryInterface(aDestNode);
   nsCOMPtr<nsIDOMElement> sourceElement = do_QueryInterface(aSourceNode);
   NS_ENSURE_TRUE(destElement && sourceElement, NS_ERROR_NO_INTERFACE);
   nsAutoString attrValue;
   bool isAttrSet;
   nsresult rv = GetAttributeValue(sourceElement,
                                   aAttribute,
                                   attrValue,
                                   &isAttrSet);
   NS_ENSURE_SUCCESS(rv, rv);
   if (isAttrSet)
     rv = SetAttribute(destElement, aAttribute, attrValue);
   else
     rv = RemoveAttribute(destElement, aAttribute);
   return rv;
 }
 // Objects must be DOM elements
 NS_IMETHODIMP
 nsEditor::CloneAttributes(nsIDOMNode *aDestNode, nsIDOMNode *aSourceNode)
 {
   NS_ENSURE_TRUE(aDestNode && aSourceNode, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIDOMElement> destElement = do_QueryInterface(aDestNode);
   nsCOMPtr<nsIDOMElement> sourceElement = do_QueryInterface(aSourceNode);
   NS_ENSURE_TRUE(destElement && sourceElement, NS_ERROR_NO_INTERFACE);
   nsCOMPtr<nsIDOMMozNamedAttrMap> sourceAttributes;
   sourceElement->GetAttributes(getter_AddRefs(sourceAttributes));
   nsCOMPtr<nsIDOMMozNamedAttrMap> destAttributes;
   destElement->GetAttributes(getter_AddRefs(destAttributes));
   NS_ENSURE_TRUE(sourceAttributes && destAttributes, NS_ERROR_FAILURE);
   nsAutoEditBatch beginBatching(this);
   // Use transaction system for undo only if destination
   //   is already in the document
   nsCOMPtr<nsIDOMNode> p = aDestNode;
   nsCOMPtr<nsIDOMNode> rootNode = do_QueryInterface(GetRoot());
   NS_ENSURE_TRUE(rootNode, NS_ERROR_NULL_POINTER);
   bool destInBody = true;
   while (p && p != rootNode)
   {
     nsCOMPtr<nsIDOMNode> tmp;
     if (NS_FAILED(p->GetParentNode(getter_AddRefs(tmp))) || !tmp)
     {
       destInBody = false;
       break;
     }
     p = tmp;
   }
   uint32_t sourceCount;
   sourceAttributes->GetLength(&sourceCount);
   uint32_t destCount;
   destAttributes->GetLength(&destCount);
   nsCOMPtr<nsIDOMAttr> attr;
   // Clear existing attributes
   for (uint32_t i = 0; i < destCount; i++) {
     // always remove item number 0 (first item in list)
     if (NS_SUCCEEDED(destAttributes->Item(0, getter_AddRefs(attr))) && attr) {
       nsString str;
       if (NS_SUCCEEDED(attr->GetName(str))) {
         if (destInBody) {
           RemoveAttribute(destElement, str);
         } else {
           destElement->RemoveAttribute(str);
         }
       }
     }
   }
   nsresult result = NS_OK;
   // Set just the attributes that the source element has
   for (uint32_t i = 0; i < sourceCount; i++)
   {
     if (NS_SUCCEEDED(sourceAttributes->Item(i, getter_AddRefs(attr))) && attr) {
       nsString sourceAttrName;
       if (NS_SUCCEEDED(attr->GetName(sourceAttrName))) {
         nsString sourceAttrValue;
         /* Presence of an attribute in the named node map indicates that it was
          * set on the element even if it has no value.
          */
         if (NS_SUCCEEDED(attr->GetValue(sourceAttrValue))) {
           if (destInBody) {
             result = SetAttributeOrEquivalent(destElement, sourceAttrName, sourceAttrValue, false);
           } else {
             // the element is not inserted in the document yet, we don't want to put a
             // transaction on the UndoStack
             result = SetAttributeOrEquivalent(destElement, sourceAttrName, sourceAttrValue, true);
           }
         } else {
           // Do we ever get here?
 #if DEBUG_cmanske
           printf("Attribute in sourceAttribute has empty value in nsEditor::CloneAttributes()\n");
 #endif
         }
       }
     }
   }
   return result;
 }
 NS_IMETHODIMP nsEditor::ScrollSelectionIntoView(bool aScrollToAnchor)
 {
   nsCOMPtr<nsISelectionController> selCon;
   if (NS_SUCCEEDED(GetSelectionController(getter_AddRefs(selCon))) && selCon)
   {
     int16_t region = nsISelectionController::SELECTION_FOCUS_REGION;
     if (aScrollToAnchor)
       region = nsISelectionController::SELECTION_ANCHOR_REGION;
     selCon->ScrollSelectionIntoView(nsISelectionController::SELECTION_NORMAL,
       region, nsISelectionController::SCROLL_OVERFLOW_HIDDEN);
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::InsertTextImpl(const nsAString& aStringToInsert,
                          nsCOMPtr<nsIDOMNode>* aInOutNode,
                          int32_t* aInOutOffset,
                          nsIDOMDocument* aDoc)
 {
   // NOTE: caller *must* have already used nsAutoTxnsConserveSelection
   // stack-based class to turn off txn selection updating.  Caller also turned
   // on rules sniffing if desired.
   NS_ENSURE_TRUE(aInOutNode && *aInOutNode && aInOutOffset && aDoc,
                  NS_ERROR_NULL_POINTER);
   if (!mComposition && aStringToInsert.IsEmpty()) {
     return NS_OK;
   }
   nsCOMPtr<nsINode> node = do_QueryInterface(*aInOutNode);
   NS_ENSURE_STATE(node);
   uint32_t offset = static_cast<uint32_t>(*aInOutOffset);
   if (!node->IsNodeOfType(nsINode::eTEXT) && IsPlaintextEditor()) {
     nsCOMPtr<nsINode> root = GetRoot();
     // In some cases, node is the anonymous DIV, and offset is 0.  To avoid
     // injecting unneeded text nodes, we first look to see if we have one
     // available.  In that case, we'll just adjust node and offset accordingly.
     if (node == root && offset == 0 && node->HasChildren() &&
         node->GetFirstChild()->IsNodeOfType(nsINode::eTEXT)) {
       node = node->GetFirstChild();
     }
     // In some other cases, node is the anonymous DIV, and offset points to the
     // terminating mozBR.  In that case, we'll adjust aInOutNode and
     // aInOutOffset to the preceding text node, if any.
     if (node == root && offset > 0 && node->GetChildAt(offset - 1) &&
         node->GetChildAt(offset - 1)->IsNodeOfType(nsINode::eTEXT)) {
       node = node->GetChildAt(offset - 1);
       offset = node->Length();
     }
     // Sometimes, node is the mozBR element itself.  In that case, we'll adjust
     // the insertion point to the previous text node, if one exists, or to the
     // parent anonymous DIV.
     if (nsTextEditUtils::IsMozBR(node) && offset == 0) {
       if (node->GetPreviousSibling() &&
           node->GetPreviousSibling()->IsNodeOfType(nsINode::eTEXT)) {
         node = node->GetPreviousSibling();
         offset = node->Length();
       } else if (node->GetParentNode() && node->GetParentNode() == root) {
         node = node->GetParentNode();
       }
     }
   }
   nsresult res;
   if (mComposition) {
     if (!node->IsNodeOfType(nsINode::eTEXT)) {
       // create a text node
       nsCOMPtr<nsIDocument> doc = do_QueryInterface(aDoc);
       NS_ENSURE_STATE(doc);
       nsRefPtr<nsTextNode> newNode = doc->CreateTextNode(EmptyString());
       // then we insert it into the dom tree
       res = InsertNode(newNode->AsDOMNode(), node->AsDOMNode(), offset);
       NS_ENSURE_SUCCESS(res, res);
       node = newNode;
       offset = 0;
     }
     nsCOMPtr<nsIDOMCharacterData> charDataNode = do_QueryInterface(node);
     NS_ENSURE_STATE(charDataNode);
     res = InsertTextIntoTextNodeImpl(aStringToInsert, charDataNode, offset);
     NS_ENSURE_SUCCESS(res, res);
     offset += aStringToInsert.Length();
   } else {
     if (node->IsNodeOfType(nsINode::eTEXT)) {
       // we are inserting text into an existing text node.
       nsCOMPtr<nsIDOMCharacterData> charDataNode = do_QueryInterface(node);
       NS_ENSURE_STATE(charDataNode);
       res = InsertTextIntoTextNodeImpl(aStringToInsert, charDataNode, offset);
       NS_ENSURE_SUCCESS(res, res);
       offset += aStringToInsert.Length();
     } else {
       // we are inserting text into a non-text node.  first we have to create a
       // textnode (this also populates it with the text)
       nsCOMPtr<nsIDocument> doc = do_QueryInterface(aDoc);
       NS_ENSURE_STATE(doc);
       nsRefPtr<nsTextNode> newNode = doc->CreateTextNode(aStringToInsert);
       // then we insert it into the dom tree
       res = InsertNode(newNode->AsDOMNode(), node->AsDOMNode(), offset);
       NS_ENSURE_SUCCESS(res, res);
       node = newNode;
       offset = aStringToInsert.Length();
     }
   }
   *aInOutNode = node->AsDOMNode();
   *aInOutOffset = static_cast<int32_t>(offset);
   return NS_OK;
 }
 nsresult nsEditor::InsertTextIntoTextNodeImpl(const nsAString& aStringToInsert,
                                               nsIDOMCharacterData *aTextNode,
                                               int32_t aOffset,
                                               bool aSuppressIME)
 {
   nsRefPtr<EditTxn> txn;
   nsresult result = NS_OK;
   bool isIMETransaction = false;
   // aSuppressIME is used when editor must insert text, yet this text is not
   // part of current ime operation.  example: adjusting whitespace around an ime insertion.
   if (mComposition && !aSuppressIME) {
     if (!mIMETextNode) {
       mIMETextNode = aTextNode;
       mIMETextOffset = aOffset;
     }
     // Modify mPhonetic with raw text input clauses.
     const TextRangeArray* ranges = mComposition->GetRanges();
     for (uint32_t i = 0; i < (ranges ? ranges->Length() : 0); ++i) {
       const TextRange& textRange = ranges->ElementAt(i);
       if (!textRange.Length() ||
           textRange.mRangeType != NS_TEXTRANGE_RAWINPUT) {
         continue;
       }
       if (!mPhonetic) {
         mPhonetic = new nsString();
       }
       nsAutoString stringToInsert(aStringToInsert);
       stringToInsert.Mid(*mPhonetic,
                          textRange.mStartOffset, textRange.Length());
     }
     nsRefPtr<IMETextTxn> imeTxn;
     result = CreateTxnForIMEText(aStringToInsert, getter_AddRefs(imeTxn));
     txn = imeTxn;
     isIMETransaction = true;
   }
   else
   {
     nsRefPtr<InsertTextTxn> insertTxn;
     result = CreateTxnForInsertText(aStringToInsert, aTextNode, aOffset,
                                     getter_AddRefs(insertTxn));
     txn = insertTxn;
   }
   NS_ENSURE_SUCCESS(result, result);
   // let listeners know what's up
   int32_t i;
   for (i = 0; i < mActionListeners.Count(); i++)
     mActionListeners[i]->WillInsertText(aTextNode, aOffset, aStringToInsert);
   // XXX we may not need these view batches anymore.  This is handled at a higher level now I believe
   BeginUpdateViewBatch();
   result = DoTransaction(txn);
   EndUpdateViewBatch();
   mRangeUpdater.SelAdjInsertText(aTextNode, aOffset, aStringToInsert);
   // let listeners know what happened
   for (i = 0; i < mActionListeners.Count(); i++)
     mActionListeners[i]->DidInsertText(aTextNode, aOffset, aStringToInsert, result);
   // Added some cruft here for bug 43366.  Layout was crashing because we left an
   // empty text node lying around in the document.  So I delete empty text nodes
   // caused by IME.  I have to mark the IME transaction as "fixed", which means
   // that furure ime txns won't merge with it.  This is because we don't want
   // future ime txns trying to put their text into a node that is no longer in
   // the document.  This does not break undo/redo, because all these txns are
   // wrapped in a parent PlaceHolder txn, and placeholder txns are already
   // savvy to having multiple ime txns inside them.
   // delete empty ime text node if there is one
   if (isIMETransaction && mIMETextNode)
   {
     uint32_t len;
     mIMETextNode->GetLength(&len);
     if (!len)
     {
       DeleteNode(mIMETextNode);
       mIMETextNode = nullptr;
       static_cast<IMETextTxn*>(txn.get())->MarkFixed();  // mark the ime txn "fixed"
     }
   }
   return result;
 }
 NS_IMETHODIMP nsEditor::SelectEntireDocument(nsISelection *aSelection)
 {
   if (!aSelection) { return NS_ERROR_NULL_POINTER; }
   nsCOMPtr<nsIDOMElement> rootElement = do_QueryInterface(GetRoot());
   if (!rootElement) { return NS_ERROR_NOT_INITIALIZED; }
   return aSelection->SelectAllChildren(rootElement);
 }
 nsINode*
 nsEditor::GetFirstEditableNode(nsINode* aRoot)
 {
   MOZ_ASSERT(aRoot);
   nsIContent* node = GetLeftmostChild(aRoot);
   if (node && !IsEditable(node)) {
     node = GetNextNode(node, /* aEditableNode = */ true);
   }
   return (node != aRoot) ? node : nullptr;
 }
 NS_IMETHODIMP
 nsEditor::NotifyDocumentListeners(TDocumentListenerNotification aNotificationType)
 {
   int32_t numListeners = mDocStateListeners.Count();
   if (!numListeners)    // maybe there just aren't any.
     return NS_OK;
   nsCOMArray<nsIDocumentStateListener> listeners(mDocStateListeners);
   nsresult rv = NS_OK;
   int32_t i;
   switch (aNotificationType)
   {
     case eDocumentCreated:
       for (i = 0; i < numListeners;i++)
       {
         rv = listeners[i]->NotifyDocumentCreated();
         if (NS_FAILED(rv))
           break;
       }
       break;
     case eDocumentToBeDestroyed:
       for (i = 0; i < numListeners;i++)
       {
         rv = listeners[i]->NotifyDocumentWillBeDestroyed();
         if (NS_FAILED(rv))
           break;
       }
       break;
     case eDocumentStateChanged:
       {
         bool docIsDirty;
         rv = GetDocumentModified(&docIsDirty);
         NS_ENSURE_SUCCESS(rv, rv);
         if (static_cast<int8_t>(docIsDirty) == mDocDirtyState)
           return NS_OK;
         mDocDirtyState = docIsDirty;
         for (i = 0; i < numListeners;i++)
         {
           rv = listeners[i]->NotifyDocumentStateChanged(mDocDirtyState);
           if (NS_FAILED(rv))
             break;
         }
       }
       break;
     default:
       NS_NOTREACHED("Unknown notification");
   }
   return rv;
 }
 NS_IMETHODIMP nsEditor::CreateTxnForInsertText(const nsAString & aStringToInsert,
                                                nsIDOMCharacterData *aTextNode,
                                                int32_t aOffset,
                                                InsertTextTxn ** aTxn)
 {
   NS_ENSURE_TRUE(aTextNode && aTxn, NS_ERROR_NULL_POINTER);
   nsresult rv;
   nsRefPtr<InsertTextTxn> txn = new InsertTextTxn();
   rv = txn->Init(aTextNode, aOffset, aStringToInsert, this);
   if (NS_SUCCEEDED(rv))
   {
     txn.forget(aTxn);
   }
   return rv;
 }
 NS_IMETHODIMP nsEditor::DeleteText(nsIDOMCharacterData *aElement,
                               uint32_t             aOffset,
                               uint32_t             aLength)
 {
   nsRefPtr<DeleteTextTxn> txn;
   nsresult result = CreateTxnForDeleteText(aElement, aOffset, aLength,
                                            getter_AddRefs(txn));
   nsAutoRules beginRulesSniffing(this, EditAction::deleteText, nsIEditor::ePrevious);
   if (NS_SUCCEEDED(result))
   {
     // let listeners know what's up
     int32_t i;
     for (i = 0; i < mActionListeners.Count(); i++)
       mActionListeners[i]->WillDeleteText(aElement, aOffset, aLength);
     result = DoTransaction(txn);
     // let listeners know what happened
     for (i = 0; i < mActionListeners.Count(); i++)
       mActionListeners[i]->DidDeleteText(aElement, aOffset, aLength, result);
   }
   return result;
 }
 nsresult
 nsEditor::CreateTxnForDeleteText(nsIDOMCharacterData* aElement,
                                  uint32_t             aOffset,
                                  uint32_t             aLength,
                                  DeleteTextTxn**      aTxn)
 {
   NS_ENSURE_TRUE(aElement, NS_ERROR_NULL_POINTER);
   nsRefPtr<DeleteTextTxn> txn = new DeleteTextTxn();
   nsresult res = txn->Init(this, aElement, aOffset, aLength, &mRangeUpdater);
   NS_ENSURE_SUCCESS(res, res);
   txn.forget(aTxn);
   return NS_OK;
 }
 NS_IMETHODIMP nsEditor::CreateTxnForSplitNode(nsIDOMNode *aNode,
                                          uint32_t    aOffset,
                                          SplitElementTxn **aTxn)
 {
   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
   nsRefPtr<SplitElementTxn> txn = new SplitElementTxn();
   nsresult rv = txn->Init(this, aNode, aOffset);
   if (NS_SUCCEEDED(rv))
   {
     txn.forget(aTxn);
   }
   return rv;
 }
 NS_IMETHODIMP nsEditor::CreateTxnForJoinNode(nsIDOMNode  *aLeftNode,
                                              nsIDOMNode  *aRightNode,
                                              JoinElementTxn **aTxn)
 {
   NS_ENSURE_TRUE(aLeftNode && aRightNode, NS_ERROR_NULL_POINTER);
   nsRefPtr<JoinElementTxn> txn = new JoinElementTxn();
   nsresult rv = txn->Init(this, aLeftNode, aRightNode);
   if (NS_SUCCEEDED(rv))
   {
     txn.forget(aTxn);
   }
   return rv;
 }
 // END nsEditor core implementation
 // BEGIN nsEditor public helper methods
 nsresult
 nsEditor::SplitNodeImpl(nsIDOMNode * aExistingRightNode,
                         int32_t      aOffset,
                         nsIDOMNode*  aNewLeftNode,
                         nsIDOMNode*  aParent)
 {
   NS_ASSERTION(((nullptr!=aExistingRightNode) &&
                 (nullptr!=aNewLeftNode) &&
                 (nullptr!=aParent)),
                 "null arg");
   nsresult result;
   if ((nullptr!=aExistingRightNode) &&
       (nullptr!=aNewLeftNode) &&
       (nullptr!=aParent))
   {
     // get selection
     nsCOMPtr<nsISelection> selection;
     result = GetSelection(getter_AddRefs(selection));
     NS_ENSURE_SUCCESS(result, result);
     NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
     // remember some selection points
     nsCOMPtr<nsIDOMNode> selStartNode, selEndNode;
     int32_t selStartOffset, selEndOffset;
     result = GetStartNodeAndOffset(selection, getter_AddRefs(selStartNode), &selStartOffset);
     if (NS_FAILED(result)) selStartNode = nullptr;  // if selection is cleared, remember that
     result = GetEndNodeAndOffset(selection, getter_AddRefs(selEndNode), &selEndOffset);
     if (NS_FAILED(result)) selStartNode = nullptr;  // if selection is cleared, remember that
     nsCOMPtr<nsIDOMNode> resultNode;
     result = aParent->InsertBefore(aNewLeftNode, aExistingRightNode, getter_AddRefs(resultNode));
     //printf("  after insert\n"); content->List();  // DEBUG
     if (NS_SUCCEEDED(result))
     {
       // split the children between the 2 nodes
       // at this point, aExistingRightNode has all the children
       // move all the children whose index is < aOffset to aNewLeftNode
       if (0<=aOffset) // don't bother unless we're going to move at least one child
       {
         // if it's a text node, just shuffle around some text
         nsCOMPtr<nsIDOMCharacterData> rightNodeAsText( do_QueryInterface(aExistingRightNode) );
         nsCOMPtr<nsIDOMCharacterData> leftNodeAsText( do_QueryInterface(aNewLeftNode) );
         if (leftNodeAsText && rightNodeAsText)
         {
           // fix right node
           nsAutoString leftText;
           rightNodeAsText->SubstringData(0, aOffset, leftText);
           rightNodeAsText->DeleteData(0, aOffset);
           // fix left node
           leftNodeAsText->SetData(leftText);
           // moose
         }
         else
         {  // otherwise it's an interior node, so shuffle around the children
            // go through list backwards so deletes don't interfere with the iteration
           nsCOMPtr<nsIDOMNodeList> childNodes;
           result = aExistingRightNode->GetChildNodes(getter_AddRefs(childNodes));
           if ((NS_SUCCEEDED(result)) && (childNodes))
           {
             int32_t i=aOffset-1;
             for ( ; ((NS_SUCCEEDED(result)) && (0<=i)); i--)
             {
               nsCOMPtr<nsIDOMNode> childNode;
               result = childNodes->Item(i, getter_AddRefs(childNode));
               if ((NS_SUCCEEDED(result)) && (childNode))
               {
                 result = aExistingRightNode->RemoveChild(childNode, getter_AddRefs(resultNode));
                 //printf("  after remove\n"); content->List();  // DEBUG
                 if (NS_SUCCEEDED(result))
                 {
                   nsCOMPtr<nsIDOMNode> firstChild;
                   aNewLeftNode->GetFirstChild(getter_AddRefs(firstChild));
                   result = aNewLeftNode->InsertBefore(childNode, firstChild, getter_AddRefs(resultNode));
                   //printf("  after append\n"); content->List();  // DEBUG
                 }
               }
             }
           }
         }
         // handle selection
         nsCOMPtr<nsIPresShell> ps = GetPresShell();
         if (ps)
           ps->FlushPendingNotifications(Flush_Frames);
         if (GetShouldTxnSetSelection())
         {
           // editor wants us to set selection at split point
           selection->Collapse(aNewLeftNode, aOffset);
         }
         else if (selStartNode)
         {
           // else adjust the selection if needed.  if selStartNode is null, then there was no selection.
           // HACK: this is overly simplified - multi-range selections need more work than this
           if (selStartNode.get() == aExistingRightNode)
           {
             if (selStartOffset < aOffset)
             {
               selStartNode = aNewLeftNode;
             }
             else
             {
               selStartOffset -= aOffset;
             }
           }
           if (selEndNode.get() == aExistingRightNode)
           {
             if (selEndOffset < aOffset)
             {
               selEndNode = aNewLeftNode;
             }
             else
             {
               selEndOffset -= aOffset;
             }
           }
           selection->Collapse(selStartNode,selStartOffset);
           selection->Extend(selEndNode,selEndOffset);
         }
       }
     }
   }
   else
     result = NS_ERROR_INVALID_ARG;
   return result;
 }
 nsresult
 nsEditor::JoinNodesImpl(nsINode* aNodeToKeep,
                         nsINode* aNodeToJoin,
                         nsINode* aParent)
 {
   MOZ_ASSERT(aNodeToKeep);
   MOZ_ASSERT(aNodeToJoin);
   MOZ_ASSERT(aParent);
   nsRefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
   // remember some selection points
   nsCOMPtr<nsINode> selStartNode;
   int32_t selStartOffset;
   nsresult result = GetStartNodeAndOffset(selection, getter_AddRefs(selStartNode), &selStartOffset);
   if (NS_FAILED(result)) {
     selStartNode = nullptr;
   }
   nsCOMPtr<nsINode> selEndNode;
   int32_t selEndOffset;
   result = GetEndNodeAndOffset(selection, getter_AddRefs(selEndNode), &selEndOffset);
   // Joe or Kin should comment here on why the following line is not a copy/paste error
   if (NS_FAILED(result)) {
     selStartNode = nullptr;
   }
   uint32_t firstNodeLength = aNodeToJoin->Length();
   int32_t joinOffset;
   GetNodeLocation(aNodeToJoin, &joinOffset);
   int32_t keepOffset;
   nsINode* parent = GetNodeLocation(aNodeToKeep, &keepOffset);
   // if selection endpoint is between the nodes, remember it as being
   // in the one that is going away instead.  This simplifies later selection
   // adjustment logic at end of this method.
   if (selStartNode) {
     if (selStartNode == parent &&
         joinOffset < selStartOffset && selStartOffset <= keepOffset) {
       selStartNode = aNodeToJoin;
       selStartOffset = firstNodeLength;
     }
     if (selEndNode == parent &&
         joinOffset < selEndOffset && selEndOffset <= keepOffset) {
       selEndNode = aNodeToJoin;
       selEndOffset = firstNodeLength;
     }
   }
   // ok, ready to do join now.
   // if it's a text node, just shuffle around some text
   nsCOMPtr<nsIDOMCharacterData> keepNodeAsText( do_QueryInterface(aNodeToKeep) );
   nsCOMPtr<nsIDOMCharacterData> joinNodeAsText( do_QueryInterface(aNodeToJoin) );
   if (keepNodeAsText && joinNodeAsText) {
     nsAutoString rightText;
     nsAutoString leftText;
     keepNodeAsText->GetData(rightText);
     joinNodeAsText->GetData(leftText);
     leftText += rightText;
     keepNodeAsText->SetData(leftText);
   } else {
     // otherwise it's an interior node, so shuffle around the children
     nsCOMPtr<nsINodeList> childNodes = aNodeToJoin->ChildNodes();
     MOZ_ASSERT(childNodes);
     // remember the first child in aNodeToKeep, we'll insert all the children of aNodeToJoin in front of it
     // GetFirstChild returns nullptr firstNode if aNodeToKeep has no children, that's ok.
     nsCOMPtr<nsIContent> firstNode = aNodeToKeep->GetFirstChild();
     // have to go through the list backwards to keep deletes from interfering with iteration
     for (uint32_t i = childNodes->Length(); i > 0; --i) {
       nsCOMPtr<nsIContent> childNode = childNodes->Item(i - 1);
       if (childNode) {
         // prepend children of aNodeToJoin
         ErrorResult err;
         aNodeToKeep->InsertBefore(*childNode, firstNode, err);
         NS_ENSURE_SUCCESS(err.ErrorCode(), err.ErrorCode());
         firstNode = childNode.forget();
       }
     }
   }
   // delete the extra node
   ErrorResult err;
   aParent->RemoveChild(*aNodeToJoin, err);
   if (GetShouldTxnSetSelection()) {
     // editor wants us to set selection at join point
     selection->Collapse(aNodeToKeep, SafeCast<int32_t>(firstNodeLength));
   } else if (selStartNode) {
     // and adjust the selection if needed
     // HACK: this is overly simplified - multi-range selections need more work than this
     bool bNeedToAdjust = false;
     // check to see if we joined nodes where selection starts
     if (selStartNode == aNodeToJoin) {
       bNeedToAdjust = true;
       selStartNode = aNodeToKeep;
     } else if (selStartNode == aNodeToKeep) {
       bNeedToAdjust = true;
       selStartOffset += firstNodeLength;
     }
     // check to see if we joined nodes where selection ends
     if (selEndNode == aNodeToJoin) {
       bNeedToAdjust = true;
       selEndNode = aNodeToKeep;
     } else if (selEndNode == aNodeToKeep) {
       bNeedToAdjust = true;
       selEndOffset += firstNodeLength;
     }
     // adjust selection if needed
     if (bNeedToAdjust) {
       selection->Collapse(selStartNode, selStartOffset);
       selection->Extend(selEndNode, selEndOffset);
     }
   }
   return err.ErrorCode();
 }
 int32_t
 nsEditor::GetChildOffset(nsIDOMNode* aChild, nsIDOMNode* aParent)
 {
   MOZ_ASSERT(aChild && aParent);
   nsCOMPtr<nsINode> parent = do_QueryInterface(aParent);
   nsCOMPtr<nsINode> child = do_QueryInterface(aChild);
   MOZ_ASSERT(parent && child);
   int32_t idx = parent->IndexOf(child);
   MOZ_ASSERT(idx != -1);
   return idx;
 }
 // static
 already_AddRefed<nsIDOMNode>
 nsEditor::GetNodeLocation(nsIDOMNode* aChild, int32_t* outOffset)
 {
   MOZ_ASSERT(aChild && outOffset);
   NS_ENSURE_TRUE(aChild && outOffset, nullptr);
   *outOffset = -1;
   nsCOMPtr<nsIDOMNode> parent;
   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
     aChild->GetParentNode(getter_AddRefs(parent))));
   if (parent) {
     *outOffset = GetChildOffset(aChild, parent);
   }
   return parent.forget();
 }
 nsINode*
 nsEditor::GetNodeLocation(nsINode* aChild, int32_t* aOffset)
 {
   MOZ_ASSERT(aChild);
   MOZ_ASSERT(aOffset);
   nsINode* parent = aChild->GetParentNode();
   if (parent) {
     *aOffset = parent->IndexOf(aChild);
     MOZ_ASSERT(*aOffset != -1);
   } else {
     *aOffset = -1;
   }
   return parent;
 }
 // returns the number of things inside aNode.
 // If aNode is text, returns number of characters. If not, returns number of children nodes.
 nsresult
 nsEditor::GetLengthOfDOMNode(nsIDOMNode *aNode, uint32_t &aCount)
 {
   aCount = 0;
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
   aCount = node->Length();
   return NS_OK;
 }
 nsresult
 nsEditor::GetPriorNode(nsIDOMNode  *aParentNode,
                        int32_t      aOffset,
                        bool         aEditableNode,
                        nsCOMPtr<nsIDOMNode> *aResultNode,
                        bool         bNoBlockCrossing)
 {
   NS_ENSURE_TRUE(aResultNode, NS_ERROR_NULL_POINTER);
   *aResultNode = nullptr;
   nsCOMPtr<nsINode> parentNode = do_QueryInterface(aParentNode);
   NS_ENSURE_TRUE(parentNode, NS_ERROR_NULL_POINTER);
   *aResultNode = do_QueryInterface(GetPriorNode(parentNode, aOffset,
                                                 aEditableNode,
                                                 bNoBlockCrossing));
   return NS_OK;
 }
 nsIContent*
 nsEditor::GetPriorNode(nsINode* aParentNode,
                        int32_t aOffset,
                        bool aEditableNode,
                        bool aNoBlockCrossing)
 {
   MOZ_ASSERT(aParentNode);
   // If we are at the beginning of the node, or it is a text node, then just
   // look before it.
   if (!aOffset || aParentNode->NodeType() == nsIDOMNode::TEXT_NODE) {
     if (aNoBlockCrossing && IsBlockNode(aParentNode)) {
       // If we aren't allowed to cross blocks, don't look before this block.
       return nullptr;
     }
     return GetPriorNode(aParentNode, aEditableNode, aNoBlockCrossing);
   }
   // else look before the child at 'aOffset'
   if (nsIContent* child = aParentNode->GetChildAt(aOffset)) {
     return GetPriorNode(child, aEditableNode, aNoBlockCrossing);
   }
   // unless there isn't one, in which case we are at the end of the node
   // and want the deep-right child.
   nsIContent* resultNode = GetRightmostChild(aParentNode, aNoBlockCrossing);
   if (!resultNode || !aEditableNode || IsEditable(resultNode)) {
     return resultNode;
   }
   // restart the search from the non-editable node we just found
   return GetPriorNode(resultNode, aEditableNode, aNoBlockCrossing);
 }
 nsresult
 nsEditor::GetNextNode(nsIDOMNode   *aParentNode,
                       int32_t      aOffset,
                       bool         aEditableNode,
                       nsCOMPtr<nsIDOMNode> *aResultNode,
                       bool         bNoBlockCrossing)
 {
   NS_ENSURE_TRUE(aResultNode, NS_ERROR_NULL_POINTER);
   *aResultNode = nullptr;
   nsCOMPtr<nsINode> parentNode = do_QueryInterface(aParentNode);
   NS_ENSURE_TRUE(parentNode, NS_ERROR_NULL_POINTER);
   *aResultNode = do_QueryInterface(GetNextNode(parentNode, aOffset,
                                                aEditableNode,
                                                bNoBlockCrossing));
   return NS_OK;
 }
 nsIContent*
 nsEditor::GetNextNode(nsINode* aParentNode,
                       int32_t aOffset,
                       bool aEditableNode,
                       bool aNoBlockCrossing)
 {
   MOZ_ASSERT(aParentNode);
   // if aParentNode is a text node, use its location instead
   if (aParentNode->NodeType() == nsIDOMNode::TEXT_NODE) {
     nsINode* parent = aParentNode->GetParentNode();
     NS_ENSURE_TRUE(parent, nullptr);
     aOffset = parent->IndexOf(aParentNode) + 1; // _after_ the text node
     aParentNode = parent;
   }
   // look at the child at 'aOffset'
   nsIContent* child = aParentNode->GetChildAt(aOffset);
   if (child) {
     if (aNoBlockCrossing && IsBlockNode(child)) {
       return child;
     }
     nsIContent* resultNode = GetLeftmostChild(child, aNoBlockCrossing);
     if (!resultNode) {
       return child;
     }
     if (!IsDescendantOfEditorRoot(resultNode)) {
       return nullptr;
     }
     if (!aEditableNode || IsEditable(resultNode)) {
       return resultNode;
     }
     // restart the search from the non-editable node we just found
     return GetNextNode(resultNode, aEditableNode, aNoBlockCrossing);
   }
   // unless there isn't one, in which case we are at the end of the node
   // and want the next one.
   if (aNoBlockCrossing && IsBlockNode(aParentNode)) {
     // don't cross out of parent block
     return nullptr;
   }
   return GetNextNode(aParentNode, aEditableNode, aNoBlockCrossing);
 }
 nsresult
 nsEditor::GetPriorNode(nsIDOMNode  *aCurrentNode,
                        bool         aEditableNode,
                        nsCOMPtr<nsIDOMNode> *aResultNode,
                        bool         bNoBlockCrossing)
 {
   NS_ENSURE_TRUE(aResultNode, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsINode> currentNode = do_QueryInterface(aCurrentNode);
   NS_ENSURE_TRUE(currentNode, NS_ERROR_NULL_POINTER);
   *aResultNode = do_QueryInterface(GetPriorNode(currentNode, aEditableNode,
                                                 bNoBlockCrossing));
   return NS_OK;
 }
 nsIContent*
 nsEditor::GetPriorNode(nsINode* aCurrentNode, bool aEditableNode,
                        bool aNoBlockCrossing /* = false */)
 {
   MOZ_ASSERT(aCurrentNode);
   if (!IsDescendantOfEditorRoot(aCurrentNode)) {
     return nullptr;
   }
   return FindNode(aCurrentNode, false, aEditableNode, aNoBlockCrossing);
 }
 nsIContent*
 nsEditor::FindNextLeafNode(nsINode  *aCurrentNode,
                            bool      aGoForward,
                            bool      bNoBlockCrossing)
 {
   // called only by GetPriorNode so we don't need to check params.
   NS_PRECONDITION(IsDescendantOfEditorRoot(aCurrentNode) &&
                   !IsEditorRoot(aCurrentNode),
                   "Bogus arguments");
   nsINode* cur = aCurrentNode;
   for (;;) {
     // if aCurrentNode has a sibling in the right direction, return
     // that sibling's closest child (or itself if it has no children)
     nsIContent* sibling =
       aGoForward ? cur->GetNextSibling() : cur->GetPreviousSibling();
     if (sibling) {
       if (bNoBlockCrossing && IsBlockNode(sibling)) {
         // don't look inside prevsib, since it is a block
         return sibling;
       }
       nsIContent *leaf =
         aGoForward ? GetLeftmostChild(sibling, bNoBlockCrossing) :
                      GetRightmostChild(sibling, bNoBlockCrossing);
       if (!leaf) {
         return sibling;
       }
       return leaf;
     }
     nsINode *parent = cur->GetParentNode();
     if (!parent) {
       return nullptr;
     }
     NS_ASSERTION(IsDescendantOfEditorRoot(parent),
                  "We started with a proper descendant of root, and should stop "
                  "if we ever hit the root, so we better have a descendant of "
                  "root now!");
     if (IsEditorRoot(parent) ||
         (bNoBlockCrossing && IsBlockNode(parent))) {
       return nullptr;
     }
     cur = parent;
   }
   NS_NOTREACHED("What part of for(;;) do you not understand?");
   return nullptr;
 }
 nsresult
 nsEditor::GetNextNode(nsIDOMNode* aCurrentNode,
                       bool aEditableNode,
                       nsCOMPtr<nsIDOMNode> *aResultNode,
                       bool bNoBlockCrossing)
 {
   nsCOMPtr<nsINode> currentNode = do_QueryInterface(aCurrentNode);
   if (!currentNode || !aResultNode) {
     return NS_ERROR_NULL_POINTER;
   }
   *aResultNode = do_QueryInterface(GetNextNode(currentNode, aEditableNode,
                                                bNoBlockCrossing));
   return NS_OK;
 }
 nsIContent*
 nsEditor::GetNextNode(nsINode* aCurrentNode,
                       bool aEditableNode,
                       bool bNoBlockCrossing)
 {
   MOZ_ASSERT(aCurrentNode);
   if (!IsDescendantOfEditorRoot(aCurrentNode)) {
     return nullptr;
   }
   return FindNode(aCurrentNode, true, aEditableNode, bNoBlockCrossing);
 }
 nsIContent*
 nsEditor::FindNode(nsINode *aCurrentNode,
                    bool     aGoForward,
                    bool     aEditableNode,
                    bool     bNoBlockCrossing)
 {
   if (IsEditorRoot(aCurrentNode)) {
     // Don't allow traversal above the root node! This helps
     // prevent us from accidentally editing browser content
     // when the editor is in a text widget.
     return nullptr;
   }
   nsCOMPtr<nsIContent> candidate =
     FindNextLeafNode(aCurrentNode, aGoForward, bNoBlockCrossing);
   if (!candidate) {
     return nullptr;
   }
   if (!aEditableNode || IsEditable(candidate)) {
     return candidate;
   }
   return FindNode(candidate, aGoForward, aEditableNode, bNoBlockCrossing);
 }
 nsIDOMNode*
 nsEditor::GetRightmostChild(nsIDOMNode* aCurrentNode,
                             bool bNoBlockCrossing)
 {
   nsCOMPtr<nsINode> currentNode = do_QueryInterface(aCurrentNode);
   nsIContent* result = GetRightmostChild(currentNode, bNoBlockCrossing);
   return result ? result->AsDOMNode() : nullptr;
 }
 nsIContent*
 nsEditor::GetRightmostChild(nsINode *aCurrentNode,
                             bool     bNoBlockCrossing)
 {
   NS_ENSURE_TRUE(aCurrentNode, nullptr);
   nsIContent *cur = aCurrentNode->GetLastChild();
   if (!cur) {
     return nullptr;
   }
   for (;;) {
     if (bNoBlockCrossing && IsBlockNode(cur)) {
       return cur;
     }
     nsIContent* next = cur->GetLastChild();
     if (!next) {
       return cur;
     }
     cur = next;
   }
   NS_NOTREACHED("What part of for(;;) do you not understand?");
   return nullptr;
 }
 nsIContent*
 nsEditor::GetLeftmostChild(nsINode *aCurrentNode,
                            bool     bNoBlockCrossing)
 {
   NS_ENSURE_TRUE(aCurrentNode, nullptr);
   nsIContent *cur = aCurrentNode->GetFirstChild();
   if (!cur) {
     return nullptr;
   }
   for (;;) {
     if (bNoBlockCrossing && IsBlockNode(cur)) {
       return cur;
     }
     nsIContent *next = cur->GetFirstChild();
     if (!next) {
       return cur;
     }
     cur = next;
   }
   NS_NOTREACHED("What part of for(;;) do you not understand?");
   return nullptr;
 }
 nsIDOMNode*
 nsEditor::GetLeftmostChild(nsIDOMNode* aCurrentNode,
                            bool bNoBlockCrossing)
 {
   nsCOMPtr<nsINode> currentNode = do_QueryInterface(aCurrentNode);
   nsIContent* result = GetLeftmostChild(currentNode, bNoBlockCrossing);
   return result ? result->AsDOMNode() : nullptr;
 }
 bool
 nsEditor::IsBlockNode(nsIDOMNode* aNode)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   return IsBlockNode(node);
 }
 bool
 nsEditor::IsBlockNode(nsINode* aNode)
 {
   // stub to be overridden in nsHTMLEditor.
   // screwing around with the class hierarchy here in order
   // to not duplicate the code in GetNextNode/GetPrevNode
   // across both nsEditor/nsHTMLEditor.
   return false;
 }
 bool
 nsEditor::CanContain(nsIDOMNode* aParent, nsIDOMNode* aChild)
 {
   nsCOMPtr<nsIContent> parent = do_QueryInterface(aParent);
   NS_ENSURE_TRUE(parent, false);
   switch (parent->NodeType()) {
   case nsIDOMNode::ELEMENT_NODE:
   case nsIDOMNode::DOCUMENT_FRAGMENT_NODE:
     return TagCanContain(parent->Tag(), aChild);
   }
   return false;
 }
 bool
 nsEditor::CanContainTag(nsIDOMNode* aParent, nsIAtom* aChildTag)
 {
   nsCOMPtr<nsIContent> parent = do_QueryInterface(aParent);
   NS_ENSURE_TRUE(parent, false);
   switch (parent->NodeType()) {
   case nsIDOMNode::ELEMENT_NODE:
   case nsIDOMNode::DOCUMENT_FRAGMENT_NODE:
     return TagCanContainTag(parent->Tag(), aChildTag);
   }
   return false;
 }
 bool
 nsEditor::TagCanContain(nsIAtom* aParentTag, nsIDOMNode* aChild)
 {
   nsCOMPtr<nsIContent> child = do_QueryInterface(aChild);
   NS_ENSURE_TRUE(child, false);
   switch (child->NodeType()) {
   case nsIDOMNode::TEXT_NODE:
   case nsIDOMNode::ELEMENT_NODE:
   case nsIDOMNode::DOCUMENT_FRAGMENT_NODE:
     return TagCanContainTag(aParentTag, child->Tag());
   }
   return false;
 }
 bool
 nsEditor::TagCanContainTag(nsIAtom* aParentTag, nsIAtom* aChildTag)
 {
   return true;
 }
 bool
 nsEditor::IsRoot(nsIDOMNode* inNode)
 {
   NS_ENSURE_TRUE(inNode, false);
   nsCOMPtr<nsIDOMNode> rootNode = do_QueryInterface(GetRoot());
   return inNode == rootNode;
 }
 bool
 nsEditor::IsRoot(nsINode* inNode)
 {
   NS_ENSURE_TRUE(inNode, false);
   nsCOMPtr<nsINode> rootNode = GetRoot();
   return inNode == rootNode;
 }
 bool
 nsEditor::IsEditorRoot(nsINode* aNode)
 {
   NS_ENSURE_TRUE(aNode, false);
   nsCOMPtr<nsINode> rootNode = GetEditorRoot();
   return aNode == rootNode;
 }
 bool
 nsEditor::IsDescendantOfRoot(nsIDOMNode* inNode)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(inNode);
   return IsDescendantOfRoot(node);
 }
 bool
 nsEditor::IsDescendantOfRoot(nsINode* inNode)
 {
   NS_ENSURE_TRUE(inNode, false);
   nsCOMPtr<nsIContent> root = GetRoot();
   NS_ENSURE_TRUE(root, false);
   return nsContentUtils::ContentIsDescendantOf(inNode, root);
 }
 bool
 nsEditor::IsDescendantOfEditorRoot(nsIDOMNode* aNode)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   return IsDescendantOfEditorRoot(node);
 }
 bool
 nsEditor::IsDescendantOfEditorRoot(nsINode* aNode)
 {
   NS_ENSURE_TRUE(aNode, false);
   nsCOMPtr<nsIContent> root = GetEditorRoot();
   NS_ENSURE_TRUE(root, false);
   return nsContentUtils::ContentIsDescendantOf(aNode, root);
 }
 bool
 nsEditor::IsContainer(nsIDOMNode *aNode)
 {
   return aNode ? true : false;
 }
 static inline bool
 IsElementVisible(dom::Element* aElement)
 {
   if (aElement->GetPrimaryFrame()) {
     // It's visible, for our purposes
     return true;
   }
   nsIContent *cur = aElement;
   for (; ;) {
     // Walk up the tree looking for the nearest ancestor with a frame.
     // The state of the child right below it will determine whether
     // we might possibly have a frame or not.
     bool haveLazyBitOnChild = cur->HasFlag(NODE_NEEDS_FRAME);
     cur = cur->GetFlattenedTreeParent();
     if (!cur) {
       if (!haveLazyBitOnChild) {
         // None of our ancestors have lazy bits set, so we shouldn't
         // have a frame
         return false;
       }
       // The root has a lazy frame construction bit.  We need to check
       // our style.
       break;
     }
     if (cur->GetPrimaryFrame()) {
       if (!haveLazyBitOnChild) {
         // Our ancestor directly under |cur| doesn't have lazy bits;
         // that means we won't get a frame
         return false;
       }
       if (cur->GetPrimaryFrame()->IsLeaf()) {
         // Nothing under here will ever get frames
         return false;
       }
       // Otherwise, we might end up with a frame when that lazy bit is
       // processed.  Figure out our actual style.
       break;
     }
   }
   // Now it might be that we have no frame because we're in a
   // display:none subtree, or it might be that we're just dealing with
   // lazy frame construction and it hasn't happened yet.  Check which
   // one it is.
   nsRefPtr<nsStyleContext> styleContext =
     nsComputedDOMStyle::GetStyleContextForElementNoFlush(aElement,
                                                          nullptr, nullptr);
   if (styleContext) {
     return styleContext->StyleDisplay()->mDisplay != NS_STYLE_DISPLAY_NONE;
   }
   return false;
 }
 bool
 nsEditor::IsEditable(nsIDOMNode *aNode)
 {
   nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
   return IsEditable(content);
 }
 bool
 nsEditor::IsEditable(nsIContent *aNode)
 {
   NS_ENSURE_TRUE(aNode, false);
   if (IsMozEditorBogusNode(aNode) || !IsModifiableNode(aNode)) return false;
   // see if it has a frame.  If so, we'll edit it.
   // special case for textnodes: frame must have width.
   if (aNode->IsElement() && !IsElementVisible(aNode->AsElement())) {
     // If the element has no frame, it's not editable.  Note that we
     // need to check IsElement() here, because some of our tests
     // rely on frameless textnodes being visible.
     return false;
   }
   switch (aNode->NodeType()) {
     case nsIDOMNode::ELEMENT_NODE:
     case nsIDOMNode::TEXT_NODE:
       return true; // element or text node; not invisible
     default:
       return false;
   }
 }
 bool
 nsEditor::IsMozEditorBogusNode(nsIContent *element)
 {
   return element &&
          element->AttrValueIs(kNameSpaceID_None, kMOZEditorBogusNodeAttrAtom,
                               kMOZEditorBogusNodeValue, eCaseMatters);
 }
 uint32_t
 nsEditor::CountEditableChildren(nsINode* aNode)
 {
   MOZ_ASSERT(aNode);
   uint32_t count = 0;
   for (nsIContent* child = aNode->GetFirstChild();
        child;
        child = child->GetNextSibling()) {
     if (IsEditable(child)) {
       ++count;
     }
   }
   return count;
 }
 //END nsEditor static utility methods
 NS_IMETHODIMP nsEditor::IncrementModificationCount(int32_t inNumMods)
 {
   uint32_t oldModCount = mModCount;
   mModCount += inNumMods;
   if ((oldModCount == 0 && mModCount != 0)
    || (oldModCount != 0 && mModCount == 0))
     NotifyDocumentListeners(eDocumentStateChanged);
   return NS_OK;
 }
 NS_IMETHODIMP nsEditor::GetModificationCount(int32_t *outModCount)
 {
   NS_ENSURE_ARG_POINTER(outModCount);
   *outModCount = mModCount;
   return NS_OK;
 }
 NS_IMETHODIMP nsEditor::ResetModificationCount()
 {
   bool doNotify = (mModCount != 0);
   mModCount = 0;
   if (doNotify)
     NotifyDocumentListeners(eDocumentStateChanged);
   return NS_OK;
 }
 //END nsEditor Private methods
 ///////////////////////////////////////////////////////////////////////////
 // GetTag: digs out the atom for the tag of this node
 //
 nsIAtom *
 nsEditor::GetTag(nsIDOMNode *aNode)
 {
   nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
   if (!content)
   {
     NS_ASSERTION(aNode, "null node passed to nsEditor::Tag()");
     return nullptr;
   }
   return content->Tag();
 }
 ///////////////////////////////////////////////////////////////////////////
 // GetTagString: digs out string for the tag of this node
 //
 nsresult
 nsEditor::GetTagString(nsIDOMNode *aNode, nsAString& outString)
 {
   if (!aNode)
   {
     NS_NOTREACHED("null node passed to nsEditor::GetTag()");
     return NS_ERROR_NULL_POINTER;
   }
   nsIAtom *atom = GetTag(aNode);
   if (!atom)
   {
     return NS_ERROR_FAILURE;
   }
   atom->ToString(outString);
   return NS_OK;
 }
 ///////////////////////////////////////////////////////////////////////////
 // NodesSameType: do these nodes have the same tag?
 //
 bool
 nsEditor::NodesSameType(nsIDOMNode *aNode1, nsIDOMNode *aNode2)
 {
   if (!aNode1 || !aNode2) {
     NS_NOTREACHED("null node passed to nsEditor::NodesSameType()");
     return false;
   }
   nsCOMPtr<nsIContent> content1 = do_QueryInterface(aNode1);
   NS_ENSURE_TRUE(content1, false);
   nsCOMPtr<nsIContent> content2 = do_QueryInterface(aNode2);
   NS_ENSURE_TRUE(content2, false);
   return AreNodesSameType(content1, content2);
 }
 /* virtual */
 bool
 nsEditor::AreNodesSameType(nsIContent* aNode1, nsIContent* aNode2)
 {
   MOZ_ASSERT(aNode1);
   MOZ_ASSERT(aNode2);
   return aNode1->Tag() == aNode2->Tag();
 }
 ///////////////////////////////////////////////////////////////////////////
 // IsTextNode: true if node of dom type text
 //
 bool
 nsEditor::IsTextNode(nsIDOMNode *aNode)
 {
   if (!aNode)
   {
     NS_NOTREACHED("null node passed to IsTextNode()");
     return false;
   }
   uint16_t nodeType;
   aNode->GetNodeType(&nodeType);
   return (nodeType == nsIDOMNode::TEXT_NODE);
 }
 bool
 nsEditor::IsTextNode(nsINode *aNode)
 {
   return aNode->NodeType() == nsIDOMNode::TEXT_NODE;
 }
 ///////////////////////////////////////////////////////////////////////////
 // GetChildAt: returns the node at this position index in the parent
 //
 nsCOMPtr<nsIDOMNode>
 nsEditor::GetChildAt(nsIDOMNode *aParent, int32_t aOffset)
 {
   nsCOMPtr<nsIDOMNode> resultNode;
   nsCOMPtr<nsIContent> parent = do_QueryInterface(aParent);
   NS_ENSURE_TRUE(parent, resultNode);
   resultNode = do_QueryInterface(parent->GetChildAt(aOffset));
   return resultNode;
 }
 ///////////////////////////////////////////////////////////////////////////
 // GetNodeAtRangeOffsetPoint: returns the node at this position in a range,
 // assuming that aParentOrNode is the node itself if it's a text node, or
 // the node's parent otherwise.
 //
 nsCOMPtr<nsIDOMNode>
 nsEditor::GetNodeAtRangeOffsetPoint(nsIDOMNode* aParentOrNode, int32_t aOffset)
 {
   if (IsTextNode(aParentOrNode)) {
     return aParentOrNode;
   }
   return GetChildAt(aParentOrNode, aOffset);
 }
 ///////////////////////////////////////////////////////////////////////////
 // GetStartNodeAndOffset: returns whatever the start parent & offset is of
 //                        the first range in the selection.
 nsresult
 nsEditor::GetStartNodeAndOffset(nsISelection *aSelection,
                                        nsIDOMNode **outStartNode,
                                        int32_t *outStartOffset)
 {
   NS_ENSURE_TRUE(outStartNode && outStartOffset && aSelection, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsINode> startNode;
   nsresult rv = GetStartNodeAndOffset(static_cast<Selection*>(aSelection),
                                       getter_AddRefs(startNode),
                                       outStartOffset);
   NS_ENSURE_SUCCESS(rv, rv);
   if (startNode) {
     NS_ADDREF(*outStartNode = startNode->AsDOMNode());
   } else {
     *outStartNode = nullptr;
   }
   return NS_OK;
 }
 nsresult
 nsEditor::GetStartNodeAndOffset(Selection* aSelection, nsINode** aStartNode,
                                 int32_t* aStartOffset)
 {
   MOZ_ASSERT(aSelection);
   MOZ_ASSERT(aStartNode);
   MOZ_ASSERT(aStartOffset);
   *aStartNode = nullptr;
   *aStartOffset = 0;
   NS_ENSURE_TRUE(aSelection->GetRangeCount(), NS_ERROR_FAILURE);
   const nsRange* range = aSelection->GetRangeAt(0);
   NS_ENSURE_TRUE(range, NS_ERROR_FAILURE);
   NS_ENSURE_TRUE(range->IsPositioned(), NS_ERROR_FAILURE);
   NS_IF_ADDREF(*aStartNode = range->GetStartParent());
   *aStartOffset = range->StartOffset();
   return NS_OK;
 }
 ///////////////////////////////////////////////////////////////////////////
 // GetEndNodeAndOffset: returns whatever the end parent & offset is of
 //                        the first range in the selection.
 nsresult
 nsEditor::GetEndNodeAndOffset(nsISelection *aSelection,
                                        nsIDOMNode **outEndNode,
                                        int32_t *outEndOffset)
 {
   NS_ENSURE_TRUE(outEndNode && outEndOffset && aSelection, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsINode> endNode;
   nsresult rv = GetEndNodeAndOffset(static_cast<Selection*>(aSelection),
                                     getter_AddRefs(endNode),
                                     outEndOffset);
   NS_ENSURE_SUCCESS(rv, rv);
   if (endNode) {
     NS_ADDREF(*outEndNode = endNode->AsDOMNode());
   } else {
     *outEndNode = nullptr;
   }
   return NS_OK;
 }
 nsresult
 nsEditor::GetEndNodeAndOffset(Selection* aSelection, nsINode** aEndNode,
                               int32_t* aEndOffset)
 {
   MOZ_ASSERT(aSelection);
   MOZ_ASSERT(aEndNode);
   MOZ_ASSERT(aEndOffset);
   *aEndNode = nullptr;
   *aEndOffset = 0;
   NS_ENSURE_TRUE(aSelection->GetRangeCount(), NS_ERROR_FAILURE);
   const nsRange* range = aSelection->GetRangeAt(0);
   NS_ENSURE_TRUE(range, NS_ERROR_FAILURE);
   NS_ENSURE_TRUE(range->IsPositioned(), NS_ERROR_FAILURE);
   NS_IF_ADDREF(*aEndNode = range->GetEndParent());
   *aEndOffset = range->EndOffset();
   return NS_OK;
 }
 ///////////////////////////////////////////////////////////////////////////
 // IsPreformatted: checks the style info for the node for the preformatted
 //                 text style.
 nsresult
 nsEditor::IsPreformatted(nsIDOMNode *aNode, bool *aResult)
 {
   nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
   NS_ENSURE_TRUE(aResult && content, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIPresShell> ps = GetPresShell();
   NS_ENSURE_TRUE(ps, NS_ERROR_NOT_INITIALIZED);
   // Look at the node (and its parent if it's not an element), and grab its style context
   nsRefPtr<nsStyleContext> elementStyle;
   if (!content->IsElement()) {
     content = content->GetParent();
   }
   if (content && content->IsElement()) {
     elementStyle = nsComputedDOMStyle::GetStyleContextForElementNoFlush(content->AsElement(),
                                                                         nullptr,
                                                                         ps);
   }
   if (!elementStyle)
   {
     // Consider nodes without a style context to be NOT preformatted:
     // For instance, this is true of JS tags inside the body (which show
     // up as #text nodes but have no style context).
     *aResult = false;
     return NS_OK;
   }
   const nsStyleText* styleText = elementStyle->StyleText();
   *aResult = styleText->WhiteSpaceIsSignificant();
   return NS_OK;
 }
 ///////////////////////////////////////////////////////////////////////////
 // SplitNodeDeep: this splits a node "deeply", splitting children as
 //                appropriate.  The place to split is represented by
 //                a dom point at {splitPointParent, splitPointOffset}.
 //                That dom point must be inside aNode, which is the node to
 //                split.  outOffset is set to the offset in the parent of aNode where
 //                the split terminates - where you would want to insert
 //                a new element, for instance, if that's why you were splitting
 //                the node.
 //
 nsresult
 nsEditor::SplitNodeDeep(nsIDOMNode *aNode,
                         nsIDOMNode *aSplitPointParent,
                         int32_t aSplitPointOffset,
                         int32_t *outOffset,
                         bool    aNoEmptyContainers,
                         nsCOMPtr<nsIDOMNode> *outLeftNode,
                         nsCOMPtr<nsIDOMNode> *outRightNode)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   NS_ENSURE_TRUE(node && aSplitPointParent && outOffset, NS_ERROR_NULL_POINTER);
   int32_t offset = aSplitPointOffset;
   if (outLeftNode)  *outLeftNode  = nullptr;
   if (outRightNode) *outRightNode = nullptr;
   nsCOMPtr<nsINode> nodeToSplit = do_QueryInterface(aSplitPointParent);
   while (nodeToSplit) {
     // need to insert rules code call here to do things like
     // not split a list if you are after the last <li> or before the first, etc.
     // for now we just have some smarts about unneccessarily splitting
     // textnodes, which should be universal enough to put straight in
     // this nsEditor routine.
     nsCOMPtr<nsIDOMCharacterData> nodeAsText = do_QueryInterface(nodeToSplit);
     uint32_t len = nodeToSplit->Length();
     bool bDoSplit = false;
     if (!(aNoEmptyContainers || nodeAsText) || (offset && (offset != (int32_t)len)))
     {
       bDoSplit = true;
       nsCOMPtr<nsIDOMNode> tempNode;
       nsresult rv = SplitNode(nodeToSplit->AsDOMNode(), offset,
                               getter_AddRefs(tempNode));
       NS_ENSURE_SUCCESS(rv, rv);
       if (outRightNode) {
         *outRightNode = nodeToSplit->AsDOMNode();
       }
       if (outLeftNode) {
         *outLeftNode = tempNode;
       }
     }
     nsINode* parentNode = nodeToSplit->GetParentNode();
     NS_ENSURE_TRUE(parentNode, NS_ERROR_FAILURE);
     if (!bDoSplit && offset) {
       // must be "end of text node" case, we didn't split it, just move past it
       offset = parentNode->IndexOf(nodeToSplit) + 1;
       if (outLeftNode) {
         *outLeftNode = nodeToSplit->AsDOMNode();
       }
     } else {
       offset = parentNode->IndexOf(nodeToSplit);
       if (outRightNode) {
         *outRightNode = nodeToSplit->AsDOMNode();
       }
     }
     if (nodeToSplit == node) {
       // we split all the way up to (and including) aNode; we're done
       break;
     }
     nodeToSplit = parentNode;
   }
   if (!nodeToSplit) {
     NS_NOTREACHED("null node obtained in nsEditor::SplitNodeDeep()");
     return NS_ERROR_FAILURE;
   }
   *outOffset = offset;
   return NS_OK;
 }
 ///////////////////////////////////////////////////////////////////////////
 // JoinNodeDeep:  this joins two like nodes "deeply", joining children as
 //                appropriate.
 nsresult
 nsEditor::JoinNodeDeep(nsIDOMNode *aLeftNode,
                        nsIDOMNode *aRightNode,
                        nsCOMPtr<nsIDOMNode> *aOutJoinNode,
                        int32_t *outOffset)
 {
   NS_ENSURE_TRUE(aLeftNode && aRightNode && aOutJoinNode && outOffset, NS_ERROR_NULL_POINTER);
   // while the rightmost children and their descendants of the left node
   // match the leftmost children and their descendants of the right node
   // join them up.  Can you say that three times fast?
   nsCOMPtr<nsIDOMNode> leftNodeToJoin = do_QueryInterface(aLeftNode);
   nsCOMPtr<nsIDOMNode> rightNodeToJoin = do_QueryInterface(aRightNode);
   nsCOMPtr<nsIDOMNode> parentNode,tmp;
   nsresult res = NS_OK;
   rightNodeToJoin->GetParentNode(getter_AddRefs(parentNode));
   while (leftNodeToJoin && rightNodeToJoin && parentNode &&
           NodesSameType(leftNodeToJoin, rightNodeToJoin))
   {
     // adjust out params
     uint32_t length;
     res = GetLengthOfDOMNode(leftNodeToJoin, length);
     NS_ENSURE_SUCCESS(res, res);
     *aOutJoinNode = rightNodeToJoin;
     *outOffset = length;
     // do the join
     res = JoinNodes(leftNodeToJoin, rightNodeToJoin, parentNode);
     NS_ENSURE_SUCCESS(res, res);
     if (IsTextNode(parentNode)) // we've joined all the way down to text nodes, we're done!
       return NS_OK;
     else
     {
       // get new left and right nodes, and begin anew
       parentNode = rightNodeToJoin;
       leftNodeToJoin = GetChildAt(parentNode, length-1);
       rightNodeToJoin = GetChildAt(parentNode, length);
       // skip over non-editable nodes
       while (leftNodeToJoin && !IsEditable(leftNodeToJoin))
       {
         leftNodeToJoin->GetPreviousSibling(getter_AddRefs(tmp));
         leftNodeToJoin = tmp;
       }
       if (!leftNodeToJoin) break;
       while (rightNodeToJoin && !IsEditable(rightNodeToJoin))
       {
         rightNodeToJoin->GetNextSibling(getter_AddRefs(tmp));
         rightNodeToJoin = tmp;
       }
       if (!rightNodeToJoin) break;
     }
   }
   return res;
 }
 void
 nsEditor::BeginUpdateViewBatch()
 {
   NS_PRECONDITION(mUpdateCount >= 0, "bad state");
   if (0 == mUpdateCount)
   {
     // Turn off selection updates and notifications.
     nsCOMPtr<nsISelection> selection;
     GetSelection(getter_AddRefs(selection));
     if (selection)
     {
       nsCOMPtr<nsISelectionPrivate> selPrivate(do_QueryInterface(selection));
       selPrivate->StartBatchChanges();
     }
   }
   mUpdateCount++;
 }
 nsresult nsEditor::EndUpdateViewBatch()
 {
   NS_PRECONDITION(mUpdateCount > 0, "bad state");
   if (mUpdateCount <= 0)
   {
     mUpdateCount = 0;
     return NS_ERROR_FAILURE;
   }
   mUpdateCount--;
   if (0 == mUpdateCount)
   {
     // Turn selection updating and notifications back on.
     nsCOMPtr<nsISelection>selection;
     GetSelection(getter_AddRefs(selection));
     if (selection) {
       nsCOMPtr<nsISelectionPrivate>selPrivate(do_QueryInterface(selection));
       selPrivate->EndBatchChanges();
     }
   }
   return NS_OK;
 }
 bool
 nsEditor::GetShouldTxnSetSelection()
 {
   return mShouldTxnSetSelection;
 }
 NS_IMETHODIMP
 nsEditor::DeleteSelectionImpl(EDirection aAction,
                               EStripWrappers aStripWrappers)
 {
   MOZ_ASSERT(aStripWrappers == eStrip || aStripWrappers == eNoStrip);
   nsCOMPtr<nsISelection>selection;
   nsresult res = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   nsRefPtr<EditAggregateTxn> txn;
   nsCOMPtr<nsINode> deleteNode;
   int32_t deleteCharOffset = 0, deleteCharLength = 0;
   res = CreateTxnForDeleteSelection(aAction, getter_AddRefs(txn),
                                     getter_AddRefs(deleteNode),
                                     &deleteCharOffset, &deleteCharLength);
   nsCOMPtr<nsIDOMCharacterData> deleteCharData(do_QueryInterface(deleteNode));
   if (NS_SUCCEEDED(res))
   {
     nsAutoRules beginRulesSniffing(this, EditAction::deleteSelection, aAction);
     int32_t i;
     // Notify nsIEditActionListener::WillDelete[Selection|Text|Node]
     if (!deleteNode)
       for (i = 0; i < mActionListeners.Count(); i++)
         mActionListeners[i]->WillDeleteSelection(selection);
     else if (deleteCharData)
       for (i = 0; i < mActionListeners.Count(); i++)
         mActionListeners[i]->WillDeleteText(deleteCharData, deleteCharOffset, 1);
     else
       for (i = 0; i < mActionListeners.Count(); i++)
         mActionListeners[i]->WillDeleteNode(deleteNode->AsDOMNode());
     // Delete the specified amount
     res = DoTransaction(txn);
     // Notify nsIEditActionListener::DidDelete[Selection|Text|Node]
     if (!deleteNode)
       for (i = 0; i < mActionListeners.Count(); i++)
         mActionListeners[i]->DidDeleteSelection(selection);
     else if (deleteCharData)
       for (i = 0; i < mActionListeners.Count(); i++)
         mActionListeners[i]->DidDeleteText(deleteCharData, deleteCharOffset, 1, res);
     else
       for (i = 0; i < mActionListeners.Count(); i++)
         mActionListeners[i]->DidDeleteNode(deleteNode->AsDOMNode(), res);
   }
   return res;
 }
 // XXX: error handling in this routine needs to be cleaned up!
 NS_IMETHODIMP
 nsEditor::DeleteSelectionAndCreateNode(const nsAString& aTag,
                                            nsIDOMNode ** aNewNode)
 {
   nsresult result = DeleteSelectionAndPrepareToCreateNode();
   NS_ENSURE_SUCCESS(result, result);
   nsRefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsINode> node = selection->GetAnchorNode();
   uint32_t offset = selection->AnchorOffset();
   nsCOMPtr<nsIDOMNode> newNode;
   result = CreateNode(aTag, node->AsDOMNode(), offset,
                       getter_AddRefs(newNode));
   // XXX: ERROR_HANDLING  check result, and make sure aNewNode is set correctly
   // in success/failure cases
   *aNewNode = newNode;
   NS_IF_ADDREF(*aNewNode);
   // we want the selection to be just after the new node
   return selection->Collapse(node, offset + 1);
 }
 /* Non-interface, protected methods */
 TextComposition*
 nsEditor::GetComposition() const
 {
   return mComposition;
 }
 bool
 nsEditor::IsIMEComposing() const
 {
   return mComposition && mComposition->IsComposing();
 }
 nsresult
 nsEditor::DeleteSelectionAndPrepareToCreateNode()
 {
   nsresult res;
   nsRefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
   MOZ_ASSERT(selection->GetAnchorFocusRange());
   if (!selection->GetAnchorFocusRange()->Collapsed()) {
     res = DeleteSelection(nsIEditor::eNone, nsIEditor::eStrip);
     NS_ENSURE_SUCCESS(res, res);
     MOZ_ASSERT(selection->GetAnchorFocusRange() &&
                selection->GetAnchorFocusRange()->Collapsed(),
                "Selection not collapsed after delete");
   }
   // If the selection is a chardata node, split it if necessary and compute
   // where to put the new node
   nsCOMPtr<nsINode> node = selection->GetAnchorNode();
   MOZ_ASSERT(node, "Selection has no ranges in it");
   if (node && node->IsNodeOfType(nsINode::eDATA_NODE)) {
     NS_ASSERTION(node->GetParentNode(),
                  "It's impossible to insert into chardata with no parent -- "
                  "fix the caller");
     NS_ENSURE_STATE(node->GetParentNode());
     uint32_t offset = selection->AnchorOffset();
     if (offset == 0) {
       res = selection->Collapse(node->GetParentNode(),
                                 node->GetParentNode()->IndexOf(node));
       MOZ_ASSERT(NS_SUCCEEDED(res));
       NS_ENSURE_SUCCESS(res, res);
     } else if (offset == node->Length()) {
       res = selection->Collapse(node->GetParentNode(),
                                 node->GetParentNode()->IndexOf(node) + 1);
       MOZ_ASSERT(NS_SUCCEEDED(res));
       NS_ENSURE_SUCCESS(res, res);
     } else {
       nsCOMPtr<nsIDOMNode> tmp;
       res = SplitNode(node->AsDOMNode(), offset, getter_AddRefs(tmp));
       NS_ENSURE_SUCCESS(res, res);
       res = selection->Collapse(node->GetParentNode(),
                                 node->GetParentNode()->IndexOf(node));
       MOZ_ASSERT(NS_SUCCEEDED(res));
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   return NS_OK;
 }
 void
 nsEditor::DoAfterDoTransaction(nsITransaction *aTxn)
 {
   bool isTransientTransaction;
   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
     aTxn->GetIsTransient(&isTransientTransaction)));
   if (!isTransientTransaction)
   {
     // we need to deal here with the case where the user saved after some
     // edits, then undid one or more times. Then, the undo count is -ve,
     // but we can't let a do take it back to zero. So we flip it up to
     // a +ve number.
     int32_t modCount;
     GetModificationCount(&modCount);
     if (modCount < 0)
       modCount = -modCount;
     // don't count transient transactions
     MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
       IncrementModificationCount(1)));
   }
 }
 void
 nsEditor::DoAfterUndoTransaction()
 {
   // all undoable transactions are non-transient
   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
     IncrementModificationCount(-1)));
 }
 void
 nsEditor::DoAfterRedoTransaction()
 {
   // all redoable transactions are non-transient
   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
     IncrementModificationCount(1)));
 }
 NS_IMETHODIMP
 nsEditor::CreateTxnForSetAttribute(nsIDOMElement *aElement,
                                    const nsAString& aAttribute,
                                    const nsAString& aValue,
                                    ChangeAttributeTxn ** aTxn)
 {
   NS_ENSURE_TRUE(aElement, NS_ERROR_NULL_POINTER);
   nsRefPtr<ChangeAttributeTxn> txn = new ChangeAttributeTxn();
   nsresult rv = txn->Init(this, aElement, aAttribute, aValue, false);
   if (NS_SUCCEEDED(rv))
   {
     txn.forget(aTxn);
   }
   return rv;
 }
 NS_IMETHODIMP
 nsEditor::CreateTxnForRemoveAttribute(nsIDOMElement *aElement,
                                       const nsAString& aAttribute,
                                       ChangeAttributeTxn ** aTxn)
 {
   NS_ENSURE_TRUE(aElement, NS_ERROR_NULL_POINTER);
   nsRefPtr<ChangeAttributeTxn> txn = new ChangeAttributeTxn();
   nsresult rv = txn->Init(this, aElement, aAttribute, EmptyString(), true);
   if (NS_SUCCEEDED(rv))
   {
     txn.forget(aTxn);
   }
   return rv;
 }
 NS_IMETHODIMP nsEditor::CreateTxnForCreateElement(const nsAString& aTag,
                                                   nsIDOMNode     *aParent,
                                                   int32_t         aPosition,
                                                   CreateElementTxn ** aTxn)
 {
   NS_ENSURE_TRUE(aParent, NS_ERROR_NULL_POINTER);
   nsRefPtr<CreateElementTxn> txn = new CreateElementTxn();
   nsresult rv = txn->Init(this, aTag, aParent, aPosition);
   if (NS_SUCCEEDED(rv))
   {
     txn.forget(aTxn);
   }
   return rv;
 }
 NS_IMETHODIMP nsEditor::CreateTxnForInsertElement(nsIDOMNode * aNode,
                                                   nsIDOMNode * aParent,
                                                   int32_t      aPosition,
                                                   InsertElementTxn ** aTxn)
 {
   NS_ENSURE_TRUE(aNode && aParent, NS_ERROR_NULL_POINTER);
   nsRefPtr<InsertElementTxn> txn = new InsertElementTxn();
   nsresult rv = txn->Init(aNode, aParent, aPosition, this);
   if (NS_SUCCEEDED(rv))
   {
     txn.forget(aTxn);
   }
   return rv;
 }
 nsresult
 nsEditor::CreateTxnForDeleteNode(nsINode* aNode, DeleteNodeTxn** aTxn)
 {
   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
   nsRefPtr<DeleteNodeTxn> txn = new DeleteNodeTxn();
   nsresult res = txn->Init(this, aNode, &mRangeUpdater);
   NS_ENSURE_SUCCESS(res, res);
   txn.forget(aTxn);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::CreateTxnForIMEText(const nsAString& aStringToInsert,
                               IMETextTxn ** aTxn)
 {
   NS_ASSERTION(aTxn, "illegal value- null ptr- aTxn");
   nsRefPtr<IMETextTxn> txn = new IMETextTxn();
   // During handling IME composition, mComposition must have been initialized.
   // TODO: We can simplify IMETextTxn::Init() with TextComposition class.
   nsresult rv = txn->Init(mIMETextNode, mIMETextOffset,
                           mComposition->String().Length(),
                           mComposition->GetRanges(), aStringToInsert, this);
   if (NS_SUCCEEDED(rv))
   {
     txn.forget(aTxn);
   }
   return rv;
 }
 NS_IMETHODIMP
 nsEditor::CreateTxnForAddStyleSheet(nsCSSStyleSheet* aSheet, AddStyleSheetTxn* *aTxn)
 {
   nsRefPtr<AddStyleSheetTxn> txn = new AddStyleSheetTxn();
   nsresult rv = txn->Init(this, aSheet);
   if (NS_SUCCEEDED(rv))
   {
     txn.forget(aTxn);
   }
   return rv;
 }
 NS_IMETHODIMP
 nsEditor::CreateTxnForRemoveStyleSheet(nsCSSStyleSheet* aSheet, RemoveStyleSheetTxn* *aTxn)
 {
   nsRefPtr<RemoveStyleSheetTxn> txn = new RemoveStyleSheetTxn();
   nsresult rv = txn->Init(this, aSheet);
   if (NS_SUCCEEDED(rv))
   {
     txn.forget(aTxn);
   }
   return rv;
 }
 nsresult
 nsEditor::CreateTxnForDeleteSelection(EDirection aAction,
                                       EditAggregateTxn** aTxn,
                                       nsINode** aNode,
                                       int32_t* aOffset,
                                       int32_t* aLength)
 {
   MOZ_ASSERT(aTxn);
   *aTxn = nullptr;
   nsRefPtr<Selection> selection = GetSelection();
   NS_ENSURE_STATE(selection);
   // Check whether the selection is collapsed and we should do nothing:
   if (selection->Collapsed() && aAction == eNone) {
     return NS_OK;
   }
   // allocate the out-param transaction
   nsRefPtr<EditAggregateTxn> aggTxn = new EditAggregateTxn();
   for (int32_t rangeIdx = 0; rangeIdx < selection->GetRangeCount(); ++rangeIdx) {
     nsRefPtr<nsRange> range = selection->GetRangeAt(rangeIdx);
     NS_ENSURE_STATE(range);
     // Same with range as with selection; if it is collapsed and action
     // is eNone, do nothing.
     if (!range->Collapsed()) {
       nsRefPtr<DeleteRangeTxn> txn = new DeleteRangeTxn();
       txn->Init(this, range, &mRangeUpdater);
       aggTxn->AppendChild(txn);
     } else if (aAction != eNone) {
       // we have an insertion point.  delete the thing in front of it or
       // behind it, depending on aAction
       nsresult res = CreateTxnForDeleteInsertionPoint(range, aAction, aggTxn,
                                                       aNode, aOffset, aLength);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   aggTxn.forget(aTxn);
   return NS_OK;
 }
 nsresult
 nsEditor::CreateTxnForDeleteCharacter(nsIDOMCharacterData* aData,
                                       uint32_t             aOffset,
                                       EDirection           aDirection,
                                       DeleteTextTxn**      aTxn)
 {
   NS_ASSERTION(aDirection == eNext || aDirection == ePrevious,
                "invalid direction");
   nsAutoString data;
   aData->GetData(data);
   NS_ASSERTION(data.Length(), "Trying to delete from a zero-length node");
   NS_ENSURE_STATE(data.Length());
   uint32_t segOffset = aOffset, segLength = 1;
   if (aDirection == eNext) {
     if (segOffset + 1 < data.Length() &&
         NS_IS_HIGH_SURROGATE(data[segOffset]) &&
         NS_IS_LOW_SURROGATE(data[segOffset+1])) {
       // delete both halves of the surrogate pair
       ++segLength;
     }
   } else if (aOffset > 0) {
     --segOffset;
     if (segOffset > 0 &&
       NS_IS_LOW_SURROGATE(data[segOffset]) &&
       NS_IS_HIGH_SURROGATE(data[segOffset-1])) {
       ++segLength;
       --segOffset;
     }
   } else {
     return NS_ERROR_FAILURE;
   }
   return CreateTxnForDeleteText(aData, segOffset, segLength, aTxn);
 }
 //XXX: currently, this doesn't handle edge conditions because GetNext/GetPrior
 //are not implemented
 nsresult
 nsEditor::CreateTxnForDeleteInsertionPoint(nsRange*          aRange,
                                            EDirection        aAction,
                                            EditAggregateTxn* aTxn,
                                            nsINode**         aNode,
                                            int32_t*          aOffset,
                                            int32_t*          aLength)
 {
   MOZ_ASSERT(aAction != eNone);
   nsresult res;
   // get the node and offset of the insertion point
   nsCOMPtr<nsINode> node = aRange->GetStartParent();
   NS_ENSURE_STATE(node);
   int32_t offset = aRange->StartOffset();
   // determine if the insertion point is at the beginning, middle, or end of
   // the node
   nsCOMPtr<nsIDOMCharacterData> nodeAsCharData = do_QueryInterface(node);
   uint32_t count = node->Length();
   bool isFirst = (0 == offset);
   bool isLast  = (count == (uint32_t)offset);
   // XXX: if isFirst && isLast, then we'll need to delete the node
   //      as well as the 1 child
   // build a transaction for deleting the appropriate data
   // XXX: this has to come from rule section
   if (aAction == ePrevious && isFirst) {
     // we're backspacing from the beginning of the node.  Delete the first
     // thing to our left
     nsCOMPtr<nsIContent> priorNode = GetPriorNode(node, true);
     NS_ENSURE_STATE(priorNode);
     // there is a priorNode, so delete its last child (if chardata, delete the
     // last char). if it has no children, delete it
     nsCOMPtr<nsIDOMCharacterData> priorNodeAsCharData =
       do_QueryInterface(priorNode);
     if (priorNodeAsCharData) {
       uint32_t length = priorNode->Length();
       // Bail out for empty chardata XXX: Do we want to do something else?
       NS_ENSURE_STATE(length);
       nsRefPtr<DeleteTextTxn> txn;
       res = CreateTxnForDeleteCharacter(priorNodeAsCharData, length,
                                         ePrevious, getter_AddRefs(txn));
       NS_ENSURE_SUCCESS(res, res);
       *aOffset = txn->GetOffset();
       *aLength = txn->GetNumCharsToDelete();
       aTxn->AppendChild(txn);
     } else {
       // priorNode is not chardata, so tell its parent to delete it
       nsRefPtr<DeleteNodeTxn> txn;
       res = CreateTxnForDeleteNode(priorNode, getter_AddRefs(txn));
       NS_ENSURE_SUCCESS(res, res);
       aTxn->AppendChild(txn);
     }
     NS_ADDREF(*aNode = priorNode);
     return NS_OK;
   }
   if (aAction == eNext && isLast) {
     // we're deleting from the end of the node.  Delete the first thing to our
     // right
     nsCOMPtr<nsIContent> nextNode = GetNextNode(node, true);
     NS_ENSURE_STATE(nextNode);
     // there is a nextNode, so delete its first child (if chardata, delete the
     // first char). if it has no children, delete it
     nsCOMPtr<nsIDOMCharacterData> nextNodeAsCharData =
       do_QueryInterface(nextNode);
     if (nextNodeAsCharData) {
       uint32_t length = nextNode->Length();
       // Bail out for empty chardata XXX: Do we want to do something else?
       NS_ENSURE_STATE(length);
       nsRefPtr<DeleteTextTxn> txn;
       res = CreateTxnForDeleteCharacter(nextNodeAsCharData, 0, eNext,
                                         getter_AddRefs(txn));
       NS_ENSURE_SUCCESS(res, res);
       *aOffset = txn->GetOffset();
       *aLength = txn->GetNumCharsToDelete();
       aTxn->AppendChild(txn);
     } else {
       // nextNode is not chardata, so tell its parent to delete it
       nsRefPtr<DeleteNodeTxn> txn;
       res = CreateTxnForDeleteNode(nextNode, getter_AddRefs(txn));
       NS_ENSURE_SUCCESS(res, res);
       aTxn->AppendChild(txn);
     }
     NS_ADDREF(*aNode = nextNode);
     return NS_OK;
   }
   if (nodeAsCharData) {
     // we have chardata, so delete a char at the proper offset
     nsRefPtr<DeleteTextTxn> txn;
     res = CreateTxnForDeleteCharacter(nodeAsCharData, offset, aAction,
                                       getter_AddRefs(txn));
     NS_ENSURE_SUCCESS(res, res);
     aTxn->AppendChild(txn);
     NS_ADDREF(*aNode = node);
     *aOffset = txn->GetOffset();
     *aLength = txn->GetNumCharsToDelete();
   } else {
     // we're either deleting a node or chardata, need to dig into the next/prev
     // node to find out
     nsCOMPtr<nsINode> selectedNode;
     if (aAction == ePrevious) {
       selectedNode = GetPriorNode(node, offset, true);
     } else if (aAction == eNext) {
       selectedNode = GetNextNode(node, offset, true);
     }
     while (selectedNode &&
            selectedNode->IsNodeOfType(nsINode::eDATA_NODE) &&
            !selectedNode->Length()) {
       // Can't delete an empty chardata node (bug 762183)
       if (aAction == ePrevious) {
         selectedNode = GetPriorNode(selectedNode, true);
       } else if (aAction == eNext) {
         selectedNode = GetNextNode(selectedNode, true);
       }
     }
     NS_ENSURE_STATE(selectedNode);
     nsCOMPtr<nsIDOMCharacterData> selectedNodeAsCharData =
       do_QueryInterface(selectedNode);
     if (selectedNodeAsCharData) {
       // we are deleting from a chardata node, so do a character deletion
       uint32_t position = 0;
       if (aAction == ePrevious) {
         position = selectedNode->Length();
       }
       nsRefPtr<DeleteTextTxn> delTextTxn;
       res = CreateTxnForDeleteCharacter(selectedNodeAsCharData, position,
                                         aAction, getter_AddRefs(delTextTxn));
       NS_ENSURE_SUCCESS(res, res);
       NS_ENSURE_TRUE(delTextTxn, NS_ERROR_NULL_POINTER);
       aTxn->AppendChild(delTextTxn);
       *aOffset = delTextTxn->GetOffset();
       *aLength = delTextTxn->GetNumCharsToDelete();
     } else {
       nsRefPtr<DeleteNodeTxn> delElementTxn;
       res = CreateTxnForDeleteNode(selectedNode, getter_AddRefs(delElementTxn));
       NS_ENSURE_SUCCESS(res, res);
       NS_ENSURE_TRUE(delElementTxn, NS_ERROR_NULL_POINTER);
       aTxn->AppendChild(delElementTxn);
     }
     NS_ADDREF(*aNode = selectedNode);
   }
   return NS_OK;
 }
 nsresult
 nsEditor::CreateRange(nsIDOMNode *aStartParent, int32_t aStartOffset,
                       nsIDOMNode *aEndParent, int32_t aEndOffset,
                       nsIDOMRange **aRange)
 {
   return nsRange::CreateRange(aStartParent, aStartOffset, aEndParent,
                               aEndOffset, aRange);
 }
 nsresult
 nsEditor::AppendNodeToSelectionAsRange(nsIDOMNode *aNode)
 {
   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsISelection> selection;
   nsresult res = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   if(!selection) return NS_ERROR_FAILURE;
   nsCOMPtr<nsIDOMNode> parentNode;
   res = aNode->GetParentNode(getter_AddRefs(parentNode));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(parentNode, NS_ERROR_NULL_POINTER);
   int32_t offset = GetChildOffset(aNode, parentNode);
   nsCOMPtr<nsIDOMRange> range;
   res = CreateRange(parentNode, offset, parentNode, offset+1, getter_AddRefs(range));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(range, NS_ERROR_NULL_POINTER);
   return selection->AddRange(range);
 }
 nsresult nsEditor::ClearSelection()
 {
   nsCOMPtr<nsISelection> selection;
   nsresult res = nsEditor::GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
   return selection->RemoveAllRanges();
 }
 nsresult
 nsEditor::CreateHTMLContent(const nsAString& aTag, dom::Element** aContent)
 {
   nsCOMPtr<nsIDocument> doc = GetDocument();
   NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
   // XXX Wallpaper over editor bug (editor tries to create elements with an
   //     empty nodename).
   if (aTag.IsEmpty()) {
     NS_ERROR("Don't pass an empty tag to nsEditor::CreateHTMLContent, "
              "check caller.");
     return NS_ERROR_FAILURE;
   }
   return doc->CreateElem(aTag, nullptr, kNameSpaceID_XHTML,
                          reinterpret_cast<nsIContent**>(aContent));
 }
 nsresult
 nsEditor::SetAttributeOrEquivalent(nsIDOMElement * aElement,
                                    const nsAString & aAttribute,
                                    const nsAString & aValue,
                                    bool aSuppressTransaction)
 {
   return SetAttribute(aElement, aAttribute, aValue);
 }
 nsresult
 nsEditor::RemoveAttributeOrEquivalent(nsIDOMElement * aElement,
                                       const nsAString & aAttribute,
                                       bool aSuppressTransaction)
 {
   return RemoveAttribute(aElement, aAttribute);
 }
 nsresult
 nsEditor::HandleKeyPressEvent(nsIDOMKeyEvent* aKeyEvent)
 {
   // NOTE: When you change this method, you should also change:
   //   * editor/libeditor/text/tests/test_texteditor_keyevent_handling.html
   //   * editor/libeditor/html/tests/test_htmleditor_keyevent_handling.html
   //
   // And also when you add new key handling, you need to change the subclass's
   // HandleKeyPressEvent()'s switch statement.
   WidgetKeyboardEvent* nativeKeyEvent =
     aKeyEvent->GetInternalNSEvent()->AsKeyboardEvent();
   NS_ENSURE_TRUE(nativeKeyEvent, NS_ERROR_UNEXPECTED);
   NS_ASSERTION(nativeKeyEvent->message == NS_KEY_PRESS,
                "HandleKeyPressEvent gets non-keypress event");
   // if we are readonly or disabled, then do nothing.
   if (IsReadonly() || IsDisabled()) {
     // consume backspace for disabled and readonly textfields, to prevent
     // back in history, which could be confusing to users
     if (nativeKeyEvent->keyCode == nsIDOMKeyEvent::DOM_VK_BACK_SPACE) {
       aKeyEvent->PreventDefault();
     }
     return NS_OK;
   }
   switch (nativeKeyEvent->keyCode) {
     case nsIDOMKeyEvent::DOM_VK_META:
     case nsIDOMKeyEvent::DOM_VK_WIN:
     case nsIDOMKeyEvent::DOM_VK_SHIFT:
     case nsIDOMKeyEvent::DOM_VK_CONTROL:
     case nsIDOMKeyEvent::DOM_VK_ALT:
       aKeyEvent->PreventDefault(); // consumed
       return NS_OK;
     case nsIDOMKeyEvent::DOM_VK_BACK_SPACE:
       if (nativeKeyEvent->IsControl() || nativeKeyEvent->IsAlt() ||
           nativeKeyEvent->IsMeta() || nativeKeyEvent->IsOS()) {
         return NS_OK;
       }
       DeleteSelection(nsIEditor::ePrevious, nsIEditor::eStrip);
       aKeyEvent->PreventDefault(); // consumed
       return NS_OK;
     case nsIDOMKeyEvent::DOM_VK_DELETE:
       // on certain platforms (such as windows) the shift key
       // modifies what delete does (cmd_cut in this case).
       // bailing here to allow the keybindings to do the cut.
       if (nativeKeyEvent->IsShift() || nativeKeyEvent->IsControl() ||
           nativeKeyEvent->IsAlt() || nativeKeyEvent->IsMeta() ||
           nativeKeyEvent->IsOS()) {
         return NS_OK;
       }
       DeleteSelection(nsIEditor::eNext, nsIEditor::eStrip);
       aKeyEvent->PreventDefault(); // consumed
       return NS_OK;
   }
   return NS_OK;
 }
 nsresult
 nsEditor::HandleInlineSpellCheck(EditAction action,
                                    nsISelection *aSelection,
                                    nsIDOMNode *previousSelectedNode,
                                    int32_t previousSelectedOffset,
                                    nsIDOMNode *aStartNode,
                                    int32_t aStartOffset,
                                    nsIDOMNode *aEndNode,
                                    int32_t aEndOffset)
 {
   // Have to cast action here because this method is from an IDL
   return mInlineSpellChecker ? mInlineSpellChecker->SpellCheckAfterEditorChange(
                                  (int32_t)action, aSelection,
                                  previousSelectedNode, previousSelectedOffset,
                                  aStartNode, aStartOffset, aEndNode,
                                  aEndOffset)
                              : NS_OK;
 }
 already_AddRefed<nsIContent>
 nsEditor::FindSelectionRoot(nsINode *aNode)
 {
   nsCOMPtr<nsIContent> rootContent = GetRoot();
   return rootContent.forget();
 }
 nsresult
 nsEditor::InitializeSelection(nsIDOMEventTarget* aFocusEventTarget)
 {
   nsCOMPtr<nsINode> targetNode = do_QueryInterface(aFocusEventTarget);
   NS_ENSURE_TRUE(targetNode, NS_ERROR_INVALID_ARG);
   nsCOMPtr<nsIContent> selectionRootContent = FindSelectionRoot(targetNode);
   if (!selectionRootContent) {
     return NS_OK;
   }
   bool isTargetDoc =
     targetNode->NodeType() == nsIDOMNode::DOCUMENT_NODE &&
     targetNode->HasFlag(NODE_IS_EDITABLE);
   nsCOMPtr<nsISelection> selection;
   nsresult rv = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(rv, rv);
   nsCOMPtr<nsIPresShell> presShell = GetPresShell();
   NS_ENSURE_TRUE(presShell, NS_ERROR_NOT_INITIALIZED);
   nsCOMPtr<nsISelectionController> selCon;
   rv = GetSelectionController(getter_AddRefs(selCon));
   NS_ENSURE_SUCCESS(rv, rv);
   nsCOMPtr<nsISelectionPrivate> selectionPrivate =
     do_QueryInterface(selection);
   NS_ENSURE_TRUE(selectionPrivate, NS_ERROR_UNEXPECTED);
   // Init the caret
   nsRefPtr<nsCaret> caret = presShell->GetCaret();
   NS_ENSURE_TRUE(caret, NS_ERROR_UNEXPECTED);
   caret->SetIgnoreUserModify(false);
   caret->SetCaretDOMSelection(selection);
   selCon->SetCaretReadOnly(IsReadonly());
   selCon->SetCaretEnabled(true);
   // Init selection
   selCon->SetDisplaySelection(nsISelectionController::SELECTION_ON);
   selCon->SetSelectionFlags(nsISelectionDisplay::DISPLAY_ALL);
   selCon->RepaintSelection(nsISelectionController::SELECTION_NORMAL);
   // If the computed selection root isn't root content, we should set it
   // as selection ancestor limit.  However, if that is root element, it means
   // there is not limitation of the selection, then, we must set nullptr.
   // NOTE: If we set a root element to the ancestor limit, some selection
   // methods don't work fine.
   if (selectionRootContent->GetParent()) {
     selectionPrivate->SetAncestorLimiter(selectionRootContent);
   } else {
     selectionPrivate->SetAncestorLimiter(nullptr);
   }
   // XXX What case needs this?
   if (isTargetDoc) {
     int32_t rangeCount;
     selection->GetRangeCount(&rangeCount);
     if (rangeCount == 0) {
       BeginningOfDocument();
     }
   }
   return NS_OK;
 }
 void
 nsEditor::FinalizeSelection()
 {
   nsCOMPtr<nsISelectionController> selCon;
   nsresult rv = GetSelectionController(getter_AddRefs(selCon));
   NS_ENSURE_SUCCESS_VOID(rv);
   nsCOMPtr<nsISelection> selection;
   rv = selCon->GetSelection(nsISelectionController::SELECTION_NORMAL,
                             getter_AddRefs(selection));
   NS_ENSURE_SUCCESS_VOID(rv);
   nsCOMPtr<nsISelectionPrivate> selectionPrivate = do_QueryInterface(selection);
   NS_ENSURE_TRUE_VOID(selectionPrivate);
   selectionPrivate->SetAncestorLimiter(nullptr);
   nsCOMPtr<nsIPresShell> presShell = GetPresShell();
   NS_ENSURE_TRUE_VOID(presShell);
   selCon->SetCaretEnabled(false);
   nsFocusManager* fm = nsFocusManager::GetFocusManager();
   NS_ENSURE_TRUE_VOID(fm);
   fm->UpdateCaretForCaretBrowsingMode();
   if (!HasIndependentSelection()) {
     // If this editor doesn't have an independent selection, i.e., it must
     // mean that it is an HTML editor, the selection controller is shared with
     // presShell.  So, even this editor loses focus, other part of the document
     // may still have focus.
     nsCOMPtr<nsIDocument> doc = GetDocument();
     ErrorResult ret;
     if (!doc || !doc->HasFocus(ret)) {
       // If the document already lost focus, mark the selection as disabled.
       selCon->SetDisplaySelection(nsISelectionController::SELECTION_DISABLED);
     } else {
       // Otherwise, mark selection as normal because outside of a
       // contenteditable element should be selected with normal selection
       // color after here.
       selCon->SetDisplaySelection(nsISelectionController::SELECTION_ON);
     }
   } else if (IsFormWidget() || IsPasswordEditor() ||
              IsReadonly() || IsDisabled() || IsInputFiltered()) {
     // In <input> or <textarea>, the independent selection should be hidden
     // while this editor doesn't have focus.
     selCon->SetDisplaySelection(nsISelectionController::SELECTION_HIDDEN);
   } else {
     // Otherwise, although we're not sure how this case happens, the
     // independent selection should be marked as disabled.
     selCon->SetDisplaySelection(nsISelectionController::SELECTION_DISABLED);
   }
   selCon->RepaintSelection(nsISelectionController::SELECTION_NORMAL);
 }
 dom::Element *
 nsEditor::GetRoot()
 {
   if (!mRootElement)
   {
     nsCOMPtr<nsIDOMElement> root;
     // Let GetRootElement() do the work
     GetRootElement(getter_AddRefs(root));
   }
   return mRootElement;
 }
 dom::Element*
 nsEditor::GetEditorRoot()
 {
   return GetRoot();
 }
 Element*
 nsEditor::GetExposedRoot()
 {
   Element* rootElement = GetRoot();
   // For plaintext editors, we need to ask the input/textarea element directly.
   if (rootElement && rootElement->IsRootOfNativeAnonymousSubtree()) {
     rootElement = rootElement->GetParent()->AsElement();
   }
   return rootElement;
 }
 nsresult
 nsEditor::DetermineCurrentDirection()
 {
   // Get the current root direction from its frame
   nsIContent* rootElement = GetExposedRoot();
   // If we don't have an explicit direction, determine our direction
   // from the content's direction
   if (!(mFlags & (nsIPlaintextEditor::eEditorLeftToRight |
                   nsIPlaintextEditor::eEditorRightToLeft))) {
     nsIFrame* frame = rootElement->GetPrimaryFrame();
     NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE);
     // Set the flag here, to enable us to use the same code path below.
     // It will be flipped before returning from the function.
     if (frame->StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL) {
       mFlags |= nsIPlaintextEditor::eEditorRightToLeft;
     } else {
       mFlags |= nsIPlaintextEditor::eEditorLeftToRight;
     }
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::SwitchTextDirection()
 {
   // Get the current root direction from its frame
   nsIContent* rootElement = GetExposedRoot();
   nsresult rv = DetermineCurrentDirection();
   NS_ENSURE_SUCCESS(rv, rv);
   // Apply the opposite direction
   if (mFlags & nsIPlaintextEditor::eEditorRightToLeft) {
     NS_ASSERTION(!(mFlags & nsIPlaintextEditor::eEditorLeftToRight),
                  "Unexpected mutually exclusive flag");
     mFlags &= ~nsIPlaintextEditor::eEditorRightToLeft;
     mFlags |= nsIPlaintextEditor::eEditorLeftToRight;
     rv = rootElement->SetAttr(kNameSpaceID_None, nsGkAtoms::dir, NS_LITERAL_STRING("ltr"), true);
   } else if (mFlags & nsIPlaintextEditor::eEditorLeftToRight) {
     NS_ASSERTION(!(mFlags & nsIPlaintextEditor::eEditorRightToLeft),
                  "Unexpected mutually exclusive flag");
     mFlags |= nsIPlaintextEditor::eEditorRightToLeft;
     mFlags &= ~nsIPlaintextEditor::eEditorLeftToRight;
     rv = rootElement->SetAttr(kNameSpaceID_None, nsGkAtoms::dir, NS_LITERAL_STRING("rtl"), true);
   }
   if (NS_SUCCEEDED(rv)) {
     FireInputEvent();
   }
   return rv;
 }
 void
 nsEditor::SwitchTextDirectionTo(uint32_t aDirection)
 {
   // Get the current root direction from its frame
   nsIContent* rootElement = GetExposedRoot();
   nsresult rv = DetermineCurrentDirection();
   NS_ENSURE_SUCCESS_VOID(rv);
   // Apply the requested direction
   if (aDirection == nsIPlaintextEditor::eEditorLeftToRight &&
       (mFlags & nsIPlaintextEditor::eEditorRightToLeft)) {
     NS_ASSERTION(!(mFlags & nsIPlaintextEditor::eEditorLeftToRight),
                  "Unexpected mutually exclusive flag");
     mFlags &= ~nsIPlaintextEditor::eEditorRightToLeft;
     mFlags |= nsIPlaintextEditor::eEditorLeftToRight;
     rv = rootElement->SetAttr(kNameSpaceID_None, nsGkAtoms::dir, NS_LITERAL_STRING("ltr"), true);
   } else if (aDirection == nsIPlaintextEditor::eEditorRightToLeft &&
              (mFlags & nsIPlaintextEditor::eEditorLeftToRight)) {
     NS_ASSERTION(!(mFlags & nsIPlaintextEditor::eEditorRightToLeft),
                  "Unexpected mutually exclusive flag");
     mFlags |= nsIPlaintextEditor::eEditorRightToLeft;
     mFlags &= ~nsIPlaintextEditor::eEditorLeftToRight;
     rv = rootElement->SetAttr(kNameSpaceID_None, nsGkAtoms::dir, NS_LITERAL_STRING("rtl"), true);
   }
   if (NS_SUCCEEDED(rv)) {
     FireInputEvent();
   }
 }
 #if DEBUG_JOE
 void
 nsEditor::DumpNode(nsIDOMNode *aNode, int32_t indent)
 {
   int32_t i;
   for (i=0; i<indent; i++)
     printf("  ");
   nsCOMPtr<nsIDOMElement> element = do_QueryInterface(aNode);
   nsCOMPtr<nsIDOMDocumentFragment> docfrag = do_QueryInterface(aNode);
   if (element || docfrag)
   {
     if (element)
     {
       nsAutoString tag;
       element->GetTagName(tag);
       printf("<%s>\n", NS_LossyConvertUTF16toASCII(tag).get());
     }
     else
     {
       printf("<document fragment>\n");
     }
     nsCOMPtr<nsIDOMNodeList> childList;
     aNode->GetChildNodes(getter_AddRefs(childList));
     NS_ENSURE_TRUE(childList, NS_ERROR_NULL_POINTER);
     uint32_t numChildren;
     childList->GetLength(&numChildren);
     nsCOMPtr<nsIDOMNode> child, tmp;
     aNode->GetFirstChild(getter_AddRefs(child));
     for (i=0; i<numChildren; i++)
     {
       DumpNode(child, indent+1);
       child->GetNextSibling(getter_AddRefs(tmp));
       child = tmp;
     }
   }
   else if (IsTextNode(aNode))
   {
     nsCOMPtr<nsIDOMCharacterData> textNode = do_QueryInterface(aNode);
     nsAutoString str;
     textNode->GetData(str);
     nsAutoCString cstr;
     LossyCopyUTF16toASCII(str, cstr);
     cstr.ReplaceChar('\n', ' ');
     printf("<textnode> %s\n", cstr.get());
   }
 }
 #endif
 bool
 nsEditor::IsModifiableNode(nsIDOMNode *aNode)
 {
   return true;
 }
 bool
 nsEditor::IsModifiableNode(nsINode *aNode)
 {
   return true;
 }
 already_AddRefed<nsIContent>
 nsEditor::GetFocusedContent()
 {
   nsCOMPtr<nsIDOMEventTarget> piTarget = GetDOMEventTarget();
   if (!piTarget) {
     return nullptr;
   }
   nsFocusManager* fm = nsFocusManager::GetFocusManager();
   NS_ENSURE_TRUE(fm, nullptr);
   nsCOMPtr<nsIContent> content = fm->GetFocusedContent();
   return SameCOMIdentity(content, piTarget) ? content.forget() : nullptr;
 }
 already_AddRefed<nsIContent>
 nsEditor::GetFocusedContentForIME()
 {
   return GetFocusedContent();
 }
 bool
 nsEditor::IsActiveInDOMWindow()
 {
   nsCOMPtr<nsIDOMEventTarget> piTarget = GetDOMEventTarget();
   if (!piTarget) {
     return false;
   }
   nsFocusManager* fm = nsFocusManager::GetFocusManager();
   NS_ENSURE_TRUE(fm, false);
   nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
   nsPIDOMWindow* ourWindow = doc->GetWindow();
   nsCOMPtr<nsPIDOMWindow> win;
   nsIContent* content =
     nsFocusManager::GetFocusedDescendant(ourWindow, false,
                                          getter_AddRefs(win));
   return SameCOMIdentity(content, piTarget);
 }
 bool
 nsEditor::IsAcceptableInputEvent(nsIDOMEvent* aEvent)
 {
   // If the event is trusted, the event should always cause input.
   NS_ENSURE_TRUE(aEvent, false);
   // If this is mouse event but this editor doesn't have focus, we shouldn't
   // handle it.
   nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aEvent);
   if (mouseEvent) {
     nsCOMPtr<nsIContent> focusedContent = GetFocusedContent();
     if (!focusedContent) {
       return false;
     }
   } else {
     nsAutoString eventType;
     aEvent->GetType(eventType);
     // If composition event or text event isn't dispatched via widget,
     // we need to ignore them since they cannot be managed by TextComposition.
     // E.g., the event was created by chrome JS.
     // Note that if we allow to handle such events, editor may be confused by
     // strange event order.
     if (eventType.EqualsLiteral("text") ||
         eventType.EqualsLiteral("compositionstart") ||
         eventType.EqualsLiteral("compositionend")) {
       WidgetGUIEvent* widgetGUIEvent =
         aEvent->GetInternalNSEvent()->AsGUIEvent();
       if (!widgetGUIEvent || !widgetGUIEvent->widget) {
         return false;
       }
     }
   }
   bool isTrusted;
   nsresult rv = aEvent->GetIsTrusted(&isTrusted);
   NS_ENSURE_SUCCESS(rv, false);
   if (isTrusted) {
     return true;
   }
   // Ignore untrusted mouse event.
   // XXX Why are we handling other untrusted input events?
   if (mouseEvent) {
     return false;
   }
   // Otherwise, we shouldn't handle any input events when we're not an active
   // element of the DOM window.
   return IsActiveInDOMWindow();
 }
 void
 nsEditor::OnFocus(nsIDOMEventTarget* aFocusEventTarget)
 {
   InitializeSelection(aFocusEventTarget);
   if (mInlineSpellChecker) {
     mInlineSpellChecker->UpdateCurrentDictionary();
   }
 }
 NS_IMETHODIMP
 nsEditor::GetSuppressDispatchingInputEvent(bool *aSuppressed)
 {
   NS_ENSURE_ARG_POINTER(aSuppressed);
   *aSuppressed = !mDispatchInputEvent;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsEditor::SetSuppressDispatchingInputEvent(bool aSuppress)
 {
   mDispatchInputEvent = !aSuppress;
   return NS_OK;
 }

The Tor Browser / annotate

editor/libeditor/base/nsEditor.cpp@6474c204b198 (annotated)

editor/libeditor/base/nsEditor.cpp