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 <stddef.h>                     // for nullptr

 #include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc

 #include "mozilla/mozalloc.h"           // for operator new, etc

 #include "nsAString.h"                  // for nsAString_internal::Length, etc

 #include "nsAutoPtr.h"                  // for nsRefPtr

 #include "nsContentUtils.h"             // for nsContentUtils

 #include "nsDebug.h"                    // for NS_ENSURE_TRUE, etc

 #include "nsDependentSubstring.h"       // for Substring

 #include "nsError.h"                    // for NS_OK, NS_ERROR_FAILURE, etc

 #include "nsFilteredContentIterator.h"  // for nsFilteredContentIterator

 #include "nsIContent.h"                 // for nsIContent, etc

 #include "nsIContentIterator.h"         // for nsIContentIterator

 #include "nsID.h"                       // for NS_GET_IID

 #include "nsIDOMDocument.h"             // for nsIDOMDocument

 #include "nsIDOMElement.h"              // for nsIDOMElement

 #include "nsIDOMHTMLDocument.h"         // for nsIDOMHTMLDocument

 #include "nsIDOMHTMLElement.h"          // for nsIDOMHTMLElement

 #include "nsIDOMNode.h"                 // for nsIDOMNode, etc

 #include "nsIDOMRange.h"                // for nsIDOMRange, etc

 #include "nsIEditor.h"                  // for nsIEditor, etc

 #include "nsINode.h"                    // for nsINode

 #include "nsIPlaintextEditor.h"         // for nsIPlaintextEditor

 #include "nsISelection.h"               // for nsISelection

 #include "nsISelectionController.h"     // for nsISelectionController, etc

 #include "nsISupportsBase.h"            // for nsISupports

 #include "nsISupportsUtils.h"           // for NS_IF_ADDREF, NS_ADDREF, etc

 #include "nsITextServicesFilter.h"      // for nsITextServicesFilter

 #include "nsIWordBreaker.h"             // for nsWordRange, nsIWordBreaker

 #include "nsRange.h"                    // for nsRange

 #include "nsStaticAtom.h"               // for NS_STATIC_ATOM, etc

 #include "nsString.h"                   // for nsString, nsAutoString

 #include "nsTextServicesDocument.h"

 #include "nscore.h"                     // for nsresult, NS_IMETHODIMP, etc

 #define LOCK_DOC(doc)

 #define UNLOCK_DOC(doc)

 using namespace mozilla;

 class OffsetEntry

 {

 public:

   OffsetEntry(nsIDOMNode *aNode, int32_t aOffset, int32_t aLength)

     : mNode(aNode), mNodeOffset(0), mStrOffset(aOffset), mLength(aLength),

       mIsInsertedText(false), mIsValid(true)

   {

     if (mStrOffset < 1)

       mStrOffset = 0;

     if (mLength < 1)

       mLength = 0;

   }

   virtual ~OffsetEntry()

   {

     mNode       = 0;

     mNodeOffset = 0;

     mStrOffset  = 0;

     mLength     = 0;

     mIsValid    = false;

   }

   nsIDOMNode *mNode;

   int32_t mNodeOffset;

   int32_t mStrOffset;

   int32_t mLength;

   bool    mIsInsertedText;

   bool    mIsValid;

 };

 #define TS_ATOM(name_, value_) nsIAtom* nsTextServicesDocument::name_ = 0;

 #include "nsTSAtomList.h" // IWYU pragma: keep

 #undef TS_ATOM

 nsTextServicesDocument::nsTextServicesDocument()

 {

   mRefCnt         = 0;

   mSelStartIndex  = -1;

   mSelStartOffset = -1;

   mSelEndIndex    = -1;

   mSelEndOffset   = -1;

   mIteratorStatus = eIsDone;

 }

 nsTextServicesDocument::~nsTextServicesDocument()

 {

   ClearOffsetTable(&mOffsetTable);

 }

 #define TS_ATOM(name_, value_) NS_STATIC_ATOM_BUFFER(name_##_buffer, value_)

 #include "nsTSAtomList.h" // IWYU pragma: keep

 #undef TS_ATOM

 /* static */

 void

 nsTextServicesDocument::RegisterAtoms()

 {

   static const nsStaticAtom ts_atoms[] = {

 #define TS_ATOM(name_, value_) NS_STATIC_ATOM(name_##_buffer, &name_),

 #include "nsTSAtomList.h" // IWYU pragma: keep

 #undef TS_ATOM

   };

   NS_RegisterStaticAtoms(ts_atoms);

 }

 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsTextServicesDocument)

 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsTextServicesDocument)

 NS_INTERFACE_MAP_BEGIN(nsTextServicesDocument)

   NS_INTERFACE_MAP_ENTRY(nsITextServicesDocument)

   NS_INTERFACE_MAP_ENTRY(nsIEditActionListener)

   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsITextServicesDocument)

   NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(nsTextServicesDocument)

 NS_INTERFACE_MAP_END

 NS_IMPL_CYCLE_COLLECTION(nsTextServicesDocument,

                          mDOMDocument,

                          mSelCon,

                          mIterator,

                          mPrevTextBlock,

                          mNextTextBlock,

                          mExtent,

                          mTxtSvcFilter)

 NS_IMETHODIMP

 nsTextServicesDocument::InitWithEditor(nsIEditor *aEditor)

 {

   nsresult result = NS_OK;

   nsCOMPtr<nsISelectionController> selCon;

   nsCOMPtr<nsIDOMDocument> doc;

   NS_ENSURE_TRUE(aEditor, NS_ERROR_NULL_POINTER);

   LOCK_DOC(this);

   // Check to see if we already have an mSelCon. If we do, it

   // better be the same one the editor uses!

   result = aEditor->GetSelectionController(getter_AddRefs(selCon));

   if (NS_FAILED(result))

   {

     UNLOCK_DOC(this);

     return result;

   }

   if (!selCon || (mSelCon && selCon != mSelCon))

   {

     UNLOCK_DOC(this);

     return NS_ERROR_FAILURE;

   }

   if (!mSelCon)

     mSelCon = selCon;

   // Check to see if we already have an mDOMDocument. If we do, it

   // better be the same one the editor uses!

   result = aEditor->GetDocument(getter_AddRefs(doc));

   if (NS_FAILED(result))

   {

     UNLOCK_DOC(this);

     return result;

   }

   if (!doc || (mDOMDocument && doc != mDOMDocument))

   {

     UNLOCK_DOC(this);

     return NS_ERROR_FAILURE;

   }

   if (!mDOMDocument)

   {

     mDOMDocument = doc;

     result = CreateDocumentContentIterator(getter_AddRefs(mIterator));

     if (NS_FAILED(result))

     {

       UNLOCK_DOC(this);

       return result;

     }

     mIteratorStatus = nsTextServicesDocument::eIsDone;

     result = FirstBlock();

     if (NS_FAILED(result))

     {

       UNLOCK_DOC(this);

       return result;

     }

   }

   mEditor = do_GetWeakReference(aEditor);

   result = aEditor->AddEditActionListener(this);

   UNLOCK_DOC(this);

   return result;

 }

 NS_IMETHODIMP 

 nsTextServicesDocument::GetDocument(nsIDOMDocument **aDoc)

 {

   NS_ENSURE_TRUE(aDoc, NS_ERROR_NULL_POINTER);

   *aDoc = nullptr; // init out param

   NS_ENSURE_TRUE(mDOMDocument, NS_ERROR_NOT_INITIALIZED);

   *aDoc = mDOMDocument;

   NS_ADDREF(*aDoc);

   return NS_OK;

 }

 NS_IMETHODIMP

 nsTextServicesDocument::SetExtent(nsIDOMRange* aDOMRange)

 {

   NS_ENSURE_ARG_POINTER(aDOMRange);

   NS_ENSURE_TRUE(mDOMDocument, NS_ERROR_FAILURE);

   LOCK_DOC(this);

   // We need to store a copy of aDOMRange since we don't

   // know where it came from.

   nsresult result = aDOMRange->CloneRange(getter_AddRefs(mExtent));

   if (NS_FAILED(result))

   {

     UNLOCK_DOC(this);

     return result;

   }

   // Create a new iterator based on our new extent range.

   result = CreateContentIterator(mExtent, getter_AddRefs(mIterator));

   if (NS_FAILED(result))

   {

     UNLOCK_DOC(this);

     return result;

   }

   // Now position the iterator at the start of the first block

   // in the range.

   mIteratorStatus = nsTextServicesDocument::eIsDone;

   result = FirstBlock();

   UNLOCK_DOC(this);

   return result;

 }

 NS_IMETHODIMP

 nsTextServicesDocument::ExpandRangeToWordBoundaries(nsIDOMRange *aRange)

 {

   NS_ENSURE_ARG_POINTER(aRange);

   // Get the end points of the range.

   nsCOMPtr<nsIDOMNode> rngStartNode, rngEndNode;

   int32_t rngStartOffset, rngEndOffset;

   nsresult result =  GetRangeEndPoints(aRange,

                                        getter_AddRefs(rngStartNode),

                                        &rngStartOffset,

                                        getter_AddRefs(rngEndNode),

                                        &rngEndOffset);

   NS_ENSURE_SUCCESS(result, result);

   // Create a content iterator based on the range.

   nsCOMPtr<nsIContentIterator> iter;

   result = CreateContentIterator(aRange, getter_AddRefs(iter));

   NS_ENSURE_SUCCESS(result, result);

   // Find the first text node in the range.

   TSDIteratorStatus iterStatus;

   result = FirstTextNode(iter, &iterStatus);

   NS_ENSURE_SUCCESS(result, result);

   if (iterStatus == nsTextServicesDocument::eIsDone)

   {

     // No text was found so there's no adjustment necessary!

     return NS_OK;

   }

   nsINode *firstText = iter->GetCurrentNode();

   NS_ENSURE_TRUE(firstText, NS_ERROR_FAILURE);

   // Find the last text node in the range.

   result = LastTextNode(iter, &iterStatus);

   NS_ENSURE_SUCCESS(result, result);

   if (iterStatus == nsTextServicesDocument::eIsDone)

   {

     // We should never get here because a first text block

     // was found above.

     NS_ASSERTION(false, "Found a first without a last!");

     return NS_ERROR_FAILURE;

   }

   nsINode *lastText = iter->GetCurrentNode();

   NS_ENSURE_TRUE(lastText, NS_ERROR_FAILURE);

   // Now make sure our end points are in terms of text nodes in the range!

   nsCOMPtr<nsIDOMNode> firstTextNode = do_QueryInterface(firstText);

   NS_ENSURE_TRUE(firstTextNode, NS_ERROR_FAILURE);

   if (rngStartNode != firstTextNode)

   {

     // The range includes the start of the first text node!

     rngStartNode = firstTextNode;

     rngStartOffset = 0;

   }

   nsCOMPtr<nsIDOMNode> lastTextNode = do_QueryInterface(lastText);

   NS_ENSURE_TRUE(lastTextNode, NS_ERROR_FAILURE);

   if (rngEndNode != lastTextNode)

   {

     // The range includes the end of the last text node!

     rngEndNode = lastTextNode;

     nsAutoString str;

     result = lastTextNode->GetNodeValue(str);

     rngEndOffset = str.Length();

   }

   // Create a doc iterator so that we can scan beyond

   // the bounds of the extent range.

   nsCOMPtr<nsIContentIterator> docIter;

   result = CreateDocumentContentIterator(getter_AddRefs(docIter));

   NS_ENSURE_SUCCESS(result, result);

   // Grab all the text in the block containing our

   // first text node.

   result = docIter->PositionAt(firstText);

   NS_ENSURE_SUCCESS(result, result);

   iterStatus = nsTextServicesDocument::eValid;

   nsTArray<OffsetEntry*> offsetTable;

   nsAutoString blockStr;

   result = CreateOffsetTable(&offsetTable, docIter, &iterStatus,

                              nullptr, &blockStr);

   if (NS_FAILED(result))

   {

     ClearOffsetTable(&offsetTable);

     return result;

   }

   nsCOMPtr<nsIDOMNode> wordStartNode, wordEndNode;

   int32_t wordStartOffset, wordEndOffset;

   result = FindWordBounds(&offsetTable, &blockStr,

                           rngStartNode, rngStartOffset,

                           getter_AddRefs(wordStartNode), &wordStartOffset,

                           getter_AddRefs(wordEndNode), &wordEndOffset);

   ClearOffsetTable(&offsetTable);

   NS_ENSURE_SUCCESS(result, result);

   rngStartNode = wordStartNode;

   rngStartOffset = wordStartOffset;

   // Grab all the text in the block containing our

   // last text node.

   result = docIter->PositionAt(lastText);

   NS_ENSURE_SUCCESS(result, result);

   iterStatus = nsTextServicesDocument::eValid;

   result = CreateOffsetTable(&offsetTable, docIter, &iterStatus,

                              nullptr, &blockStr);

   if (NS_FAILED(result))

   {

     ClearOffsetTable(&offsetTable);

     return result;

   }

   result = FindWordBounds(&offsetTable, &blockStr,

                           rngEndNode, rngEndOffset,

                           getter_AddRefs(wordStartNode), &wordStartOffset,

                           getter_AddRefs(wordEndNode), &wordEndOffset);

   ClearOffsetTable(&offsetTable);

   NS_ENSURE_SUCCESS(result, result);

   // To prevent expanding the range too much, we only change

   // rngEndNode and rngEndOffset if it isn't already at the start of the

   // word and isn't equivalent to rngStartNode and rngStartOffset.

   if (rngEndNode != wordStartNode || rngEndOffset != wordStartOffset ||

      (rngEndNode == rngStartNode  && rngEndOffset == rngStartOffset))

   {

     rngEndNode = wordEndNode;

     rngEndOffset = wordEndOffset;

   }

   // Now adjust the range so that it uses our new

   // end points.

   result = aRange->SetEnd(rngEndNode, rngEndOffset);

   NS_ENSURE_SUCCESS(result, result);

   return aRange->SetStart(rngStartNode, rngStartOffset);

 }

 NS_IMETHODIMP

 nsTextServicesDocument::SetFilter(nsITextServicesFilter *aFilter)

 {

   // Hang on to the filter so we can set it into the filtered iterator.

   mTxtSvcFilter = aFilter;

   return NS_OK;

 }

 NS_IMETHODIMP

 nsTextServicesDocument::GetCurrentTextBlock(nsString *aStr)

 {

   nsresult result;

   NS_ENSURE_TRUE(aStr, NS_ERROR_NULL_POINTER);

   aStr->Truncate();

   NS_ENSURE_TRUE(mIterator, NS_ERROR_FAILURE);

   LOCK_DOC(this);

   result = CreateOffsetTable(&mOffsetTable, mIterator, &mIteratorStatus,

                              mExtent, aStr);

   UNLOCK_DOC(this);

   return result;

 }

 NS_IMETHODIMP

 nsTextServicesDocument::FirstBlock()

 {

   NS_ENSURE_TRUE(mIterator, NS_ERROR_FAILURE);

   LOCK_DOC(this);

   nsresult result = FirstTextNode(mIterator, &mIteratorStatus);

   if (NS_FAILED(result))

   {

     UNLOCK_DOC(this);

     return result;

   }

   // Keep track of prev and next blocks, just in case

   // the text service blows away the current block.

   if (mIteratorStatus == nsTextServicesDocument::eValid)

   {

     mPrevTextBlock  = nullptr;

     result = GetFirstTextNodeInNextBlock(getter_AddRefs(mNextTextBlock));

   }

   else

   {

     // There's no text block in the document!

     mPrevTextBlock  = nullptr;

     mNextTextBlock  = nullptr;

   }

   UNLOCK_DOC(this);

   return result;

 }

 NS_IMETHODIMP

 nsTextServicesDocument::LastSelectedBlock(TSDBlockSelectionStatus *aSelStatus,

                                           int32_t *aSelOffset,

                                           int32_t *aSelLength)

 {

   nsresult result = NS_OK;

   NS_ENSURE_TRUE(aSelStatus && aSelOffset && aSelLength, NS_ERROR_NULL_POINTER);

   LOCK_DOC(this);

   mIteratorStatus = nsTextServicesDocument::eIsDone;

   *aSelStatus = nsITextServicesDocument::eBlockNotFound;

   *aSelOffset = *aSelLength = -1;

   if (!mSelCon || !mIterator)

   {

     UNLOCK_DOC(this);

     return NS_ERROR_FAILURE;

   }

   nsCOMPtr<nsISelection> selection;

   bool isCollapsed = false;

   result = mSelCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));

   if (NS_FAILED(result))

   {

     UNLOCK_DOC(this);

     return result;

   }

   result = selection->GetIsCollapsed(&isCollapsed);

   if (NS_FAILED(result))

   {

     UNLOCK_DOC(this);

     return result;

   }

   nsCOMPtr<nsIContentIterator> iter;

   nsCOMPtr<nsIDOMRange>        range;

   nsCOMPtr<nsIDOMNode>         parent;

   int32_t                      i, rangeCount, offset;

   if (isCollapsed)

   {

     // We have a caret. Check if the caret is in a text node.

     // If it is, make the text node's block the current block.

     // If the caret isn't in a text node, search forwards in

     // the document, till we find a text node.

     result = selection->GetRangeAt(0, getter_AddRefs(range));

     if (NS_FAILED(result))

     {

       UNLOCK_DOC(this);

       return result;

     }

     if (!range)

     {

       UNLOCK_DOC(this);

       return NS_ERROR_FAILURE;

     }

     result = range->GetStartContainer(getter_AddRefs(parent));

     if (NS_FAILED(result))

     {

       UNLOCK_DOC(this);

       return result;

     }

     if (!parent)

     {

       UNLOCK_DOC(this);

       return NS_ERROR_FAILURE;

     }

     result = range->GetStartOffset(&offset);

     if (NS_FAILED(result))

     {

       UNLOCK_DOC(this);

       return result;

     }

     if (IsTextNode(parent))

     {

       // The caret is in a text node. Find the beginning

       // of the text block containing this text node and

       // return.

       nsCOMPtr<nsIContent> content(do_QueryInterface(parent));

       if (!content)

       {

         UNLOCK_DOC(this);

         return NS_ERROR_FAILURE;

       }

       result = mIterator->PositionAt(content);

       if (NS_FAILED(result))

       {

         UNLOCK_DOC(this);

         return result;

       }

       result = FirstTextNodeInCurrentBlock(mIterator);

       if (NS_FAILED(result))

       {

         UNLOCK_DOC(this);

         return result;

       }

       mIteratorStatus = nsTextServicesDocument::eValid;

       result = CreateOffsetTable(&mOffsetTable, mIterator, &mIteratorStatus,

                                  mExtent, nullptr);

       if (NS_FAILED(result))

       {

         UNLOCK_DOC(this);

         return result;

       }

       result = GetSelection(aSelStatus, aSelOffset, aSelLength);

       if (NS_FAILED(result))

       {

         UNLOCK_DOC(this);

         return result;

       }

       if (*aSelStatus == nsITextServicesDocument::eBlockContains)

         result = SetSelectionInternal(*aSelOffset, *aSelLength, false);

     }

     else

     {

       // The caret isn't in a text node. Create an iterator

       // based on a range that extends from the current caret

       // position to the end of the document, then walk forwards

       // till you find a text node, then find the beginning of it's block.

       result = CreateDocumentContentRootToNodeOffsetRange(parent, offset, false, getter_AddRefs(range));

       if (NS_FAILED(result))

       {

         UNLOCK_DOC(this);

         return result;

       }

       result = range->GetCollapsed(&isCollapsed);

       if (NS_FAILED(result))

       {

         UNLOCK_DOC(this);

         return result;

       }

       if (isCollapsed)

       {

         // If we get here, the range is collapsed because there is nothing after

         // the caret! Just return NS_OK;

         UNLOCK_DOC(this);

         return NS_OK;

       }

       result = CreateContentIterator(range, getter_AddRefs(iter));

       if (NS_FAILED(result))

       {

         UNLOCK_DOC(this);

         return result;

       }

       iter->First();

       nsCOMPtr<nsIContent> content;

       while (!iter->IsDone())

       {

         content = do_QueryInterface(iter->GetCurrentNode());

         if (IsTextNode(content))

           break;

         content = nullptr;

         iter->Next();

       }

       if (!content)

       {

         UNLOCK_DOC(this);

         return NS_OK;

       }

       result = mIterator->PositionAt(content);

       if (NS_FAILED(result))

       {

         UNLOCK_DOC(this);

         return result;

       }

       result = FirstTextNodeInCurrentBlock(mIterator);

       if (NS_FAILED(result))

       {

         UNLOCK_DOC(this);

         return result;

       }

       mIteratorStatus = nsTextServicesDocument::eValid;

       result = CreateOffsetTable(&mOffsetTable, mIterator, &mIteratorStatus,

                                  mExtent, nullptr);

       if (NS_FAILED(result))

       {

         UNLOCK_DOC(this);

         return result;

       }

       result = GetSelection(aSelStatus, aSelOffset, aSelLength);

       if (NS_FAILED(result))

       {

         UNLOCK_DOC(this);

         return result;

       }

     }

     UNLOCK_DOC(this);

     return result;

   }

   // If we get here, we have an uncollapsed selection!

   // Look backwards through each range in the selection till you

   // find the first text node. If you find one, find the

   // beginning of its text block, and make it the current

   // block.

   result = selection->GetRangeCount(&rangeCount);

   if (NS_FAILED(result))

   {

     UNLOCK_DOC(this);

     return result;

   }

   NS_ASSERTION(rangeCount > 0, "Unexpected range count!");

   if (rangeCount <= 0)

   {

     UNLOCK_DOC(this);

     return NS_OK;

   }

   // XXX: We may need to add some code here to make sure

   //      the ranges are sorted in document appearance order!

   for (i = rangeCount - 1; i >= 0; i--)

   {

     // Get the i'th range from the selection.

     result = selection->GetRangeAt(i, getter_AddRefs(range));

     if (NS_FAILED(result))

     {

       UNLOCK_DOC(this);

       return result;

     }

     // Create an iterator for the range.

     result = CreateContentIterator(range, getter_AddRefs(iter));

     if (NS_FAILED(result))

     {

       UNLOCK_DOC(this);

       return result;

     }

     iter->Last();

     // Now walk through the range till we find a text node.

     while (!iter->IsDone())

     {

       if (iter->GetCurrentNode()->NodeType() == nsIDOMNode::TEXT_NODE) {

         // We found a text node, so position the document's

         // iterator at the beginning of the block, then get

         // the selection in terms of the string offset.

         nsCOMPtr<nsIContent> content = iter->GetCurrentNode()->AsContent();

         result = mIterator->PositionAt(content);

         if (NS_FAILED(result))

         {

           UNLOCK_DOC(this);

           return result;

         }

         result = FirstTextNodeInCurrentBlock(mIterator);

         if (NS_FAILED(result))

         {

           UNLOCK_DOC(this);

           return result;

         }

         mIteratorStatus = nsTextServicesDocument::eValid;

         result = CreateOffsetTable(&mOffsetTable, mIterator, &mIteratorStatus,

                                    mExtent, nullptr);

         if (NS_FAILED(result))

         {

           UNLOCK_DOC(this);

           return result;

         }

         result = GetSelection(aSelStatus, aSelOffset, aSelLength);

         UNLOCK_DOC(this);

         return result;

       }

       iter->Prev();

     }

   }

   // If we get here, we didn't find any text node in the selection!

   // Create a range that extends from the end of the selection,

   // to the end of the document, then iterate forwards through

   // it till you find a text node!

   result = selection->GetRangeAt(rangeCount - 1, getter_AddRefs(range));

   if (NS_FAILED(result))

   {

     UNLOCK_DOC(this);

     return result;

   }

   if (!range)

   {

     UNLOCK_DOC(this);

     return NS_ERROR_FAILURE;

   }

   result = range->GetEndContainer(getter_AddRefs(parent));

   if (NS_FAILED(result))

   {

     UNLOCK_DOC(this);

     return result;

   }

   if (!parent)

   {

     UNLOCK_DOC(this);

     return NS_ERROR_FAILURE;

   }

   result = range->GetEndOffset(&offset);

   if (NS_FAILED(result))

   {

     UNLOCK_DOC(this);

     return result;

   }

   result = CreateDocumentContentRootToNodeOffsetRange(parent, offset, false, getter_AddRefs(range));

   if (NS_FAILED(result))

   {

     UNLOCK_DOC(this);

     return result;

   }

   result = range->GetCollapsed(&isCollapsed);

   if (NS_FAILED(result))

   {

     UNLOCK_DOC(this);

     return result;

   }

   if (isCollapsed)

   {

     // If we get here, the range is collapsed because there is nothing after

     // the current selection! Just return NS_OK;

     UNLOCK_DOC(this);

     return NS_OK;

   }

   result = CreateContentIterator(range, getter_AddRefs(iter));

   if (NS_FAILED(result))

   {

     UNLOCK_DOC(this);

     return result;

   }

   iter->First();

   while (!iter->IsDone())

   {

     if (iter->GetCurrentNode()->NodeType() == nsIDOMNode::TEXT_NODE) {

       // We found a text node! Adjust the document's iterator to point

       // to the beginning of its text block, then get the current selection.

       nsCOMPtr<nsIContent> content = iter->GetCurrentNode()->AsContent();

       result = mIterator->PositionAt(content);

       if (NS_FAILED(result))

       {

         UNLOCK_DOC(this);

         return result;

       }

       result = FirstTextNodeInCurrentBlock(mIterator);

       if (NS_FAILED(result))

       {

         UNLOCK_DOC(this);

         return result;

       }

       mIteratorStatus = nsTextServicesDocument::eValid;

       result = CreateOffsetTable(&mOffsetTable, mIterator, &mIteratorStatus,

                                  mExtent, nullptr);

       if (NS_FAILED(result))

       {

         UNLOCK_DOC(this);

         return result;

       }

       result = GetSelection(aSelStatus, aSelOffset, aSelLength);

       UNLOCK_DOC(this);

       return result;

     }

     iter->Next();

   }

   // If we get here, we didn't find any block before or inside

   // the selection! Just return OK.

   UNLOCK_DOC(this);

   return NS_OK;

 }

 NS_IMETHODIMP

 nsTextServicesDocument::PrevBlock()

 {

   nsresult result = NS_OK;

   NS_ENSURE_TRUE(mIterator, NS_ERROR_FAILURE);

   LOCK_DOC(this);

   if (mIteratorStatus == nsTextServicesDocument::eIsDone)

     return NS_OK;

   switch (mIteratorStatus)

   {

     case nsTextServicesDocument::eValid:

     case nsTextServicesDocument::eNext:

       result = FirstTextNodeInPrevBlock(mIterator);

       if (NS_FAILED(result))

       {

         mIteratorStatus = nsTextServicesDocument::eIsDone;

         UNLOCK_DOC(this);

         return result;

       }

       if (mIterator->IsDone())

       {

         mIteratorStatus = nsTextServicesDocument::eIsDone;

         UNLOCK_DOC(this);

         return NS_OK;

       }

       mIteratorStatus = nsTextServicesDocument::eValid;

       break;

     case nsTextServicesDocument::ePrev:

       // The iterator already points to the previous

       // block, so don't do anything.

       mIteratorStatus = nsTextServicesDocument::eValid;

       break;

     default:

       mIteratorStatus = nsTextServicesDocument::eIsDone;

       break;

   }

   // Keep track of prev and next blocks, just in case

   // the text service blows away the current block.

   if (mIteratorStatus == nsTextServicesDocument::eValid)

   {

     result = GetFirstTextNodeInPrevBlock(getter_AddRefs(mPrevTextBlock));

     result = GetFirstTextNodeInNextBlock(getter_AddRefs(mNextTextBlock));

   }

   else

   {

     // We must be done!

     mPrevTextBlock = nullptr;

     mNextTextBlock = nullptr;

   }

   UNLOCK_DOC(this);

   return result;

 }

 NS_IMETHODIMP

 nsTextServicesDocument::NextBlock()

 {

   nsresult result = NS_OK;

   NS_ENSURE_TRUE(mIterator, NS_ERROR_FAILURE);

   LOCK_DOC(this);

   if (mIteratorStatus == nsTextServicesDocument::eIsDone)

     return NS_OK;

   switch (mIteratorStatus)

   {

     case nsTextServicesDocument::eValid:

       // Advance the iterator to the next text block.

       result = FirstTextNodeInNextBlock(mIterator);

       if (NS_FAILED(result))

       {

         mIteratorStatus = nsTextServicesDocument::eIsDone;

         UNLOCK_DOC(this);

         return result;

       }

       if (mIterator->IsDone())

       {

         mIteratorStatus = nsTextServicesDocument::eIsDone;

         UNLOCK_DOC(this);

         return NS_OK;

       }

       mIteratorStatus = nsTextServicesDocument::eValid;

       break;

     case nsTextServicesDocument::eNext:

       // The iterator already points to the next block,

       // so don't do anything to it!

       mIteratorStatus = nsTextServicesDocument::eValid;

       break;

     case nsTextServicesDocument::ePrev:

       // If the iterator is pointing to the previous block,

       // we know that there is no next text block! Just

       // fall through to the default case!

     default:

       mIteratorStatus = nsTextServicesDocument::eIsDone;

       break;

   }

   // Keep track of prev and next blocks, just in case

   // the text service blows away the current block.

   if (mIteratorStatus == nsTextServicesDocument::eValid)

   {

     result = GetFirstTextNodeInPrevBlock(getter_AddRefs(mPrevTextBlock));

     result = GetFirstTextNodeInNextBlock(getter_AddRefs(mNextTextBlock));

   }

   else

   {

     // We must be done.

     mPrevTextBlock = nullptr;

     mNextTextBlock = nullptr;

   }

   UNLOCK_DOC(this);

   return result;

 }

 NS_IMETHODIMP

 nsTextServicesDocument::IsDone(bool *aIsDone)

 {

   NS_ENSURE_TRUE(aIsDone, NS_ERROR_NULL_POINTER);

   *aIsDone = false;

   NS_ENSURE_TRUE(mIterator, NS_ERROR_FAILURE);

   LOCK_DOC(this);

   *aIsDone = (mIteratorStatus == nsTextServicesDocument::eIsDone) ? true : false;

   UNLOCK_DOC(this);

   return NS_OK;

 }

 NS_IMETHODIMP

 nsTextServicesDocument::SetSelection(int32_t aOffset, int32_t aLength)

 {

   nsresult result;

   NS_ENSURE_TRUE(mSelCon && aOffset >= 0 && aLength >= 0, NS_ERROR_FAILURE);

   LOCK_DOC(this);

   result = SetSelectionInternal(aOffset, aLength, true);

   UNLOCK_DOC(this);

   //**** KDEBUG ****

   // printf("\n * Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);

   //**** KDEBUG ****

   return result;

 }

 NS_IMETHODIMP

 nsTextServicesDocument::ScrollSelectionIntoView()

 {

   nsresult result;

   NS_ENSURE_TRUE(mSelCon, NS_ERROR_FAILURE);

   LOCK_DOC(this);

   // After ScrollSelectionIntoView(), the pending notifications might be flushed

   // and PresShell/PresContext/Frames may be dead. See bug 418470.

   result = mSelCon->ScrollSelectionIntoView(nsISelectionController::SELECTION_NORMAL, nsISelectionController::SELECTION_FOCUS_REGION,

                                             nsISelectionController::SCROLL_SYNCHRONOUS);

   UNLOCK_DOC(this);

   return result;

 }

 NS_IMETHODIMP

 nsTextServicesDocument::DeleteSelection()

 {

   nsresult result = NS_OK;

   // We don't allow deletion during a collapsed selection!

   nsCOMPtr<nsIEditor> editor (do_QueryReferent(mEditor));

   NS_ASSERTION(editor, "DeleteSelection called without an editor present!"); 

   NS_ASSERTION(SelectionIsValid(), "DeleteSelection called without a valid selection!"); 

   if (!editor || !SelectionIsValid())

     return NS_ERROR_FAILURE;

   if (SelectionIsCollapsed())

     return NS_OK;

   LOCK_DOC(this);

   //**** KDEBUG ****

   // printf("\n---- Before Delete\n");

   // printf("Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);

   // PrintOffsetTable();

   //**** KDEBUG ****

   // If we have an mExtent, save off its current set of

   // end points so we can compare them against mExtent's

   // set after the deletion of the content.

   nsCOMPtr<nsIDOMNode> origStartNode, origEndNode;

   int32_t origStartOffset = 0, origEndOffset = 0;

   if (mExtent)

   {

     result = GetRangeEndPoints(mExtent,

                                getter_AddRefs(origStartNode), &origStartOffset,

                                getter_AddRefs(origEndNode), &origEndOffset);

     if (NS_FAILED(result))

     {

       UNLOCK_DOC(this);

       return result;

     }

   }

   int32_t i, selLength;

   OffsetEntry *entry, *newEntry;

   for (i = mSelStartIndex; i <= mSelEndIndex; i++)

   {

     entry = mOffsetTable[i];

     if (i == mSelStartIndex)

     {

       // Calculate the length of the selection. Note that the

       // selection length can be zero if the start of the selection

       // is at the very end of a text node entry.

       if (entry->mIsInsertedText)

       {

         // Inserted text offset entries have no width when

         // talking in terms of string offsets! If the beginning

         // of the selection is in an inserted text offset entry,

         // the caret is always at the end of the entry!

         selLength = 0;

       }

       else

         selLength = entry->mLength - (mSelStartOffset - entry->mStrOffset);

       if (selLength > 0 && mSelStartOffset > entry->mStrOffset)

       {

         // Selection doesn't start at the beginning of the

         // text node entry. We need to split this entry into

         // two pieces, the piece before the selection, and

         // the piece inside the selection.

         result = SplitOffsetEntry(i, selLength);

         if (NS_FAILED(result))

         {

           UNLOCK_DOC(this);

           return result;

         }

         // Adjust selection indexes to account for new entry:

         ++mSelStartIndex;

         ++mSelEndIndex;

         ++i;

         entry = mOffsetTable[i];

       }

       if (selLength > 0 && mSelStartIndex < mSelEndIndex)

       {

         // The entire entry is contained in the selection. Mark the

         // entry invalid.

         entry->mIsValid = false;

       }

     }

   //**** KDEBUG ****

   // printf("\n---- Middle Delete\n");

   // printf("Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);

   // PrintOffsetTable();

   //**** KDEBUG ****

     if (i == mSelEndIndex)

     {

       if (entry->mIsInsertedText)

       {

         // Inserted text offset entries have no width when

         // talking in terms of string offsets! If the end

         // of the selection is in an inserted text offset entry,

         // the selection includes the entire entry!

         entry->mIsValid = false;

       }

       else

       {

         // Calculate the length of the selection. Note that the

         // selection length can be zero if the end of the selection

         // is at the very beginning of a text node entry.

         selLength = mSelEndOffset - entry->mStrOffset;

         if (selLength > 0 && mSelEndOffset < entry->mStrOffset + entry->mLength)

         {

           // mStrOffset is guaranteed to be inside the selection, even

           // when mSelStartIndex == mSelEndIndex.

           result = SplitOffsetEntry(i, entry->mLength - selLength);

           if (NS_FAILED(result))

           {

             UNLOCK_DOC(this);

             return result;

           }

           // Update the entry fields:

           newEntry = mOffsetTable[i+1];

           newEntry->mNodeOffset = entry->mNodeOffset;

         }

         if (selLength > 0 && mSelEndOffset == entry->mStrOffset + entry->mLength)

         {

           // The entire entry is contained in the selection. Mark the

           // entry invalid.

           entry->mIsValid = false;

         }

       }

     }

     if (i != mSelStartIndex && i != mSelEndIndex)

     {

       // The entire entry is contained in the selection. Mark the

       // entry invalid.

       entry->mIsValid = false;

     }

   }

   // Make sure mIterator always points to something valid!

   AdjustContentIterator();

   // Now delete the actual content!

   result = editor->DeleteSelection(nsIEditor::ePrevious, nsIEditor::eStrip);

   if (NS_FAILED(result))

   {

     UNLOCK_DOC(this);

     return result;

   }

   // Now that we've actually deleted the selected content,

   // check to see if our mExtent has changed, if so, then

   // we have to create a new content iterator!

   if (origStartNode && origEndNode)

   {

     nsCOMPtr<nsIDOMNode> curStartNode, curEndNode;

     int32_t curStartOffset = 0, curEndOffset = 0;

     result = GetRangeEndPoints(mExtent,

                                getter_AddRefs(curStartNode), &curStartOffset,

                                getter_AddRefs(curEndNode), &curEndOffset);

     if (NS_FAILED(result))

     {

       UNLOCK_DOC(this);

       return result;

     }

     if (origStartNode != curStartNode || origEndNode != curEndNode)

     {

       // The range has changed, so we need to create a new content

       // iterator based on the new range.

       nsCOMPtr<nsIContent> curContent;

       if (mIteratorStatus != nsTextServicesDocument::eIsDone) {

         // The old iterator is still pointing to something valid,

         // so get its current node so we can restore it after we

         // create the new iterator!

         curContent = mIterator->GetCurrentNode()

                      ? mIterator->GetCurrentNode()->AsContent()

                      : nullptr;

       }

       // Create the new iterator.

       result = CreateContentIterator(mExtent, getter_AddRefs(mIterator));

       if (NS_FAILED(result))

       {

         UNLOCK_DOC(this);

         return result;

       }

       // Now make the new iterator point to the content node

       // the old one was pointing at.

       if (curContent)

       {

         result = mIterator->PositionAt(curContent);

         if (NS_FAILED(result))

           mIteratorStatus = eIsDone;

         else

           mIteratorStatus = eValid;

       }

     }

   }

   entry = 0;

   // Move the caret to the end of the first valid entry.

   // Start with mSelStartIndex since it may still be valid.

   for (i = mSelStartIndex; !entry && i >= 0; i--)

   {

     entry = mOffsetTable[i];

     if (!entry->mIsValid)

       entry = 0;

     else

     {

       mSelStartIndex  = mSelEndIndex  = i;

       mSelStartOffset = mSelEndOffset = entry->mStrOffset + entry->mLength;

     }

   }

   // If we still don't have a valid entry, move the caret

   // to the next valid entry after the selection:

   for (i = mSelEndIndex; !entry && i < int32_t(mOffsetTable.Length()); i++)

   {

     entry = mOffsetTable[i];

     if (!entry->mIsValid)

       entry = 0;

     else

     {

       mSelStartIndex = mSelEndIndex = i;

       mSelStartOffset = mSelEndOffset = entry->mStrOffset;

     }

   }

   if (entry)

     result = SetSelection(mSelStartOffset, 0);

   else

   {

     // Uuughh we have no valid offset entry to place our

     // caret ... just mark the selection invalid.

     mSelStartIndex  = mSelEndIndex  = -1;

     mSelStartOffset = mSelEndOffset = -1;

   }

   // Now remove any invalid entries from the offset table.

   result = RemoveInvalidOffsetEntries();

   //**** KDEBUG ****

   // printf("\n---- After Delete\n");

   // printf("Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);

   // PrintOffsetTable();

   //**** KDEBUG ****

   UNLOCK_DOC(this);

   return result;

 }

 NS_IMETHODIMP

 nsTextServicesDocument::InsertText(const nsString *aText)

 {

   nsresult result = NS_OK;

   nsCOMPtr<nsIEditor> editor (do_QueryReferent(mEditor));

   NS_ASSERTION(editor, "InsertText called without an editor present!"); 

   if (!editor || !SelectionIsValid())

     return NS_ERROR_FAILURE;

   NS_ENSURE_TRUE(aText, NS_ERROR_NULL_POINTER);

   // If the selection is not collapsed, we need to save

   // off the selection offsets so we can restore the

   // selection and delete the selected content after we've

   // inserted the new text. This is necessary to try and

   // retain as much of the original style of the content

   // being deleted.

   bool collapsedSelection = SelectionIsCollapsed();

   int32_t savedSelOffset = mSelStartOffset;

   int32_t savedSelLength = mSelEndOffset - mSelStartOffset;

   if (!collapsedSelection)

   {

     // Collapse to the start of the current selection

     // for the insert!

     result = SetSelection(mSelStartOffset, 0);

     NS_ENSURE_SUCCESS(result, result);

   }

   LOCK_DOC(this);

   result = editor->BeginTransaction();

   if (NS_FAILED(result))

   {

     UNLOCK_DOC(this);

     return result;

   }

   nsCOMPtr<nsIPlaintextEditor> textEditor (do_QueryInterface(editor, &result));

   if (textEditor)

     result = textEditor->InsertText(*aText);

   if (NS_FAILED(result))

   {

     editor->EndTransaction();

     UNLOCK_DOC(this);

     return result;

   }

   //**** KDEBUG ****

   // printf("\n---- Before Insert\n");

   // printf("Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);

   // PrintOffsetTable();

   //**** KDEBUG ****

   int32_t strLength = aText->Length();

   uint32_t i;

   nsCOMPtr<nsISelection> selection;

   OffsetEntry *itEntry;

   OffsetEntry *entry = mOffsetTable[mSelStartIndex];

   void *node         = entry->mNode;

   NS_ASSERTION((entry->mIsValid), "Invalid insertion point!");

   if (entry->mStrOffset == mSelStartOffset)

   {

     if (entry->mIsInsertedText)

     {

       // If the caret is in an inserted text offset entry,

       // we simply insert the text at the end of the entry.

       entry->mLength += strLength;

     }

     else

     {

       // Insert an inserted text offset entry before the current

       // entry!

       itEntry = new OffsetEntry(entry->mNode, entry->mStrOffset, strLength);

       if (!itEntry)

       {

         editor->EndTransaction();

         UNLOCK_DOC(this);

         return NS_ERROR_OUT_OF_MEMORY;

       }

       itEntry->mIsInsertedText = true;

       itEntry->mNodeOffset = entry->mNodeOffset;

       if (!mOffsetTable.InsertElementAt(mSelStartIndex, itEntry))

       {

         editor->EndTransaction();

         UNLOCK_DOC(this);

         return NS_ERROR_FAILURE;

       }

     }

   }

   else if ((entry->mStrOffset + entry->mLength) == mSelStartOffset)

   {

     // We are inserting text at the end of the current offset entry.

     // Look at the next valid entry in the table. If it's an inserted

     // text entry, add to its length and adjust its node offset. If

     // it isn't, add a new inserted text entry.

     i       = mSelStartIndex + 1;

     itEntry = 0;

     if (mOffsetTable.Length() > i)

     {

       itEntry = mOffsetTable[i];

       if (!itEntry)

       {

         editor->EndTransaction();

         UNLOCK_DOC(this);

         return NS_ERROR_FAILURE;

       }

       // Check if the entry is a match. If it isn't, set

       // iEntry to zero.

       if (!itEntry->mIsInsertedText || itEntry->mStrOffset != mSelStartOffset)

         itEntry = 0;

     }

     if (!itEntry)

     {

       // We didn't find an inserted text offset entry, so

       // create one.

       itEntry = new OffsetEntry(entry->mNode, mSelStartOffset, 0);

       if (!itEntry)

       {

         editor->EndTransaction();

         UNLOCK_DOC(this);

         return NS_ERROR_OUT_OF_MEMORY;

       }

       itEntry->mNodeOffset = entry->mNodeOffset + entry->mLength;

       itEntry->mIsInsertedText = true;

       if (!mOffsetTable.InsertElementAt(i, itEntry))

       {

         delete itEntry;

         return NS_ERROR_FAILURE;

       }

     }

     // We have a valid inserted text offset entry. Update its

     // length, adjust the selection indexes, and make sure the

     // caret is properly placed!

     itEntry->mLength += strLength;

     mSelStartIndex = mSelEndIndex = i;

     result = mSelCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));

     if (NS_FAILED(result))

     {

       editor->EndTransaction();

       UNLOCK_DOC(this);

       return result;

     }

     result = selection->Collapse(itEntry->mNode, itEntry->mNodeOffset + itEntry->mLength);

     if (NS_FAILED(result))

     {

       editor->EndTransaction();

       UNLOCK_DOC(this);

       return result;

     }

   }

   else if ((entry->mStrOffset + entry->mLength) > mSelStartOffset)

   {

     // We are inserting text into the middle of the current offset entry.

     // split the current entry into two parts, then insert an inserted text

     // entry between them!

     i = entry->mLength - (mSelStartOffset - entry->mStrOffset);

     result = SplitOffsetEntry(mSelStartIndex, i);

     if (NS_FAILED(result))

     {

       editor->EndTransaction();

       UNLOCK_DOC(this);

       return result;

     }

     itEntry = new OffsetEntry(entry->mNode, mSelStartOffset, strLength);

     if (!itEntry)

     {

       editor->EndTransaction();

       UNLOCK_DOC(this);

       return NS_ERROR_OUT_OF_MEMORY;

     }

     itEntry->mIsInsertedText = true;

     itEntry->mNodeOffset     = entry->mNodeOffset + entry->mLength;

     if (!mOffsetTable.InsertElementAt(mSelStartIndex + 1, itEntry))

     {

       editor->EndTransaction();

       UNLOCK_DOC(this);

       return NS_ERROR_FAILURE;

     }

     mSelEndIndex = ++mSelStartIndex;

   }

   // We've just finished inserting an inserted text offset entry.

   // update all entries with the same mNode pointer that follow

   // it in the table!

   for (i = mSelStartIndex + 1; i < mOffsetTable.Length(); i++)

   {

     entry = mOffsetTable[i];

     if (entry->mNode == node)

     {

       if (entry->mIsValid)

         entry->mNodeOffset += strLength;

     }

     else

       break;

   }

   //**** KDEBUG ****

   // printf("\n---- After Insert\n");

   // printf("Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);

   // PrintOffsetTable();

   //**** KDEBUG ****

   if (!collapsedSelection)

   {

     result = SetSelection(savedSelOffset, savedSelLength);

     if (NS_FAILED(result))

     {

       editor->EndTransaction();

       UNLOCK_DOC(this);

       return result;

     }

     result = DeleteSelection();

     if (NS_FAILED(result))

     {

       editor->EndTransaction();

       UNLOCK_DOC(this);

       return result;

     }

   }

   result = editor->EndTransaction();

   UNLOCK_DOC(this);

   return result;

 }

 NS_IMETHODIMP

 nsTextServicesDocument::DidInsertNode(nsIDOMNode *aNode,

                                       nsIDOMNode *aParent,

                                       int32_t     aPosition,

                                       nsresult    aResult)

 {

   return NS_OK;

 }

 NS_IMETHODIMP

 nsTextServicesDocument::DidDeleteNode(nsIDOMNode *aChild, nsresult aResult)

 {

   NS_ENSURE_SUCCESS(aResult, NS_OK);

   NS_ENSURE_TRUE(mIterator, NS_ERROR_FAILURE);

   //**** KDEBUG ****

   // printf("** DeleteNode: 0x%.8x\n", aChild);

   // fflush(stdout);

   //**** KDEBUG ****

   LOCK_DOC(this);

   int32_t nodeIndex = 0;

   bool hasEntry = false;

   OffsetEntry *entry;

   nsresult result = NodeHasOffsetEntry(&mOffsetTable, aChild, &hasEntry, &nodeIndex);

   if (NS_FAILED(result))

   {

     UNLOCK_DOC(this);

     return result;

   }

   if (!hasEntry)

   {

     // It's okay if the node isn't in the offset table, the

     // editor could be cleaning house.

     UNLOCK_DOC(this);

     return NS_OK;

   }

   nsCOMPtr<nsIDOMNode> node = do_QueryInterface(mIterator->GetCurrentNode());

   if (node && node == aChild &&

       mIteratorStatus != nsTextServicesDocument::eIsDone)

   {

     // XXX: This should never really happen because

     // AdjustContentIterator() should have been called prior

     // to the delete to try and position the iterator on the

     // next valid text node in the offset table, and if there

     // wasn't a next, it would've set mIteratorStatus to eIsDone.

     NS_ERROR("DeleteNode called for current iterator node."); 

   }

   int32_t tcount = mOffsetTable.Length();

   while (nodeIndex < tcount)

   {

     entry = mOffsetTable[nodeIndex];

     if (!entry)

     {

       UNLOCK_DOC(this);

       return NS_ERROR_FAILURE;

     }

     if (entry->mNode == aChild)

     {

       entry->mIsValid = false;

     }

     nodeIndex++;

   }

   UNLOCK_DOC(this);

   return NS_OK;

 }

 NS_IMETHODIMP

 nsTextServicesDocument::DidSplitNode(nsIDOMNode *aExistingRightNode,

                                      int32_t     aOffset,

                                      nsIDOMNode *aNewLeftNode,

                                      nsresult    aResult)

 {

   //**** KDEBUG ****

   // printf("** SplitNode: 0x%.8x  %d  0x%.8x\n", aExistingRightNode, aOffset, aNewLeftNode);

   // fflush(stdout);

   //**** KDEBUG ****

   return NS_OK;

 }

 NS_IMETHODIMP

 nsTextServicesDocument::DidJoinNodes(nsIDOMNode  *aLeftNode,

                                      nsIDOMNode  *aRightNode,

                                      nsIDOMNode  *aParent,

                                      nsresult     aResult)

 {

   NS_ENSURE_SUCCESS(aResult, NS_OK);

   int32_t i;

   uint16_t type;

   nsresult result;

   //**** KDEBUG ****

   // printf("** JoinNodes: 0x%.8x  0x%.8x  0x%.8x\n", aLeftNode, aRightNode, aParent);

   // fflush(stdout);

   //**** KDEBUG ****

   // Make sure that both nodes are text nodes -- otherwise we don't care.

   result = aLeftNode->GetNodeType(&type);

   NS_ENSURE_SUCCESS(result, NS_OK);

   if (nsIDOMNode::TEXT_NODE != type) {

     return NS_OK;

   }

   result = aRightNode->GetNodeType(&type);

   NS_ENSURE_SUCCESS(result, NS_OK);

   if (nsIDOMNode::TEXT_NODE != type) {

     return NS_OK;

   }

   // Note: The editor merges the contents of the left node into the

   //       contents of the right.

   int32_t leftIndex = 0;

   int32_t rightIndex = 0;

   bool leftHasEntry = false;

   bool rightHasEntry = false;

   result = NodeHasOffsetEntry(&mOffsetTable, aLeftNode, &leftHasEntry, &leftIndex);

   NS_ENSURE_SUCCESS(result, result);

   if (!leftHasEntry)

   {

     // It's okay if the node isn't in the offset table, the

     // editor could be cleaning house.

     return NS_OK;

   }

   result = NodeHasOffsetEntry(&mOffsetTable, aRightNode, &rightHasEntry, &rightIndex);

   NS_ENSURE_SUCCESS(result, result);

   if (!rightHasEntry)

   {

     // It's okay if the node isn't in the offset table, the

     // editor could be cleaning house.

     return NS_OK;

   }

   NS_ASSERTION(leftIndex < rightIndex, "Indexes out of order.");

   if (leftIndex > rightIndex)

   {

     // Don't know how to handle this situation.

     return NS_ERROR_FAILURE;

   }

   LOCK_DOC(this);

   OffsetEntry *entry = mOffsetTable[rightIndex];

   NS_ASSERTION(entry->mNodeOffset == 0, "Unexpected offset value for rightIndex.");

   // Run through the table and change all entries referring to

   // the left node so that they now refer to the right node:

   nsAutoString str;

   result = aLeftNode->GetNodeValue(str);

   int32_t nodeLength = str.Length();

   for (i = leftIndex; i < rightIndex; i++)

   {

     entry = mOffsetTable[i];

     if (entry->mNode == aLeftNode)

     {

       if (entry->mIsValid)

         entry->mNode = aRightNode;

     }

     else

       break;

   }

   // Run through the table and adjust the node offsets

   // for all entries referring to the right node.

   for (i = rightIndex; i < int32_t(mOffsetTable.Length()); i++)

   {

     entry = mOffsetTable[i];

     if (entry->mNode == aRightNode)

     {

       if (entry->mIsValid)

         entry->mNodeOffset += nodeLength;

     }

     else

       break;

   }

   // Now check to see if the iterator is pointing to the

   // left node. If it is, make it point to the right node!

   nsCOMPtr<nsIContent> leftContent = do_QueryInterface(aLeftNode);

   nsCOMPtr<nsIContent> rightContent = do_QueryInterface(aRightNode);

   if (!leftContent || !rightContent)

   {

     UNLOCK_DOC(this);

     return NS_ERROR_FAILURE;

   }

   if (mIterator->GetCurrentNode() == leftContent)

     result = mIterator->PositionAt(rightContent);

   UNLOCK_DOC(this);

   return NS_OK;

 }

 nsresult

 nsTextServicesDocument::CreateContentIterator(nsIDOMRange *aRange, nsIContentIterator **aIterator)

 {

   nsresult result;

   NS_ENSURE_TRUE(aRange && aIterator, NS_ERROR_NULL_POINTER);

   *aIterator = 0;

   // Create a nsFilteredContentIterator

   // This class wraps the ContentIterator in order to give itself a chance 

   // to filter out certain content nodes

   nsFilteredContentIterator* filter = new nsFilteredContentIterator(mTxtSvcFilter);

   *aIterator = static_cast<nsIContentIterator *>(filter);

   if (*aIterator) {

     NS_IF_ADDREF(*aIterator);

     result = filter ? NS_OK : NS_ERROR_FAILURE;

   } else {

     delete filter;

     result = NS_ERROR_FAILURE;

   }

   NS_ENSURE_SUCCESS(result, result);

   NS_ENSURE_TRUE(*aIterator, NS_ERROR_NULL_POINTER);

   result = (*aIterator)->Init(aRange);

   if (NS_FAILED(result))

   {

     NS_RELEASE((*aIterator));

     *aIterator = 0;

     return result;

   }

   return NS_OK;

 }

 nsresult

 nsTextServicesDocument::GetDocumentContentRootNode(nsIDOMNode **aNode)

 {

   nsresult result;

   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);

   *aNode = 0;

   NS_ENSURE_TRUE(mDOMDocument, NS_ERROR_FAILURE);

   nsCOMPtr<nsIDOMHTMLDocument> htmlDoc = do_QueryInterface(mDOMDocument);

   if (htmlDoc)

   {

     // For HTML documents, the content root node is the body.

     nsCOMPtr<nsIDOMHTMLElement> bodyElement;

     result = htmlDoc->GetBody(getter_AddRefs(bodyElement));

     NS_ENSURE_SUCCESS(result, result);

     NS_ENSURE_TRUE(bodyElement, NS_ERROR_FAILURE);

     result = bodyElement->QueryInterface(NS_GET_IID(nsIDOMNode), (void **)aNode);

   }

   else

   {

     // For non-HTML documents, the content root node will be the document element.

     nsCOMPtr<nsIDOMElement> docElement;

     result = mDOMDocument->GetDocumentElement(getter_AddRefs(docElement));

     NS_ENSURE_SUCCESS(result, result);

     NS_ENSURE_TRUE(docElement, NS_ERROR_FAILURE);

     result = docElement->QueryInterface(NS_GET_IID(nsIDOMNode), (void **)aNode);

   }

   return result;

 }

 nsresult

 nsTextServicesDocument::CreateDocumentContentRange(nsIDOMRange **aRange)

 {

   *aRange = nullptr;

   nsCOMPtr<nsIDOMNode> node;

   nsresult rv = GetDocumentContentRootNode(getter_AddRefs(node));

   NS_ENSURE_SUCCESS(rv, rv);

   NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);

   nsCOMPtr<nsINode> nativeNode = do_QueryInterface(node);

   NS_ENSURE_STATE(nativeNode);

   nsRefPtr<nsRange> range = new nsRange(nativeNode);

   rv = range->SelectNodeContents(node);

   NS_ENSURE_SUCCESS(rv, rv);

   range.forget(aRange);

   return NS_OK;

 }

 nsresult

 nsTextServicesDocument::CreateDocumentContentRootToNodeOffsetRange(nsIDOMNode *aParent, int32_t aOffset, bool aToStart, nsIDOMRange **aRange)

 {

   NS_ENSURE_TRUE(aParent && aRange, NS_ERROR_NULL_POINTER);

   *aRange = 0;

   NS_ASSERTION(aOffset >= 0, "Invalid offset!");

   if (aOffset < 0)

     return NS_ERROR_FAILURE;

   nsCOMPtr<nsIDOMNode> bodyNode; 

   nsresult rv = GetDocumentContentRootNode(getter_AddRefs(bodyNode));

   NS_ENSURE_SUCCESS(rv, rv);

   NS_ENSURE_TRUE(bodyNode, NS_ERROR_NULL_POINTER);

   nsCOMPtr<nsIDOMNode> startNode;

   nsCOMPtr<nsIDOMNode> endNode;

   int32_t startOffset, endOffset;

   if (aToStart) {

     // The range should begin at the start of the document

     // and extend up until (aParent, aOffset).

     startNode   = bodyNode;

     startOffset = 0;

     endNode     = aParent;

     endOffset   = aOffset;

   } else {

     // The range should begin at (aParent, aOffset) and

     // extend to the end of the document.

     startNode   = aParent;

     startOffset = aOffset;

     endNode     = bodyNode;

     nsCOMPtr<nsINode> body = do_QueryInterface(bodyNode);

     endOffset = body ? int32_t(body->GetChildCount()) : 0;

   }

   return nsRange::CreateRange(startNode, startOffset, endNode, endOffset,

                               aRange);

 }

 nsresult

 nsTextServicesDocument::CreateDocumentContentIterator(nsIContentIterator **aIterator)

 {

   nsresult result;

   NS_ENSURE_TRUE(aIterator, NS_ERROR_NULL_POINTER);

   nsCOMPtr<nsIDOMRange> range;

   result = CreateDocumentContentRange(getter_AddRefs(range));

   NS_ENSURE_SUCCESS(result, result);

   result = CreateContentIterator(range, aIterator);

   return result;

 }

 nsresult

 nsTextServicesDocument::AdjustContentIterator()

 {

   nsresult result = NS_OK;

   NS_ENSURE_TRUE(mIterator, NS_ERROR_FAILURE);

   nsCOMPtr<nsIDOMNode> node(do_QueryInterface(mIterator->GetCurrentNode()));

   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);

   nsIDOMNode *nodePtr = node.get();

   int32_t tcount      = mOffsetTable.Length();

   nsIDOMNode *prevValidNode = 0;

   nsIDOMNode *nextValidNode = 0;

   bool foundEntry = false;

   OffsetEntry *entry;

   for (int32_t i = 0; i < tcount && !nextValidNode; i++)

   {

     entry = mOffsetTable[i];

     NS_ENSURE_TRUE(entry, NS_ERROR_FAILURE);

     if (entry->mNode == nodePtr)

     {

       if (entry->mIsValid)

       {

         // The iterator is still pointing to something valid!

         // Do nothing!

         return NS_OK;

       }

       else

       {

         // We found an invalid entry that points to

         // the current iterator node. Stop looking for

         // a previous valid node!

         foundEntry = true;

       }

     }

     if (entry->mIsValid)

     {

       if (!foundEntry)

         prevValidNode = entry->mNode;

       else

         nextValidNode = entry->mNode;

     }

   }

   nsCOMPtr<nsIContent> content;

   if (prevValidNode)

     content = do_QueryInterface(prevValidNode);

   else if (nextValidNode)

     content = do_QueryInterface(nextValidNode);

   if (content)

   {

     result = mIterator->PositionAt(content);

     if (NS_FAILED(result))

       mIteratorStatus = eIsDone;

     else

       mIteratorStatus = eValid;

     return result;

   }

   // If we get here, there aren't any valid entries

   // in the offset table! Try to position the iterator

   // on the next text block first, then previous if

   // one doesn't exist!

   if (mNextTextBlock)

   {

     result = mIterator->PositionAt(mNextTextBlock);

     if (NS_FAILED(result))

     {

       mIteratorStatus = eIsDone;

       return result;

     }

     mIteratorStatus = eNext;

   }

   else if (mPrevTextBlock)

   {

     result = mIterator->PositionAt(mPrevTextBlock);

     if (NS_FAILED(result))

     {

       mIteratorStatus = eIsDone;

       return result;

     }

     mIteratorStatus = ePrev;

   }

   else

     mIteratorStatus = eIsDone;

   return NS_OK;

 }

 bool

 nsTextServicesDocument::DidSkip(nsIContentIterator* aFilteredIter)

 {

   // We can assume here that the Iterator is a nsFilteredContentIterator because

   // all the iterator are created in CreateContentIterator which create a 

   // nsFilteredContentIterator

   // So if the iterator bailed on one of the "filtered" content nodes then we 

   // consider that to be a block and bail with true

   if (aFilteredIter) {

     nsFilteredContentIterator* filter = static_cast<nsFilteredContentIterator *>(aFilteredIter);

     if (filter && filter->DidSkip()) {

       return true;

     }

   }

   return false;

 }

 void

 nsTextServicesDocument::ClearDidSkip(nsIContentIterator* aFilteredIter)

 {

   // Clear filter's skip flag

   if (aFilteredIter) {

     nsFilteredContentIterator* filter = static_cast<nsFilteredContentIterator *>(aFilteredIter);

     filter->ClearDidSkip();

   }

 }

 bool

 nsTextServicesDocument::IsBlockNode(nsIContent *aContent)

 {

   if (!aContent) {

     NS_ERROR("How did a null pointer get passed to IsBlockNode?");

     return false;

   }

   nsIAtom *atom = aContent->Tag();

   return (sAAtom       != atom &&

           sAddressAtom != atom &&

           sBigAtom     != atom &&

           sBAtom       != atom &&

           sCiteAtom    != atom &&

           sCodeAtom    != atom &&

           sDfnAtom     != atom &&

           sEmAtom      != atom &&

           sFontAtom    != atom &&

           sIAtom       != atom &&

           sKbdAtom     != atom &&

           sKeygenAtom  != atom &&

           sNobrAtom    != atom &&

           sSAtom       != atom &&

           sSampAtom    != atom &&

           sSmallAtom   != atom &&

           sSpacerAtom  != atom &&

           sSpanAtom    != atom &&

           sStrikeAtom  != atom &&

           sStrongAtom  != atom &&

           sSubAtom     != atom &&

           sSupAtom     != atom &&

           sTtAtom      != atom &&

           sUAtom       != atom &&

           sVarAtom     != atom &&

           sWbrAtom     != atom);

 }

 bool

 nsTextServicesDocument::HasSameBlockNodeParent(nsIContent *aContent1, nsIContent *aContent2)

 {

   nsIContent* p1 = aContent1->GetParent();

   nsIContent* p2 = aContent2->GetParent();

   // Quick test:

   if (p1 == p2)

     return true;

   // Walk up the parent hierarchy looking for closest block boundary node:

   while (p1 && !IsBlockNode(p1))

   {

     p1 = p1->GetParent();

   }

   while (p2 && !IsBlockNode(p2))

   {

     p2 = p2->GetParent();

   }

   return p1 == p2;

 }

 bool

 nsTextServicesDocument::IsTextNode(nsIContent *aContent)

 {

   NS_ENSURE_TRUE(aContent, false);

   return nsIDOMNode::TEXT_NODE == aContent->NodeType();

 }

 bool

 nsTextServicesDocument::IsTextNode(nsIDOMNode *aNode)

 {

   NS_ENSURE_TRUE(aNode, false);

   nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);

   return IsTextNode(content);

 }

 nsresult

 nsTextServicesDocument::SetSelectionInternal(int32_t aOffset, int32_t aLength, bool aDoUpdate)

 {

   nsresult result = NS_OK;

   NS_ENSURE_TRUE(mSelCon && aOffset >= 0 && aLength >= 0, NS_ERROR_FAILURE);

   nsIDOMNode *sNode = 0, *eNode = 0;

   int32_t i, sOffset = 0, eOffset = 0;

   OffsetEntry *entry;

   // Find start of selection in node offset terms:

   for (i = 0; !sNode && i < int32_t(mOffsetTable.Length()); i++)

   {

     entry = mOffsetTable[i];

     if (entry->mIsValid)

     {

       if (entry->mIsInsertedText)

       {

         // Caret can only be placed at the end of an

         // inserted text offset entry, if the offsets

         // match exactly!

         if (entry->mStrOffset == aOffset)

         {

           sNode   = entry->mNode;

           sOffset = entry->mNodeOffset + entry->mLength;

         }

       }

       else if (aOffset >= entry->mStrOffset)

       {

         bool foundEntry = false;

         int32_t strEndOffset = entry->mStrOffset + entry->mLength;

         if (aOffset < strEndOffset)

           foundEntry = true;

         else if (aOffset == strEndOffset)

         {

           // Peek after this entry to see if we have any

           // inserted text entries belonging to the same

           // entry->mNode. If so, we have to place the selection

           // after it!

           if ((i+1) < int32_t(mOffsetTable.Length()))

           {

             OffsetEntry *nextEntry = mOffsetTable[i+1];

             if (!nextEntry->mIsValid || nextEntry->mStrOffset != aOffset)

             {

               // Next offset entry isn't an exact match, so we'll

               // just use the current entry.

               foundEntry = true;

             }

           }

         }

         if (foundEntry)

         {

           sNode   = entry->mNode;

           sOffset = entry->mNodeOffset + aOffset - entry->mStrOffset;

         }

       }

       if (sNode)

       {

         mSelStartIndex  = i;

         mSelStartOffset = aOffset;

       }

     }

   }

   NS_ENSURE_TRUE(sNode, NS_ERROR_FAILURE);

   // XXX: If we ever get a SetSelection() method in nsIEditor, we should

   //      use it.

   nsCOMPtr<nsISelection> selection;

   if (aDoUpdate)

   {

     result = mSelCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));

     NS_ENSURE_SUCCESS(result, result);

     result = selection->Collapse(sNode, sOffset);

     NS_ENSURE_SUCCESS(result, result);

    }

   if (aLength <= 0)

   {

     // We have a collapsed selection. (Caret)

     mSelEndIndex  = mSelStartIndex;

     mSelEndOffset = mSelStartOffset;

    //**** KDEBUG ****

    // printf("\n* Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);

    //**** KDEBUG ****

     return NS_OK;

   }

   // Find the end of the selection in node offset terms:

   int32_t endOffset = aOffset + aLength;

   for (i = mOffsetTable.Length() - 1; !eNode && i >= 0; i--)

   {

     entry = mOffsetTable[i];

     if (entry->mIsValid)

     {

       if (entry->mIsInsertedText)

       {

         if (entry->mStrOffset == eOffset)

         {

           // If the selection ends on an inserted text offset entry,

           // the selection includes the entire entry!

           eNode   = entry->mNode;

           eOffset = entry->mNodeOffset + entry->mLength;

         }

       }

       else if (endOffset >= entry->mStrOffset && endOffset <= entry->mStrOffset + entry->mLength)

       {

         eNode   = entry->mNode;

         eOffset = entry->mNodeOffset + endOffset - entry->mStrOffset;

       }

       if (eNode)

       {

         mSelEndIndex  = i;

         mSelEndOffset = endOffset;

       }

     }

   }

   if (aDoUpdate && eNode)

   {

     result = selection->Extend(eNode, eOffset);

     NS_ENSURE_SUCCESS(result, result);

   }

   //**** KDEBUG ****

   // printf("\n * Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);

   //**** KDEBUG ****

   return result;

 }

 nsresult

 nsTextServicesDocument::GetSelection(nsITextServicesDocument::TSDBlockSelectionStatus *aSelStatus, int32_t *aSelOffset, int32_t *aSelLength)

 {

   nsresult result;

   NS_ENSURE_TRUE(aSelStatus && aSelOffset && aSelLength, NS_ERROR_NULL_POINTER);

   *aSelStatus = nsITextServicesDocument::eBlockNotFound;

   *aSelOffset = -1;

   *aSelLength = -1;

   NS_ENSURE_TRUE(mDOMDocument && mSelCon, NS_ERROR_FAILURE);

   if (mIteratorStatus == nsTextServicesDocument::eIsDone)

     return NS_OK;

   nsCOMPtr<nsISelection> selection;

   bool isCollapsed;

   result = mSelCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));

   NS_ENSURE_SUCCESS(result, result);

   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);

   result = selection->GetIsCollapsed(&isCollapsed);

   NS_ENSURE_SUCCESS(result, result);

   // XXX: If we expose this method publicly, we need to

   //      add LOCK_DOC/UNLOCK_DOC calls!

   // LOCK_DOC(this);

   if (isCollapsed)

     result = GetCollapsedSelection(aSelStatus, aSelOffset, aSelLength);

   else

     result = GetUncollapsedSelection(aSelStatus, aSelOffset, aSelLength);

   // UNLOCK_DOC(this);

   return result;

 }

 nsresult

 nsTextServicesDocument::GetCollapsedSelection(nsITextServicesDocument::TSDBlockSelectionStatus *aSelStatus, int32_t *aSelOffset, int32_t *aSelLength)

 {

   nsCOMPtr<nsISelection> selection;

   nsresult result = mSelCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));

   NS_ENSURE_SUCCESS(result, result);

   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);

   // The calling function should have done the GetIsCollapsed()

   // check already. Just assume it's collapsed!

   *aSelStatus = nsITextServicesDocument::eBlockOutside;

   *aSelOffset = *aSelLength = -1;

   int32_t tableCount = mOffsetTable.Length();

   if (tableCount == 0)

     return NS_OK;

   // Get pointers to the first and last offset entries

   // in the table.

   OffsetEntry* eStart = mOffsetTable[0];

   OffsetEntry* eEnd;

   if (tableCount > 1)

     eEnd = mOffsetTable[tableCount - 1];

   else

     eEnd = eStart;

   int32_t eStartOffset = eStart->mNodeOffset;

   int32_t eEndOffset   = eEnd->mNodeOffset + eEnd->mLength;

   nsCOMPtr<nsIDOMRange> range;

   result = selection->GetRangeAt(0, getter_AddRefs(range));

   NS_ENSURE_SUCCESS(result, result);

   nsCOMPtr<nsIDOMNode> domParent;

   result = range->GetStartContainer(getter_AddRefs(domParent));

   NS_ENSURE_SUCCESS(result, result);

   nsCOMPtr<nsINode> parent = do_QueryInterface(domParent);

   MOZ_ASSERT(parent);

   int32_t offset;

   result = range->GetStartOffset(&offset);

   NS_ENSURE_SUCCESS(result, result);

   int32_t e1s1 = nsContentUtils::ComparePoints(eStart->mNode, eStartOffset,

                                                domParent, offset);

   int32_t e2s1 = nsContentUtils::ComparePoints(eEnd->mNode, eEndOffset,

                                                domParent, offset);

   if (e1s1 > 0 || e2s1 < 0) {

     // We're done if the caret is outside the current text block.

     return NS_OK;

   }

   if (parent->NodeType() == nsIDOMNode::TEXT_NODE) {

     // Good news, the caret is in a text node. Look

     // through the offset table for the entry that

     // matches its parent and offset.

     for (int32_t i = 0; i < tableCount; i++) {

       OffsetEntry* entry = mOffsetTable[i];

       NS_ENSURE_TRUE(entry, NS_ERROR_FAILURE);

       if (entry->mNode == domParent.get() &&

           entry->mNodeOffset <= offset && offset <= (entry->mNodeOffset + entry->mLength))

       {

         *aSelStatus = nsITextServicesDocument::eBlockContains;

         *aSelOffset = entry->mStrOffset + (offset - entry->mNodeOffset);

         *aSelLength = 0;

         return NS_OK;

       }

     }

     // If we get here, we didn't find a text node entry

     // in our offset table that matched.

     return NS_ERROR_FAILURE;

   }

   // The caret is in our text block, but it's positioned in some

   // non-text node (ex. <b>). Create a range based on the start

   // and end of the text block, then create an iterator based on

   // this range, with its initial position set to the closest

   // child of this non-text node. Then look for the closest text

   // node.