The Tor Browser / file revision

 /* -*- 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);