Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2120 insertions, 0 deletions

diff --git a/extensions/spellcheck/src/mozInlineSpellChecker.cpp b/extensions/spellcheck/src/mozInlineSpellChecker.cpp
new file mode 100644
index 0000000000..d144fff317
--- /dev/null
+++ b/extensions/spellcheck/src/mozInlineSpellChecker.cpp
@@ -0,0 +1,2120 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=2 sts=2 tw=80: */
+/* 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/. */
+
+/**
+ * This class is called by the editor to handle spellchecking after various
+ * events. The main entrypoint is SpellCheckAfterEditorChange, which is called
+ * when the text is changed.
+ *
+ * It is VERY IMPORTANT that we do NOT do any operations that might cause DOM
+ * notifications to be flushed when we are called from the editor. This is
+ * because the call might originate from a frame, and flushing the
+ * notifications might cause that frame to be deleted.
+ *
+ * We post an event and do all of the spellchecking in that event handler.
+ * We store all DOM pointers in ranges because they are kept up-to-date with
+ * DOM changes that may have happened while the event was on the queue.
+ *
+ * We also allow the spellcheck to be suspended and resumed later. This makes
+ * large pastes or initializations with a lot of text not hang the browser UI.
+ *
+ * An optimization is the mNeedsCheckAfterNavigation flag. This is set to
+ * true when we get any change, and false once there is no possibility
+ * something changed that we need to check on navigation. Navigation events
+ * tend to be a little tricky because we want to check the current word on
+ * exit if something has changed. If we navigate inside the word, we don't want
+ * to do anything. As a result, this flag is cleared in FinishNavigationEvent
+ * when we know that we are checking as a result of navigation.
+ */
+
+#include "mozInlineSpellChecker.h"
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/EditAction.h"
+#include "mozilla/EditorBase.h"
+#include "mozilla/EditorDOMPoint.h"
+#include "mozilla/EditorSpellCheck.h"
+#include "mozilla/EventListenerManager.h"
+#include "mozilla/HTMLEditor.h"
+#include "mozilla/IntegerRange.h"
+#include "mozilla/Logging.h"
+#include "mozilla/RangeUtils.h"
+#include "mozilla/Services.h"
+#include "mozilla/StaticPrefs_extensions.h"
+#include "mozilla/TextEvents.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/dom/KeyboardEvent.h"
+#include "mozilla/dom/KeyboardEventBinding.h"
+#include "mozilla/dom/MouseEvent.h"
+#include "mozilla/dom/Selection.h"
+#include "mozInlineSpellWordUtil.h"
+#ifdef ACCESSIBILITY
+#  include "nsAccessibilityService.h"
+#endif
+#include "nsCOMPtr.h"
+#include "nsCRT.h"
+#include "nsGenericHTMLElement.h"
+#include "nsRange.h"
+#include "nsIPrefBranch.h"
+#include "nsIPrefService.h"
+#include "nsIRunnable.h"
+#include "nsServiceManagerUtils.h"
+#include "nsString.h"
+#include "nsThreadUtils.h"
+#include "nsUnicharUtils.h"
+#include "nsIContent.h"
+#include "nsIContentInlines.h"
+#include "nsRange.h"
+#include "nsContentUtils.h"
+#include "nsIObserverService.h"
+#include "prtime.h"
+
+using mozilla::LogLevel;
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::ipc;
+
+// the number of milliseconds that we will take at once to do spellchecking
+#define INLINESPELL_CHECK_TIMEOUT 1
+
+// The number of words to check before we look at the time to see if
+// INLINESPELL_CHECK_TIMEOUT ms have elapsed. This prevents us from getting
+// stuck and not moving forward because the INLINESPELL_CHECK_TIMEOUT might
+// be too short to a low-end machine.
+#define INLINESPELL_MINIMUM_WORDS_BEFORE_TIMEOUT 5
+
+// The maximum number of words to check word via IPC.
+#define INLINESPELL_MAXIMUM_CHUNKED_WORDS_PER_TASK 25
+
+// These notifications are broadcast when spell check starts and ends.  STARTED
+// must always be followed by ENDED.
+#define INLINESPELL_STARTED_TOPIC "inlineSpellChecker-spellCheck-started"
+#define INLINESPELL_ENDED_TOPIC "inlineSpellChecker-spellCheck-ended"
+
+static mozilla::LazyLogModule sInlineSpellCheckerLog("InlineSpellChecker");
+
+static const PRTime kMaxSpellCheckTimeInUsec =
+    INLINESPELL_CHECK_TIMEOUT * PR_USEC_PER_MSEC;
+
+mozInlineSpellStatus::mozInlineSpellStatus(
+    mozInlineSpellChecker* aSpellChecker, const Operation aOp,
+    RefPtr<nsRange>&& aRange, RefPtr<nsRange>&& aCreatedRange,
+    RefPtr<nsRange>&& aAnchorRange, const bool aForceNavigationWordCheck,
+    const int32_t aNewNavigationPositionOffset)
+    : mSpellChecker(aSpellChecker),
+      mRange(std::move(aRange)),
+      mOp(aOp),
+      mCreatedRange(std::move(aCreatedRange)),
+      mAnchorRange(std::move(aAnchorRange)),
+      mForceNavigationWordCheck(aForceNavigationWordCheck),
+      mNewNavigationPositionOffset(aNewNavigationPositionOffset) {}
+
+// mozInlineSpellStatus::CreateForEditorChange
+//
+//    This is the most complicated case. For changes, we need to compute the
+//    range of stuff that changed based on the old and new caret positions,
+//    as well as use a range possibly provided by the editor (start and end,
+//    which are usually nullptr) to get a range with the union of these.
+
+// static
+Result<UniquePtr<mozInlineSpellStatus>, nsresult>
+mozInlineSpellStatus::CreateForEditorChange(
+    mozInlineSpellChecker& aSpellChecker, const EditSubAction aEditSubAction,
+    nsINode* aAnchorNode, uint32_t aAnchorOffset, nsINode* aPreviousNode,
+    uint32_t aPreviousOffset, nsINode* aStartNode, uint32_t aStartOffset,
+    nsINode* aEndNode, uint32_t aEndOffset) {
+  MOZ_LOG(sInlineSpellCheckerLog, LogLevel::Verbose, ("%s", __FUNCTION__));
+
+  if (NS_WARN_IF(!aAnchorNode) || NS_WARN_IF(!aPreviousNode)) {
+    return Err(NS_ERROR_FAILURE);
+  }
+
+  bool deleted = aEditSubAction == EditSubAction::eDeleteSelectedContent;
+  if (aEditSubAction == EditSubAction::eInsertTextComingFromIME) {
+    // IME may remove the previous node if it cancels composition when
+    // there is no text around the composition.
+    deleted = !aPreviousNode->IsInComposedDoc();
+  }
+
+  // save the anchor point as a range so we can find the current word later
+  RefPtr<nsRange> anchorRange = mozInlineSpellStatus::PositionToCollapsedRange(
+      aAnchorNode, aAnchorOffset);
+  if (NS_WARN_IF(!anchorRange)) {
+    return Err(NS_ERROR_FAILURE);
+  }
+
+  // Deletes are easy, the range is just the current anchor. We set the range
+  // to check to be empty, FinishInitOnEvent will fill in the range to be
+  // the current word.
+  RefPtr<nsRange> range = deleted ? nullptr : nsRange::Create(aPreviousNode);
+
+  // On insert save this range: DoSpellCheck optimizes things in this range.
+  // Otherwise, just leave this nullptr.
+  RefPtr<nsRange> createdRange =
+      (aEditSubAction == EditSubAction::eInsertText) ? range : nullptr;
+
+  UniquePtr<mozInlineSpellStatus> status{
+      /* The constructor is `private`, hence the explicit allocation. */
+      new mozInlineSpellStatus{&aSpellChecker,
+                               deleted ? eOpChangeDelete : eOpChange,
+                               std::move(range), std::move(createdRange),
+                               std::move(anchorRange), false, 0}};
+  if (deleted) {
+    return status;
+  }
+
+  // ...we need to put the start and end in the correct order
+  ErrorResult errorResult;
+  int16_t cmpResult = status->mAnchorRange->ComparePoint(
+      *aPreviousNode, aPreviousOffset, errorResult);
+  if (NS_WARN_IF(errorResult.Failed())) {
+    return Err(errorResult.StealNSResult());
+  }
+  nsresult rv;
+  if (cmpResult < 0) {
+    // previous anchor node is before the current anchor
+    rv = status->mRange->SetStartAndEnd(aPreviousNode, aPreviousOffset,
+                                        aAnchorNode, aAnchorOffset);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return Err(rv);
+    }
+  } else {
+    // previous anchor node is after (or the same as) the current anchor
+    rv = status->mRange->SetStartAndEnd(aAnchorNode, aAnchorOffset,
+                                        aPreviousNode, aPreviousOffset);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return Err(rv);
+    }
+  }
+
+  // if we were given a range, we need to expand our range to encompass it
+  if (aStartNode && aEndNode) {
+    cmpResult =
+        status->mRange->ComparePoint(*aStartNode, aStartOffset, errorResult);
+    if (NS_WARN_IF(errorResult.Failed())) {
+      return Err(errorResult.StealNSResult());
+    }
+    if (cmpResult < 0) {  // given range starts before
+      rv = status->mRange->SetStart(aStartNode, aStartOffset);
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return Err(rv);
+      }
+    }
+
+    cmpResult =
+        status->mRange->ComparePoint(*aEndNode, aEndOffset, errorResult);
+    if (NS_WARN_IF(errorResult.Failed())) {
+      return Err(errorResult.StealNSResult());
+    }
+    if (cmpResult > 0) {  // given range ends after
+      rv = status->mRange->SetEnd(aEndNode, aEndOffset);
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return Err(rv);
+      }
+    }
+  }
+
+  return status;
+}
+
+// mozInlineSpellStatus::CreateForNavigation
+//
+//    For navigation events, we just need to store the new and old positions.
+//
+//    In some cases, we detect that we shouldn't check. If this event should
+//    not be processed, *aContinue will be false.
+
+// static
+Result<UniquePtr<mozInlineSpellStatus>, nsresult>
+mozInlineSpellStatus::CreateForNavigation(
+    mozInlineSpellChecker& aSpellChecker, bool aForceCheck,
+    int32_t aNewPositionOffset, nsINode* aOldAnchorNode,
+    uint32_t aOldAnchorOffset, nsINode* aNewAnchorNode,
+    uint32_t aNewAnchorOffset, bool* aContinue) {
+  MOZ_LOG(sInlineSpellCheckerLog, LogLevel::Verbose, ("%s", __FUNCTION__));
+
+  RefPtr<nsRange> anchorRange = mozInlineSpellStatus::PositionToCollapsedRange(
+      aNewAnchorNode, aNewAnchorOffset);
+  if (NS_WARN_IF(!anchorRange)) {
+    return Err(NS_ERROR_FAILURE);
+  }
+
+  UniquePtr<mozInlineSpellStatus> status{
+      /* The constructor is `private`, hence the explicit allocation. */
+      new mozInlineSpellStatus{&aSpellChecker, eOpNavigation, nullptr, nullptr,
+                               std::move(anchorRange), aForceCheck,
+                               aNewPositionOffset}};
+
+  // get the root node for checking
+  EditorBase* editorBase = status->mSpellChecker->mEditorBase;
+  if (NS_WARN_IF(!editorBase)) {
+    return Err(NS_ERROR_FAILURE);
+  }
+  Element* root = editorBase->GetRoot();
+  if (NS_WARN_IF(!root)) {
+    return Err(NS_ERROR_FAILURE);
+  }
+  // the anchor node might not be in the DOM anymore, check
+  if (root && aOldAnchorNode &&
+      !aOldAnchorNode->IsShadowIncludingInclusiveDescendantOf(root)) {
+    *aContinue = false;
+    return status;
+  }
+
+  status->mOldNavigationAnchorRange =
+      mozInlineSpellStatus::PositionToCollapsedRange(aOldAnchorNode,
+                                                     aOldAnchorOffset);
+  if (NS_WARN_IF(!status->mOldNavigationAnchorRange)) {
+    return Err(NS_ERROR_FAILURE);
+  }
+
+  *aContinue = true;
+  return status;
+}
+
+// mozInlineSpellStatus::CreateForSelection
+//
+//    It is easy for selections since we always re-check the spellcheck
+//    selection.
+
+// static
+UniquePtr<mozInlineSpellStatus> mozInlineSpellStatus::CreateForSelection(
+    mozInlineSpellChecker& aSpellChecker) {
+  MOZ_LOG(sInlineSpellCheckerLog, LogLevel::Verbose, ("%s", __FUNCTION__));
+
+  UniquePtr<mozInlineSpellStatus> status{
+      /* The constructor is `private`, hence the explicit allocation. */
+      new mozInlineSpellStatus{&aSpellChecker, eOpSelection, nullptr, nullptr,
+                               nullptr, false, 0}};
+  return status;
+}
+
+// mozInlineSpellStatus::CreateForRange
+//
+//    Called to cause the spellcheck of the given range. This will look like
+//    a change operation over the given range.
+
+// static
+UniquePtr<mozInlineSpellStatus> mozInlineSpellStatus::CreateForRange(
+    mozInlineSpellChecker& aSpellChecker, nsRange* aRange) {
+  MOZ_LOG(sInlineSpellCheckerLog, LogLevel::Debug,
+          ("%s: range=%p", __FUNCTION__, aRange));
+
+  UniquePtr<mozInlineSpellStatus> status{
+      /* The constructor is `private`, hence the explicit allocation. */
+      new mozInlineSpellStatus{&aSpellChecker, eOpChange, nullptr, nullptr,
+                               nullptr, false, 0}};
+
+  status->mRange = aRange;
+  return status;
+}
+
+// mozInlineSpellStatus::FinishInitOnEvent
+//
+//    Called when the event is triggered to complete initialization that
+//    might require the WordUtil. This calls to the operation-specific
+//    initializer, and also sets the range to be the entire element if it
+//    is nullptr.
+//
+//    Watch out: the range might still be nullptr if there is nothing to do,
+//    the caller will have to check for this.
+
+nsresult mozInlineSpellStatus::FinishInitOnEvent(
+    mozInlineSpellWordUtil& aWordUtil) {
+  MOZ_LOG(sInlineSpellCheckerLog, LogLevel::Verbose,
+          ("%s: mRange=%p", __FUNCTION__, mRange.get()));
+
+  nsresult rv;
+  if (!mRange) {
+    rv = mSpellChecker->MakeSpellCheckRange(nullptr, 0, nullptr, 0,
+                                            getter_AddRefs(mRange));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  switch (mOp) {
+    case eOpChange:
+      if (mAnchorRange) return FillNoCheckRangeFromAnchor(aWordUtil);
+      break;
+    case eOpChangeDelete:
+      if (mAnchorRange) {
+        rv = FillNoCheckRangeFromAnchor(aWordUtil);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+      // Delete events will have no range for the changed text (because it was
+      // deleted), and CreateForEditorChange will set it to nullptr. Here, we
+      // select the entire word to cause any underlining to be removed.
+      mRange = mNoCheckRange;
+      break;
+    case eOpNavigation:
+      return FinishNavigationEvent(aWordUtil);
+    case eOpSelection:
+      // this gets special handling in ResumeCheck
+      break;
+    case eOpResume:
+      // everything should be initialized already in this case
+      break;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Bad operation");
+      return NS_ERROR_NOT_INITIALIZED;
+  }
+  return NS_OK;
+}
+
+// mozInlineSpellStatus::FinishNavigationEvent
+//
+//    This verifies that we need to check the word at the previous caret
+//    position. Now that we have the word util, we can find the word belonging
+//    to the previous caret position. If the new position is inside that word,
+//    we don't want to do anything. In this case, we'll nullptr out mRange so
+//    that the caller will know not to continue.
+//
+//    Notice that we don't set mNoCheckRange. We check here whether the cursor
+//    is in the word that needs checking, so it isn't necessary. Plus, the
+//    spellchecker isn't guaranteed to only check the given word, and it could
+//    remove the underline from the new word under the cursor.
+
+nsresult mozInlineSpellStatus::FinishNavigationEvent(
+    mozInlineSpellWordUtil& aWordUtil) {
+  MOZ_LOG(sInlineSpellCheckerLog, LogLevel::Verbose, ("%s", __FUNCTION__));
+
+  RefPtr<EditorBase> editorBase = mSpellChecker->mEditorBase;
+  if (!editorBase) {
+    return NS_ERROR_FAILURE;  // editor is gone
+  }
+
+  MOZ_ASSERT(mAnchorRange, "No anchor for navigation!");
+
+  if (!mOldNavigationAnchorRange->IsPositioned()) {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  // get the DOM position of the old caret, the range should be collapsed
+  nsCOMPtr<nsINode> oldAnchorNode =
+      mOldNavigationAnchorRange->GetStartContainer();
+  uint32_t oldAnchorOffset = mOldNavigationAnchorRange->StartOffset();
+
+  // find the word on the old caret position, this is the one that we MAY need
+  // to check
+  RefPtr<nsRange> oldWord;
+  nsresult rv = aWordUtil.GetRangeForWord(oldAnchorNode,
+                                          static_cast<int32_t>(oldAnchorOffset),
+                                          getter_AddRefs(oldWord));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // aWordUtil.GetRangeForWord flushes pending notifications, check editor
+  // again.
+  if (!mSpellChecker->mEditorBase) {
+    return NS_ERROR_FAILURE;  // editor is gone
+  }
+
+  // get the DOM position of the new caret, the range should be collapsed
+  nsCOMPtr<nsINode> newAnchorNode = mAnchorRange->GetStartContainer();
+  uint32_t newAnchorOffset = mAnchorRange->StartOffset();
+
+  // see if the new cursor position is in the word of the old cursor position
+  bool isInRange = false;
+  if (!mForceNavigationWordCheck) {
+    ErrorResult err;
+    isInRange = oldWord->IsPointInRange(
+        *newAnchorNode, newAnchorOffset + mNewNavigationPositionOffset, err);
+    if (NS_WARN_IF(err.Failed())) {
+      return err.StealNSResult();
+    }
+  }
+
+  if (isInRange) {
+    // caller should give up
+    mRange = nullptr;
+  } else {
+    // check the old word
+    mRange = oldWord;
+
+    // Once we've spellchecked the current word, we don't need to spellcheck
+    // for any more navigation events.
+    mSpellChecker->mNeedsCheckAfterNavigation = false;
+  }
+  return NS_OK;
+}
+
+// mozInlineSpellStatus::FillNoCheckRangeFromAnchor
+//
+//    Given the mAnchorRange object, computes the range of the word it is on
+//    (if any) and fills that range into mNoCheckRange. This is used for
+//    change and navigation events to know which word we should skip spell
+//    checking on
+
+nsresult mozInlineSpellStatus::FillNoCheckRangeFromAnchor(
+    mozInlineSpellWordUtil& aWordUtil) {
+  MOZ_LOG(sInlineSpellCheckerLog, LogLevel::Verbose, ("%s", __FUNCTION__));
+
+  if (!mAnchorRange->IsPositioned()) {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+  nsCOMPtr<nsINode> anchorNode = mAnchorRange->GetStartContainer();
+  uint32_t anchorOffset = mAnchorRange->StartOffset();
+  return aWordUtil.GetRangeForWord(anchorNode,
+                                   static_cast<int32_t>(anchorOffset),
+                                   getter_AddRefs(mNoCheckRange));
+}
+
+// mozInlineSpellStatus::GetDocument
+//
+//    Returns the Document object for the document for the
+//    current spellchecker.
+
+Document* mozInlineSpellStatus::GetDocument() const {
+  if (!mSpellChecker->mEditorBase) {
+    return nullptr;
+  }
+
+  return mSpellChecker->mEditorBase->GetDocument();
+}
+
+// mozInlineSpellStatus::PositionToCollapsedRange
+//
+//    Converts a given DOM position to a collapsed range covering that
+//    position. We use ranges to store DOM positions becuase they stay
+//    updated as the DOM is changed.
+
+// static
+already_AddRefed<nsRange> mozInlineSpellStatus::PositionToCollapsedRange(
+    nsINode* aNode, uint32_t aOffset) {
+  if (NS_WARN_IF(!aNode)) {
+    return nullptr;
+  }
+  IgnoredErrorResult ignoredError;
+  RefPtr<nsRange> range =
+      nsRange::Create(aNode, aOffset, aNode, aOffset, ignoredError);
+  NS_WARNING_ASSERTION(!ignoredError.Failed(),
+                       "Creating collapsed range failed");
+  return range.forget();
+}
+
+// mozInlineSpellResume
+
+class mozInlineSpellResume : public Runnable {
+ public:
+  mozInlineSpellResume(UniquePtr<mozInlineSpellStatus>&& aStatus,
+                       uint32_t aDisabledAsyncToken)
+      : Runnable("mozInlineSpellResume"),
+        mDisabledAsyncToken(aDisabledAsyncToken),
+        mStatus(std::move(aStatus)) {}
+
+  nsresult Post() {
+    nsCOMPtr<nsIRunnable> runnable(this);
+    return NS_DispatchToCurrentThreadQueue(runnable.forget(), 1000,
+                                           EventQueuePriority::Idle);
+  }
+
+  NS_IMETHOD Run() override {
+    // Discard the resumption if the spell checker was disabled after the
+    // resumption was scheduled.
+    if (mDisabledAsyncToken ==
+        mStatus->mSpellChecker->GetDisabledAsyncToken()) {
+      mStatus->mSpellChecker->ResumeCheck(std::move(mStatus));
+    }
+    return NS_OK;
+  }
+
+ private:
+  uint32_t mDisabledAsyncToken;
+  UniquePtr<mozInlineSpellStatus> mStatus;
+};
+
+// Used as the nsIEditorSpellCheck::InitSpellChecker callback.
+class InitEditorSpellCheckCallback final : public nsIEditorSpellCheckCallback {
+  ~InitEditorSpellCheckCallback() {}
+
+ public:
+  NS_DECL_ISUPPORTS
+
+  explicit InitEditorSpellCheckCallback(mozInlineSpellChecker* aSpellChecker)
+      : mSpellChecker(aSpellChecker) {}
+
+  NS_IMETHOD EditorSpellCheckDone() override {
+    return mSpellChecker ? mSpellChecker->EditorSpellCheckInited() : NS_OK;
+  }
+
+  void Cancel() { mSpellChecker = nullptr; }
+
+ private:
+  RefPtr<mozInlineSpellChecker> mSpellChecker;
+};
+NS_IMPL_ISUPPORTS(InitEditorSpellCheckCallback, nsIEditorSpellCheckCallback)
+
+NS_INTERFACE_MAP_BEGIN(mozInlineSpellChecker)
+  NS_INTERFACE_MAP_ENTRY(nsIInlineSpellChecker)
+  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+  NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMEventListener)
+  NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(mozInlineSpellChecker)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(mozInlineSpellChecker)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(mozInlineSpellChecker)
+
+NS_IMPL_CYCLE_COLLECTION_WEAK(mozInlineSpellChecker, mEditorBase, mSpellCheck,
+                              mCurrentSelectionAnchorNode)
+
+mozInlineSpellChecker::SpellCheckingState
+    mozInlineSpellChecker::gCanEnableSpellChecking =
+        mozInlineSpellChecker::SpellCheck_Uninitialized;
+
+mozInlineSpellChecker::mozInlineSpellChecker()
+    : mNumWordsInSpellSelection(0),
+      mMaxNumWordsInSpellSelection(
+          StaticPrefs::extensions_spellcheck_inline_max_misspellings()),
+      mNumPendingSpellChecks(0),
+      mNumPendingUpdateCurrentDictionary(0),
+      mDisabledAsyncToken(0),
+      mNeedsCheckAfterNavigation(false),
+      mFullSpellCheckScheduled(false),
+      mIsListeningToEditSubActions(false) {}
+
+mozInlineSpellChecker::~mozInlineSpellChecker() {}
+
+EditorSpellCheck* mozInlineSpellChecker::GetEditorSpellCheck() {
+  return mSpellCheck ? mSpellCheck : mPendingSpellCheck;
+}
+
+NS_IMETHODIMP
+mozInlineSpellChecker::GetSpellChecker(nsIEditorSpellCheck** aSpellCheck) {
+  *aSpellCheck = mSpellCheck;
+  NS_IF_ADDREF(*aSpellCheck);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+mozInlineSpellChecker::Init(nsIEditor* aEditor) {
+  mEditorBase = aEditor ? aEditor->AsEditorBase() : nullptr;
+  return NS_OK;
+}
+
+// mozInlineSpellChecker::Cleanup
+//
+//    Called by the editor when the editor is going away. This is important
+//    because we remove listeners. We do NOT clean up anything else in this
+//    function, because it can get called while DoSpellCheck is running!
+//
+//    Getting the style information there can cause DOM notifications to be
+//    flushed, which can cause editors to go away which will bring us here.
+//    We can not do anything that will cause DoSpellCheck to freak out.
+
+MOZ_CAN_RUN_SCRIPT_BOUNDARY nsresult
+mozInlineSpellChecker::Cleanup(bool aDestroyingFrames) {
+  mNumWordsInSpellSelection = 0;
+  RefPtr<Selection> spellCheckSelection = GetSpellCheckSelection();
+  nsresult rv = NS_OK;
+  if (!spellCheckSelection) {
+    // Ensure we still unregister event listeners (but return a failure code)
+    UnregisterEventListeners();
+    rv = NS_ERROR_FAILURE;
+  } else {
+    if (!aDestroyingFrames) {
+      spellCheckSelection->RemoveAllRanges(IgnoreErrors());
+    }
+
+    rv = UnregisterEventListeners();
+  }
+
+  // Notify ENDED observers now.  If we wait to notify as we normally do when
+  // these async operations finish, then in the meantime the editor may create
+  // another inline spell checker and cause more STARTED and ENDED
+  // notifications to be broadcast.  Interleaved notifications for the same
+  // editor but different inline spell checkers could easily confuse
+  // observers.  They may receive two consecutive STARTED notifications for
+  // example, which we guarantee will not happen.
+
+  RefPtr<EditorBase> editorBase = std::move(mEditorBase);
+  if (mPendingSpellCheck) {
+    // Cancel the pending editor spell checker initialization.
+    mPendingSpellCheck = nullptr;
+    mPendingInitEditorSpellCheckCallback->Cancel();
+    mPendingInitEditorSpellCheckCallback = nullptr;
+    ChangeNumPendingSpellChecks(-1, editorBase);
+  }
+
+  // Increment this token so that pending UpdateCurrentDictionary calls and
+  // scheduled spell checks are discarded when they finish.
+  mDisabledAsyncToken++;
+
+  if (mNumPendingUpdateCurrentDictionary > 0) {
+    // Account for pending UpdateCurrentDictionary calls.
+    ChangeNumPendingSpellChecks(-mNumPendingUpdateCurrentDictionary,
+                                editorBase);
+    mNumPendingUpdateCurrentDictionary = 0;
+  }
+  if (mNumPendingSpellChecks > 0) {
+    // If mNumPendingSpellChecks is still > 0 at this point, the remainder is
+    // pending scheduled spell checks.
+    ChangeNumPendingSpellChecks(-mNumPendingSpellChecks, editorBase);
+  }
+
+  mFullSpellCheckScheduled = false;
+
+  return rv;
+}
+
+// mozInlineSpellChecker::CanEnableInlineSpellChecking
+//
+//    This function can be called to see if it seems likely that we can enable
+//    spellchecking before actually creating the InlineSpellChecking objects.
+//
+//    The problem is that we can't get the dictionary list without actually
+//    creating a whole bunch of spellchecking objects. This function tries to
+//    do that and caches the result so we don't have to keep allocating those
+//    objects if there are no dictionaries or spellchecking.
+//
+//    Whenever dictionaries are added or removed at runtime, this value must be
+//    updated before an observer notification is sent out about the change, to
+//    avoid editors getting a wrong cached result.
+
+bool  // static
+mozInlineSpellChecker::CanEnableInlineSpellChecking() {
+  if (gCanEnableSpellChecking == SpellCheck_Uninitialized) {
+    gCanEnableSpellChecking = SpellCheck_NotAvailable;
+
+    nsCOMPtr<nsIEditorSpellCheck> spellchecker = new EditorSpellCheck();
+
+    bool canSpellCheck = false;
+    nsresult rv = spellchecker->CanSpellCheck(&canSpellCheck);
+    NS_ENSURE_SUCCESS(rv, false);
+
+    if (canSpellCheck) gCanEnableSpellChecking = SpellCheck_Available;
+  }
+  return (gCanEnableSpellChecking == SpellCheck_Available);
+}
+
+void  // static
+mozInlineSpellChecker::UpdateCanEnableInlineSpellChecking() {
+  gCanEnableSpellChecking = SpellCheck_Uninitialized;
+}
+
+// mozInlineSpellChecker::RegisterEventListeners
+//
+//    The inline spell checker listens to mouse events and keyboard navigation
+//    events.
+
+nsresult mozInlineSpellChecker::RegisterEventListeners() {
+  if (MOZ_UNLIKELY(NS_WARN_IF(!mEditorBase))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  StartToListenToEditSubActions();
+
+  RefPtr<Document> doc = mEditorBase->GetDocument();
+  if (MOZ_UNLIKELY(NS_WARN_IF(!doc))) {
+    return NS_ERROR_FAILURE;
+  }
+  EventListenerManager* eventListenerManager =
+      doc->GetOrCreateListenerManager();
+  if (MOZ_UNLIKELY(NS_WARN_IF(!eventListenerManager))) {
+    return NS_ERROR_FAILURE;
+  }
+  eventListenerManager->AddEventListenerByType(
+      this, u"blur"_ns, TrustedEventsAtSystemGroupCapture());
+  eventListenerManager->AddEventListenerByType(
+      this, u"click"_ns, TrustedEventsAtSystemGroupCapture());
+  eventListenerManager->AddEventListenerByType(
+      this, u"keydown"_ns, TrustedEventsAtSystemGroupCapture());
+  return NS_OK;
+}
+
+// mozInlineSpellChecker::UnregisterEventListeners
+
+nsresult mozInlineSpellChecker::UnregisterEventListeners() {
+  if (MOZ_UNLIKELY(NS_WARN_IF(!mEditorBase))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  EndListeningToEditSubActions();
+
+  RefPtr<Document> doc = mEditorBase->GetDocument();
+  if (MOZ_UNLIKELY(NS_WARN_IF(!doc))) {
+    return NS_ERROR_FAILURE;
+  }
+  EventListenerManager* eventListenerManager =
+      doc->GetOrCreateListenerManager();
+  if (MOZ_UNLIKELY(NS_WARN_IF(!eventListenerManager))) {
+    return NS_ERROR_FAILURE;
+  }
+  eventListenerManager->RemoveEventListenerByType(
+      this, u"blur"_ns, TrustedEventsAtSystemGroupCapture());
+  eventListenerManager->RemoveEventListenerByType(
+      this, u"click"_ns, TrustedEventsAtSystemGroupCapture());
+  eventListenerManager->RemoveEventListenerByType(
+      this, u"keydown"_ns, TrustedEventsAtSystemGroupCapture());
+  return NS_OK;
+}
+
+// mozInlineSpellChecker::GetEnableRealTimeSpell
+
+NS_IMETHODIMP
+mozInlineSpellChecker::GetEnableRealTimeSpell(bool* aEnabled) {
+  NS_ENSURE_ARG_POINTER(aEnabled);
+  *aEnabled = mSpellCheck != nullptr || mPendingSpellCheck != nullptr;
+  return NS_OK;
+}
+
+// mozInlineSpellChecker::SetEnableRealTimeSpell
+
+NS_IMETHODIMP
+mozInlineSpellChecker::SetEnableRealTimeSpell(bool aEnabled) {
+  if (!aEnabled) {
+    mSpellCheck = nullptr;
+    return Cleanup(false);
+  }
+
+  if (mSpellCheck) {
+    // spellcheck the current contents. SpellCheckRange doesn't supply a created
+    // range to DoSpellCheck, which in our case is the entire range. But this
+    // optimization doesn't matter because there is nothing in the spellcheck
+    // selection when starting, which triggers a better optimization.
+    return SpellCheckRange(nullptr);
+  }
+
+  if (mPendingSpellCheck) {
+    // The editor spell checker is already being initialized.
+    return NS_OK;
+  }
+
+  mPendingSpellCheck = new EditorSpellCheck();
+  mPendingSpellCheck->SetFilterType(nsIEditorSpellCheck::FILTERTYPE_MAIL);
+
+  mPendingInitEditorSpellCheckCallback = new InitEditorSpellCheckCallback(this);
+  nsresult rv = mPendingSpellCheck->InitSpellChecker(
+      mEditorBase, false, mPendingInitEditorSpellCheckCallback);
+  if (NS_FAILED(rv)) {
+    mPendingSpellCheck = nullptr;
+    mPendingInitEditorSpellCheckCallback = nullptr;
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  ChangeNumPendingSpellChecks(1);
+
+  return NS_OK;
+}
+
+// Called when nsIEditorSpellCheck::InitSpellChecker completes.
+nsresult mozInlineSpellChecker::EditorSpellCheckInited() {
+  MOZ_ASSERT(mPendingSpellCheck, "Spell check should be pending!");
+
+  // spell checking is enabled, register our event listeners to track navigation
+  RegisterEventListeners();
+
+  mSpellCheck = mPendingSpellCheck;
+  mPendingSpellCheck = nullptr;
+  mPendingInitEditorSpellCheckCallback = nullptr;
+  ChangeNumPendingSpellChecks(-1);
+
+  // spellcheck the current contents. SpellCheckRange doesn't supply a created
+  // range to DoSpellCheck, which in our case is the entire range. But this
+  // optimization doesn't matter because there is nothing in the spellcheck
+  // selection when starting, which triggers a better optimization.
+  return SpellCheckRange(nullptr);
+}
+
+// Changes the number of pending spell checks by the given delta.  If the number
+// becomes zero or nonzero, observers are notified.  See NotifyObservers for
+// info on the aEditor parameter.
+void mozInlineSpellChecker::ChangeNumPendingSpellChecks(
+    int32_t aDelta, EditorBase* aEditorBase) {
+  int8_t oldNumPending = mNumPendingSpellChecks;
+  mNumPendingSpellChecks += aDelta;
+  MOZ_ASSERT(mNumPendingSpellChecks >= 0,
+             "Unbalanced ChangeNumPendingSpellChecks calls!");
+  if (oldNumPending == 0 && mNumPendingSpellChecks > 0) {
+    NotifyObservers(INLINESPELL_STARTED_TOPIC, aEditorBase);
+  } else if (oldNumPending > 0 && mNumPendingSpellChecks == 0) {
+    NotifyObservers(INLINESPELL_ENDED_TOPIC, aEditorBase);
+  }
+}
+
+// Broadcasts the given topic to observers.  aEditor is passed to observers if
+// nonnull; otherwise mEditorBase is passed.
+void mozInlineSpellChecker::NotifyObservers(const char* aTopic,
+                                            EditorBase* aEditorBase) {
+  nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
+  if (!os) return;
+  // XXX Do we need to grab the editor here?  If it's necessary, each observer
+  //     should do it instead.
+  RefPtr<EditorBase> editorBase = aEditorBase ? aEditorBase : mEditorBase.get();
+  os->NotifyObservers(static_cast<nsIEditor*>(editorBase.get()), aTopic,
+                      nullptr);
+}
+
+// mozInlineSpellChecker::SpellCheckAfterEditorChange
+//
+//    Called by the editor when nearly anything happens to change the content.
+//
+//    The start and end positions specify a range for the thing that happened,
+//    but these are usually nullptr, even when you'd think they would be useful
+//    because you want the range (for example, pasting). We ignore them in
+//    this case.
+
+nsresult mozInlineSpellChecker::SpellCheckAfterEditorChange(
+    EditSubAction aEditSubAction, Selection& aSelection,
+    nsINode* aPreviousSelectedNode, uint32_t aPreviousSelectedOffset,
+    nsINode* aStartNode, uint32_t aStartOffset, nsINode* aEndNode,
+    uint32_t aEndOffset) {
+  nsresult rv;
+  if (!mSpellCheck) return NS_OK;  // disabling spell checking is not an error
+
+  // this means something has changed, and we never check the current word,
+  // therefore, we should spellcheck for subsequent caret navigations
+  mNeedsCheckAfterNavigation = true;
+
+  // the anchor node is the position of the caret
+  Result<UniquePtr<mozInlineSpellStatus>, nsresult> res =
+      mozInlineSpellStatus::CreateForEditorChange(
+          *this, aEditSubAction, aSelection.GetAnchorNode(),
+          aSelection.AnchorOffset(), aPreviousSelectedNode,
+          aPreviousSelectedOffset, aStartNode, aStartOffset, aEndNode,
+          aEndOffset);
+  if (NS_WARN_IF(res.isErr())) {
+    return res.unwrapErr();
+  }
+
+  rv = ScheduleSpellCheck(res.unwrap());
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // remember the current caret position after every change
+  SaveCurrentSelectionPosition();
+  return NS_OK;
+}
+
+// mozInlineSpellChecker::SpellCheckRange
+//
+//    Spellchecks all the words in the given range.
+//    Supply a nullptr range and this will check the entire editor.
+
+nsresult mozInlineSpellChecker::SpellCheckRange(nsRange* aRange) {
+  if (!mSpellCheck) {
+    NS_WARNING_ASSERTION(
+        mPendingSpellCheck,
+        "Trying to spellcheck, but checking seems to be disabled");
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  UniquePtr<mozInlineSpellStatus> status =
+      mozInlineSpellStatus::CreateForRange(*this, aRange);
+  return ScheduleSpellCheck(std::move(status));
+}
+
+// mozInlineSpellChecker::GetMisspelledWord
+
+NS_IMETHODIMP
+mozInlineSpellChecker::GetMisspelledWord(nsINode* aNode, uint32_t aOffset,
+                                         nsRange** newword) {
+  if (NS_WARN_IF(!aNode)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+  RefPtr<Selection> spellCheckSelection = GetSpellCheckSelection();
+  if (NS_WARN_IF(!spellCheckSelection)) {
+    return NS_ERROR_FAILURE;
+  }
+  return IsPointInSelection(*spellCheckSelection, aNode, aOffset, newword);
+}
+
+// mozInlineSpellChecker::ReplaceWord
+
+NS_IMETHODIMP
+mozInlineSpellChecker::ReplaceWord(nsINode* aNode, uint32_t aOffset,
+                                   const nsAString& aNewWord) {
+  if (NS_WARN_IF(!mEditorBase) || NS_WARN_IF(aNewWord.IsEmpty())) {
+    return NS_ERROR_FAILURE;
+  }
+
+  RefPtr<nsRange> range;
+  nsresult res = GetMisspelledWord(aNode, aOffset, getter_AddRefs(range));
+  NS_ENSURE_SUCCESS(res, res);
+
+  if (!range) {
+    return NS_OK;
+  }
+
+  // In usual cases, any words shouldn't include line breaks, but technically,
+  // they may include and we need to avoid `HTMLTextAreaElement.value` returns
+  // \r.  Therefore, we need to handle it here.
+  nsString newWord(aNewWord);
+  if (mEditorBase->IsTextEditor()) {
+    nsContentUtils::PlatformToDOMLineBreaks(newWord);
+  }
+
+  // Blink dispatches cancelable `beforeinput` event at collecting misspelled
+  // word so that we should allow to dispatch cancelable event.
+  RefPtr<EditorBase> editorBase(mEditorBase);
+  DebugOnly<nsresult> rv = editorBase->ReplaceTextAsAction(
+      newWord, range, EditorBase::AllowBeforeInputEventCancelable::Yes);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Failed to insert the new word");
+  return NS_OK;
+}
+
+// mozInlineSpellChecker::AddWordToDictionary
+
+NS_IMETHODIMP
+mozInlineSpellChecker::AddWordToDictionary(const nsAString& word) {
+  NS_ENSURE_TRUE(mSpellCheck, NS_ERROR_NOT_INITIALIZED);
+
+  nsresult rv = mSpellCheck->AddWordToDictionary(word);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  UniquePtr<mozInlineSpellStatus> status =
+      mozInlineSpellStatus::CreateForSelection(*this);
+  return ScheduleSpellCheck(std::move(status));
+}
+
+//  mozInlineSpellChecker::RemoveWordFromDictionary
+
+NS_IMETHODIMP
+mozInlineSpellChecker::RemoveWordFromDictionary(const nsAString& word) {
+  NS_ENSURE_TRUE(mSpellCheck, NS_ERROR_NOT_INITIALIZED);
+
+  nsresult rv = mSpellCheck->RemoveWordFromDictionary(word);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  UniquePtr<mozInlineSpellStatus> status =
+      mozInlineSpellStatus::CreateForRange(*this, nullptr);
+  return ScheduleSpellCheck(std::move(status));
+}
+
+// mozInlineSpellChecker::IgnoreWord
+
+NS_IMETHODIMP
+mozInlineSpellChecker::IgnoreWord(const nsAString& word) {
+  NS_ENSURE_TRUE(mSpellCheck, NS_ERROR_NOT_INITIALIZED);
+
+  nsresult rv = mSpellCheck->IgnoreWordAllOccurrences(word);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  UniquePtr<mozInlineSpellStatus> status =
+      mozInlineSpellStatus::CreateForSelection(*this);
+  return ScheduleSpellCheck(std::move(status));
+}
+
+// mozInlineSpellChecker::IgnoreWords
+
+NS_IMETHODIMP
+mozInlineSpellChecker::IgnoreWords(const nsTArray<nsString>& aWordsToIgnore) {
+  NS_ENSURE_TRUE(mSpellCheck, NS_ERROR_NOT_INITIALIZED);
+
+  // add each word to the ignore list and then recheck the document
+  for (auto& word : aWordsToIgnore) {
+    mSpellCheck->IgnoreWordAllOccurrences(word);
+  }
+
+  UniquePtr<mozInlineSpellStatus> status =
+      mozInlineSpellStatus::CreateForSelection(*this);
+  return ScheduleSpellCheck(std::move(status));
+}
+
+// mozInlineSpellChecker::MakeSpellCheckRange
+//
+//    Given begin and end positions, this function constructs a range as
+//    required for ScheduleSpellCheck. If the start and end nodes are nullptr,
+//    then the entire range will be selected, and you can supply -1 as the
+//    offset to the end range to select all of that node.
+//
+//    If the resulting range would be empty, nullptr is put into *aRange and the
+//    function succeeds.
+
+nsresult mozInlineSpellChecker::MakeSpellCheckRange(nsINode* aStartNode,
+                                                    int32_t aStartOffset,
+                                                    nsINode* aEndNode,
+                                                    int32_t aEndOffset,
+                                                    nsRange** aRange) const {
+  nsresult rv;
+  *aRange = nullptr;
+
+  if (NS_WARN_IF(!mEditorBase)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  RefPtr<Document> doc = mEditorBase->GetDocument();
+  if (NS_WARN_IF(!doc)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  RefPtr<nsRange> range = nsRange::Create(doc);
+
+  // possibly use full range of the editor
+  if (!aStartNode || !aEndNode) {
+    Element* domRootElement = mEditorBase->GetRoot();
+    if (NS_WARN_IF(!domRootElement)) {
+      return NS_ERROR_FAILURE;
+    }
+    aStartNode = aEndNode = domRootElement;
+    aStartOffset = 0;
+    aEndOffset = -1;
+  }
+
+  if (aEndOffset == -1) {
+    // It's hard to say whether it's better to just do nsINode::GetChildCount or
+    // get the ChildNodes() and then its length.  The latter is faster if we
+    // keep going through this code for the same nodes (because it caches the
+    // length).  The former is faster if we keep getting different nodes here...
+    //
+    // Let's do the thing which can't end up with bad O(N^2) behavior.
+    aEndOffset = aEndNode->ChildNodes()->Length();
+  }
+
+  // sometimes we are are requested to check an empty range (possibly an empty
+  // document). This will result in assertions later.
+  if (aStartNode == aEndNode && aStartOffset == aEndOffset) return NS_OK;
+
+  if (aEndOffset) {
+    rv = range->SetStartAndEnd(aStartNode, aStartOffset, aEndNode, aEndOffset);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+  } else {
+    rv = range->SetStartAndEnd(RawRangeBoundary(aStartNode, aStartOffset),
+                               RangeUtils::GetRawRangeBoundaryAfter(aEndNode));
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+  }
+
+  range.swap(*aRange);
+  return NS_OK;
+}
+
+nsresult mozInlineSpellChecker::SpellCheckBetweenNodes(nsINode* aStartNode,
+                                                       int32_t aStartOffset,
+                                                       nsINode* aEndNode,
+                                                       int32_t aEndOffset) {
+  RefPtr<nsRange> range;
+  nsresult rv = MakeSpellCheckRange(aStartNode, aStartOffset, aEndNode,
+                                    aEndOffset, getter_AddRefs(range));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!range) return NS_OK;  // range is empty: nothing to do
+
+  UniquePtr<mozInlineSpellStatus> status =
+      mozInlineSpellStatus::CreateForRange(*this, range);
+  return ScheduleSpellCheck(std::move(status));
+}
+
+// mozInlineSpellChecker::ShouldSpellCheckNode
+//
+//    There are certain conditions when we don't want to spell check a node. In
+//    particular quotations, moz signatures, etc. This routine returns false
+//    for these cases.
+
+// static
+bool mozInlineSpellChecker::ShouldSpellCheckNode(EditorBase* aEditorBase,
+                                                 nsINode* aNode) {
+  MOZ_ASSERT(aNode);
+  if (!aNode->IsContent()) return false;
+
+  nsIContent* content = aNode->AsContent();
+
+  if (aEditorBase->IsMailEditor()) {
+    nsIContent* parent = content->GetParent();
+    while (parent) {
+      if (parent->IsHTMLElement(nsGkAtoms::blockquote) &&
+          parent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+                                           nsGkAtoms::cite, eIgnoreCase)) {
+        return false;
+      }
+      if (parent->IsAnyOfHTMLElements(nsGkAtoms::pre, nsGkAtoms::div) &&
+          parent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::_class,
+                                           nsGkAtoms::mozsignature,
+                                           eIgnoreCase)) {
+        return false;
+      }
+      if (parent->IsHTMLElement(nsGkAtoms::div) &&
+          parent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::_class,
+                                           nsGkAtoms::mozfwcontainer,
+                                           eIgnoreCase)) {
+        return false;
+      }
+
+      parent = parent->GetParent();
+    }
+  } else {
+    // Check spelling only if the node is editable, and GetSpellcheck() is true
+    // on the nearest HTMLElement ancestor.
+    if (!content->IsEditable()) {
+      return false;
+    }
+
+    // Make sure that we can always turn on spell checking for inputs/textareas.
+    // Note that because of the previous check, at this point we know that the
+    // node is editable.
+    if (content->IsInNativeAnonymousSubtree()) {
+      nsIContent* node = content->GetParent();
+      while (node && node->IsInNativeAnonymousSubtree()) {
+        node = node->GetParent();
+      }
+      if (node && node->IsTextControlElement()) {
+        return true;
+      }
+    }
+
+    // Get HTML element ancestor (might be aNode itself, although probably that
+    // has to be a text node in real life here)
+    nsIContent* parent = content;
+    while (!parent->IsHTMLElement()) {
+      parent = parent->GetParent();
+      if (!parent) {
+        return true;
+      }
+    }
+
+    // See if it's spellcheckable
+    return static_cast<nsGenericHTMLElement*>(parent)->Spellcheck();
+  }
+
+  return true;
+}
+
+// mozInlineSpellChecker::ScheduleSpellCheck
+//
+//    This is called by code to do the actual spellchecking. We will set up
+//    the proper structures for calls to DoSpellCheck.
+
+nsresult mozInlineSpellChecker::ScheduleSpellCheck(
+    UniquePtr<mozInlineSpellStatus>&& aStatus) {
+  MOZ_LOG(sInlineSpellCheckerLog, LogLevel::Debug,
+          ("%s: mFullSpellCheckScheduled=%i", __FUNCTION__,
+           mFullSpellCheckScheduled));
+
+  if (mFullSpellCheckScheduled) {
+    // Just ignore this; we're going to spell-check everything anyway
+    return NS_OK;
+  }
+  // Cache the value because we are going to move aStatus's ownership to
+  // the new created mozInlineSpellResume instance.
+  bool isFullSpellCheck = aStatus->IsFullSpellCheck();
+
+  RefPtr<mozInlineSpellResume> resume =
+      new mozInlineSpellResume(std::move(aStatus), mDisabledAsyncToken);
+  NS_ENSURE_TRUE(resume, NS_ERROR_OUT_OF_MEMORY);
+
+  nsresult rv = resume->Post();
+  if (NS_SUCCEEDED(rv)) {
+    if (isFullSpellCheck) {
+      // We're going to check everything.  Suppress further spell-check attempts
+      // until that happens.
+      mFullSpellCheckScheduled = true;
+    }
+    ChangeNumPendingSpellChecks(1);
+  }
+  return rv;
+}
+
+// mozInlineSpellChecker::DoSpellCheckSelection
+//
+//    Called to re-check all misspelled words. We iterate over all ranges in
+//    the selection and call DoSpellCheck on them. This is used when a word
+//    is ignored or added to the dictionary: all instances of that word should
+//    be removed from the selection.
+//
+//    FIXME-PERFORMANCE: This takes as long as it takes and is not resumable.
+//    Typically, checking this small amount of text is relatively fast, but
+//    for large numbers of words, a lag may be noticeable.
+
+nsresult mozInlineSpellChecker::DoSpellCheckSelection(
+    mozInlineSpellWordUtil& aWordUtil, Selection* aSpellCheckSelection) {
+  nsresult rv;
+
+  // clear out mNumWordsInSpellSelection since we'll be rebuilding the ranges.
+  mNumWordsInSpellSelection = 0;
+
+  // Since we could be modifying the ranges for the spellCheckSelection while
+  // looping on the spell check selection, keep a separate array of range
+  // elements inside the selection
+  nsTArray<RefPtr<nsRange>> ranges;
+
+  const uint32_t rangeCount = aSpellCheckSelection->RangeCount();
+  for (const uint32_t idx : IntegerRange(rangeCount)) {
+    MOZ_ASSERT(aSpellCheckSelection->RangeCount() == rangeCount);
+    nsRange* range = aSpellCheckSelection->GetRangeAt(idx);
+    MOZ_ASSERT(range);
+    if (MOZ_LIKELY(range)) {
+      ranges.AppendElement(range);
+    }
+  }
+
+  // We have saved the ranges above. Clearing the spellcheck selection here
+  // isn't necessary (rechecking each word will modify it as necessary) but
+  // provides better performance. By ensuring that no ranges need to be
+  // removed in DoSpellCheck, we can save checking range inclusion which is
+  // slow.
+  aSpellCheckSelection->RemoveAllRanges(IgnoreErrors());
+
+  // We use this state object for all calls, and just update its range. Note
+  // that we don't need to call FinishInit since we will be filling in the
+  // necessary information.
+  UniquePtr<mozInlineSpellStatus> status =
+      mozInlineSpellStatus::CreateForRange(*this, nullptr);
+
+  bool doneChecking;
+  for (uint32_t idx : IntegerRange(rangeCount)) {
+    // We can consider this word as "added" since we know it has no spell
+    // check range over it that needs to be deleted. All the old ranges
+    // were cleared above. We also need to clear the word count so that we
+    // check all words instead of stopping early.
+    status->mRange = ranges[idx];
+    rv = DoSpellCheck(aWordUtil, aSpellCheckSelection, status, &doneChecking);
+    NS_ENSURE_SUCCESS(rv, rv);
+    MOZ_ASSERT(
+        doneChecking,
+        "We gave the spellchecker one word, but it didn't finish checking?!?!");
+  }
+
+  return NS_OK;
+}
+
+class MOZ_STACK_CLASS mozInlineSpellChecker::SpellCheckerSlice {
+ public:
+  /**
+   * @param aStatus must be non-nullptr.
+   */
+  SpellCheckerSlice(mozInlineSpellChecker& aInlineSpellChecker,
+                    mozInlineSpellWordUtil& aWordUtil,
+                    mozilla::dom::Selection& aSpellCheckSelection,
+                    const mozilla::UniquePtr<mozInlineSpellStatus>& aStatus,
+                    bool& aDoneChecking)
+      : mInlineSpellChecker{aInlineSpellChecker},
+        mWordUtil{aWordUtil},
+        mSpellCheckSelection{aSpellCheckSelection},
+        mStatus{aStatus},
+        mDoneChecking{aDoneChecking} {
+    MOZ_ASSERT(aStatus);
+  }
+
+  [[nodiscard]] nsresult Execute();
+
+ private:
+  // Creates an async request to check the words and update the ranges for the
+  // misspellings.
+  //
+  // @param aWords normalized words corresponding to aNodeOffsetRangesForWords.
+  // @param aOldRangesForSomeWords ranges from previous spellcheckings which
+  //                               might need to be removed. Its length might
+  //                               differ from `aWords.Length()`.
+  // @param aNodeOffsetRangesForWords One range for each word in aWords. So
+  //                                  `aNodeOffsetRangesForWords.Length() ==
+  //                                  aWords.Length()`.
+  void CheckWordsAndUpdateRangesForMisspellings(
+      const nsTArray<nsString>& aWords,
+      nsTArray<RefPtr<nsRange>>&& aOldRangesForSomeWords,
+      nsTArray<NodeOffsetRange>&& aNodeOffsetRangesForWords);
+
+  void RemoveRanges(const nsTArray<RefPtr<nsRange>>& aRanges);
+
+  bool ShouldSpellCheckRange(const nsRange& aRange) const;
+
+  bool IsInNoCheckRange(const nsINode& aNode, int32_t aOffset) const;
+
+  mozInlineSpellChecker& mInlineSpellChecker;
+  mozInlineSpellWordUtil& mWordUtil;
+  mozilla::dom::Selection& mSpellCheckSelection;
+  const mozilla::UniquePtr<mozInlineSpellStatus>& mStatus;
+  bool& mDoneChecking;
+};
+
+bool mozInlineSpellChecker::SpellCheckerSlice::ShouldSpellCheckRange(
+    const nsRange& aRange) const {
+  if (aRange.Collapsed()) {
+    return false;
+  }
+
+  nsINode* beginNode = aRange.GetStartContainer();
+  nsINode* endNode = aRange.GetEndContainer();
+
+  const nsINode* rootNode = mWordUtil.GetRootNode();
+  return beginNode->IsInComposedDoc() && endNode->IsInComposedDoc() &&
+         beginNode->IsShadowIncludingInclusiveDescendantOf(rootNode) &&
+         endNode->IsShadowIncludingInclusiveDescendantOf(rootNode);
+}
+
+bool mozInlineSpellChecker::SpellCheckerSlice::IsInNoCheckRange(
+    const nsINode& aNode, int32_t aOffset) const {
+  ErrorResult erv;
+  return mStatus->GetNoCheckRange() &&
+         mStatus->GetNoCheckRange()->IsPointInRange(aNode, aOffset, erv);
+}
+
+void mozInlineSpellChecker::SpellCheckerSlice::RemoveRanges(
+    const nsTArray<RefPtr<nsRange>>& aRanges) {
+  for (uint32_t i = 0; i < aRanges.Length(); i++) {
+    mInlineSpellChecker.RemoveRange(&mSpellCheckSelection, aRanges[i]);
+  }
+}
+
+// mozInlineSpellChecker::SpellCheckerSlice::Execute
+//
+//    This function checks words intersecting the given range, excluding those
+//    inside mStatus->mNoCheckRange (can be nullptr). Words inside aNoCheckRange
+//    will have any spell selection removed (this is used to hide the
+//    underlining for the word that the caret is in). aNoCheckRange should be
+//    on word boundaries.
+//
+//    mResume->mCreatedRange is a possibly nullptr range of new text that was
+//    inserted.  Inside this range, we don't bother to check whether things are
+//    inside the spellcheck selection, which speeds up large paste operations
+//    considerably.
+//
+//    Normal case when editing text by typing
+//       h e l l o   w o r k d   h o w   a r e   y o u
+//                            ^ caret
+//                   [-------] mRange
+//                   [-------] mNoCheckRange
+//      -> does nothing (range is the same as the no check range)
+//
+//    Case when pasting:
+//             [---------- pasted text ----------]
+//       h e l l o   w o r k d   h o w   a r e   y o u
+//                                                ^ caret
+//                                               [---] aNoCheckRange
+//      -> recheck all words in range except those in aNoCheckRange
+//
+//    If checking is complete, *aDoneChecking will be set. If there is more
+//    but we ran out of time, this will be false and the range will be
+//    updated with the stuff that still needs checking.
+
+nsresult mozInlineSpellChecker::SpellCheckerSlice::Execute() {
+  MOZ_LOG(sInlineSpellCheckerLog, LogLevel::Debug, ("%s", __FUNCTION__));
+
+  mDoneChecking = true;
+
+  if (NS_WARN_IF(!mInlineSpellChecker.mSpellCheck)) {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  if (mInlineSpellChecker.IsSpellCheckSelectionFull()) {
+    return NS_OK;
+  }
+
+  // get the editor for ShouldSpellCheckNode, this may fail in reasonable
+  // circumstances since the editor could have gone away
+  RefPtr<EditorBase> editorBase = mInlineSpellChecker.mEditorBase;
+  if (!editorBase || editorBase->Destroyed()) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!ShouldSpellCheckRange(*mStatus->mRange)) {
+    // Just bail out and don't try to spell-check this
+    return NS_OK;
+  }
+
+  // see if the selection has any ranges, if not, then we can optimize checking
+  // range inclusion later (we have no ranges when we are initially checking or
+  // when there are no misspelled words yet).
+  const int32_t originalRangeCount = mSpellCheckSelection.RangeCount();
+
+  // set the starting DOM position to be the beginning of our range
+  if (nsresult rv = mWordUtil.SetPositionAndEnd(
+          mStatus->mRange->GetStartContainer(), mStatus->mRange->StartOffset(),
+          mStatus->mRange->GetEndContainer(), mStatus->mRange->EndOffset());
+      NS_FAILED(rv)) {
+    // Just bail out and don't try to spell-check this
+    return NS_OK;
+  }
+
+  // aWordUtil.SetPosition flushes pending notifications, check editor again.
+  if (!mInlineSpellChecker.mEditorBase) {
+    return NS_ERROR_FAILURE;
+  }
+
+  int32_t wordsChecked = 0;
+  PRTime beginTime = PR_Now();
+
+  nsTArray<nsString> normalizedWords;
+  nsTArray<RefPtr<nsRange>> oldRangesToRemove;
+  nsTArray<NodeOffsetRange> checkRanges;
+  mozInlineSpellWordUtil::Word word;
+  static const size_t requestChunkSize =
+      INLINESPELL_MAXIMUM_CHUNKED_WORDS_PER_TASK;
+
+  while (mWordUtil.GetNextWord(word)) {
+    // get the range for the current word.
+    nsINode* const beginNode = word.mNodeOffsetRange.Begin().Node();
+    nsINode* const endNode = word.mNodeOffsetRange.End().Node();
+    // TODO: Make them `uint32_t`
+    const int32_t beginOffset = word.mNodeOffsetRange.Begin().Offset();
+    const int32_t endOffset = word.mNodeOffsetRange.End().Offset();
+
+    // see if we've done enough words in this round and run out of time.
+    if (wordsChecked >= INLINESPELL_MINIMUM_WORDS_BEFORE_TIMEOUT &&
+        PR_Now() > PRTime(beginTime + kMaxSpellCheckTimeInUsec)) {
+      // stop checking, our time limit has been exceeded.
+      MOZ_LOG(
+          sInlineSpellCheckerLog, LogLevel::Verbose,
+          ("%s: we have run out of time, schedule next round.", __FUNCTION__));
+
+      CheckWordsAndUpdateRangesForMisspellings(normalizedWords,
+                                               std::move(oldRangesToRemove),
+                                               std::move(checkRanges));
+
+      // move the range to encompass the stuff that needs checking.
+      nsresult rv = mStatus->mRange->SetStart(
+          beginNode, AssertedCast<uint32_t>(beginOffset));
+      if (NS_FAILED(rv)) {
+        // The range might be unhappy because the beginning is after the
+        // end. This is possible when the requested end was in the middle
+        // of a word, just ignore this situation and assume we're done.
+        return NS_OK;
+      }
+      mDoneChecking = false;
+      return NS_OK;
+    }
+
+    MOZ_LOG(sInlineSpellCheckerLog, LogLevel::Debug,
+            ("%s: got word \"%s\"%s", __FUNCTION__,
+             NS_ConvertUTF16toUTF8(word.mText).get(),
+             word.mSkipChecking ? " (not checking)" : ""));
+
+    // see if there is a spellcheck range that already intersects the word
+    // and remove it. We only need to remove old ranges, so don't bother if
+    // there were no ranges when we started out.
+    if (originalRangeCount > 0) {
+      ErrorResult erv;
+      // likewise, if this word is inside new text, we won't bother testing
+      if (!mStatus->GetCreatedRange() ||
+          !mStatus->GetCreatedRange()->IsPointInRange(
+              *beginNode, AssertedCast<uint32_t>(beginOffset), erv)) {
+        MOZ_LOG(sInlineSpellCheckerLog, LogLevel::Debug,
+                ("%s: removing ranges for some interval.", __FUNCTION__));
+
+        nsTArray<RefPtr<nsRange>> ranges;
+        mSpellCheckSelection.GetRangesForInterval(
+            *beginNode, AssertedCast<uint32_t>(beginOffset), *endNode,
+            AssertedCast<uint32_t>(endOffset), true, ranges, erv);
+        ENSURE_SUCCESS(erv, erv.StealNSResult());
+        oldRangesToRemove.AppendElements(std::move(ranges));
+      }
+    }
+
+    // some words are special and don't need checking
+    if (word.mSkipChecking) {
+      continue;
+    }
+
+    // some nodes we don't spellcheck
+    if (!mozInlineSpellChecker::ShouldSpellCheckNode(editorBase, beginNode)) {
+      continue;
+    }
+
+    // Don't check spelling if we're inside the noCheckRange. This needs to
+    // be done after we clear any old selection because the excluded word
+    // might have been previously marked.
+    //
+    // We do a simple check to see if the beginning of our word is in the
+    // exclusion range. Because the exclusion range is a multiple of a word,
+    // this is sufficient.
+    if (IsInNoCheckRange(*beginNode, beginOffset)) {
+      continue;
+    }
+
+    // check spelling and add to selection if misspelled
+    mozInlineSpellWordUtil::NormalizeWord(word.mText);
+    normalizedWords.AppendElement(word.mText);
+    checkRanges.AppendElement(word.mNodeOffsetRange);
+    wordsChecked++;
+    if (normalizedWords.Length() >= requestChunkSize) {
+      CheckWordsAndUpdateRangesForMisspellings(normalizedWords,
+                                               std::move(oldRangesToRemove),
+                                               std::move(checkRanges));
+      normalizedWords.Clear();
+      oldRangesToRemove = {};
+      // Set new empty data for spellcheck range in DOM to avoid
+      // clang-tidy detection.
+      checkRanges = nsTArray<NodeOffsetRange>();
+    }
+  }
+
+  CheckWordsAndUpdateRangesForMisspellings(
+      normalizedWords, std::move(oldRangesToRemove), std::move(checkRanges));
+
+  return NS_OK;
+}
+
+nsresult mozInlineSpellChecker::DoSpellCheck(
+    mozInlineSpellWordUtil& aWordUtil, Selection* aSpellCheckSelection,
+    const UniquePtr<mozInlineSpellStatus>& aStatus, bool* aDoneChecking) {
+  MOZ_ASSERT(aDoneChecking);
+
+  SpellCheckerSlice spellCheckerSlice{*this, aWordUtil, *aSpellCheckSelection,
+                                      aStatus, *aDoneChecking};
+
+  return spellCheckerSlice.Execute();
+}
+
+// An RAII helper that calls ChangeNumPendingSpellChecks on destruction.
+class MOZ_RAII AutoChangeNumPendingSpellChecks final {
+ public:
+  explicit AutoChangeNumPendingSpellChecks(mozInlineSpellChecker* aSpellChecker,
+                                           int32_t aDelta)
+      : mSpellChecker(aSpellChecker), mDelta(aDelta) {}
+
+  ~AutoChangeNumPendingSpellChecks() {
+    mSpellChecker->ChangeNumPendingSpellChecks(mDelta);
+  }
+
+ private:
+  RefPtr<mozInlineSpellChecker> mSpellChecker;
+  int32_t mDelta;
+};
+
+void mozInlineSpellChecker::SpellCheckerSlice::
+    CheckWordsAndUpdateRangesForMisspellings(
+        const nsTArray<nsString>& aWords,
+        nsTArray<RefPtr<nsRange>>&& aOldRangesForSomeWords,
+        nsTArray<NodeOffsetRange>&& aNodeOffsetRangesForWords) {
+  MOZ_LOG(sInlineSpellCheckerLog, LogLevel::Verbose,
+          ("%s: aWords.Length()=%i", __FUNCTION__,
+           static_cast<int>(aWords.Length())));
+
+  MOZ_ASSERT(aWords.Length() == aNodeOffsetRangesForWords.Length());
+
+  // TODO:
+  // aOldRangesForSomeWords is sorted in the same order as aWords. Could be used
+  // to remove ranges more efficiently.
+
+  if (aWords.IsEmpty()) {
+    RemoveRanges(aOldRangesForSomeWords);
+    return;
+  }
+
+  mInlineSpellChecker.ChangeNumPendingSpellChecks(1);
+
+  RefPtr<mozInlineSpellChecker> inlineSpellChecker = &mInlineSpellChecker;
+  RefPtr<Selection> spellCheckerSelection = &mSpellCheckSelection;
+  uint32_t token = mInlineSpellChecker.mDisabledAsyncToken;
+  mInlineSpellChecker.mSpellCheck->CheckCurrentWordsNoSuggest(aWords)->Then(
+      GetMainThreadSerialEventTarget(), __func__,
+      [inlineSpellChecker, spellCheckerSelection,
+       nodeOffsetRangesForWords = std::move(aNodeOffsetRangesForWords),
+       oldRangesForSomeWords = std::move(aOldRangesForSomeWords),
+       token](const nsTArray<bool>& aIsMisspelled) {
+        if (token != inlineSpellChecker->GetDisabledAsyncToken()) {
+          // This result is never used
+          return;
+        }
+
+        if (!inlineSpellChecker->mEditorBase ||
+            inlineSpellChecker->mEditorBase->Destroyed()) {
+          return;
+        }
+
+        AutoChangeNumPendingSpellChecks pendingChecks(inlineSpellChecker, -1);
+
+        if (inlineSpellChecker->IsSpellCheckSelectionFull()) {
+          return;
+        }
+
+        inlineSpellChecker->UpdateRangesForMisspelledWords(
+            nodeOffsetRangesForWords, oldRangesForSomeWords, aIsMisspelled,
+            *spellCheckerSelection);
+      },
+      [inlineSpellChecker, token](nsresult aRv) {
+        if (!inlineSpellChecker->mEditorBase ||
+            inlineSpellChecker->mEditorBase->Destroyed()) {
+          return;
+        }
+
+        if (token != inlineSpellChecker->GetDisabledAsyncToken()) {
+          // This result is never used
+          return;
+        }
+
+        inlineSpellChecker->ChangeNumPendingSpellChecks(-1);
+      });
+}
+
+// mozInlineSpellChecker::ResumeCheck
+//
+//    Called by the resume event when it fires. We will try to pick up where
+//    the last resume left off.
+
+nsresult mozInlineSpellChecker::ResumeCheck(
+    UniquePtr<mozInlineSpellStatus>&& aStatus) {
+  MOZ_LOG(sInlineSpellCheckerLog, LogLevel::Debug, ("%s", __FUNCTION__));
+
+  // Observers should be notified that spell check has ended only after spell
+  // check is done below, but since there are many early returns in this method
+  // and the number of pending spell checks must be decremented regardless of
+  // whether the spell check actually happens, use this RAII object.
+  AutoChangeNumPendingSpellChecks autoChangeNumPending(this, -1);
+
+  if (aStatus->IsFullSpellCheck()) {
+    // Allow posting new spellcheck resume events from inside
+    // ResumeCheck, now that we're actually firing.
+    MOZ_ASSERT(mFullSpellCheckScheduled,
+               "How could this be false?  The full spell check is "
+               "calling us!!");
+    mFullSpellCheckScheduled = false;
+  }
+
+  if (!mSpellCheck) return NS_OK;  // spell checking has been turned off
+
+  if (!mEditorBase) {
+    return NS_OK;
+  }
+
+  Maybe<mozInlineSpellWordUtil> wordUtil{
+      mozInlineSpellWordUtil::Create(*mEditorBase)};
+  if (!wordUtil) {
+    return NS_OK;  // editor doesn't like us, don't assert
+  }
+
+  RefPtr<Selection> spellCheckSelection = GetSpellCheckSelection();
+  if (NS_WARN_IF(!spellCheckSelection)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsTArray<nsCString> currentDictionaries;
+  nsresult rv = mSpellCheck->GetCurrentDictionaries(currentDictionaries);
+  if (NS_FAILED(rv)) {
+    MOZ_LOG(sInlineSpellCheckerLog, LogLevel::Debug,
+            ("%s: no active dictionary.", __FUNCTION__));
+
+    // no active dictionary
+    for (const uint32_t index :
+         Reversed(IntegerRange(spellCheckSelection->RangeCount()))) {
+      RefPtr<nsRange> checkRange = spellCheckSelection->GetRangeAt(index);
+      if (MOZ_LIKELY(checkRange)) {
+        RemoveRange(spellCheckSelection, checkRange);
+      }
+    }
+    return NS_OK;
+  }
+
+  CleanupRangesInSelection(spellCheckSelection);
+
+  rv = aStatus->FinishInitOnEvent(*wordUtil);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!aStatus->mRange) return NS_OK;  // empty range, nothing to do
+
+  bool doneChecking = true;
+  if (aStatus->GetOperation() == mozInlineSpellStatus::eOpSelection)
+    rv = DoSpellCheckSelection(*wordUtil, spellCheckSelection);
+  else
+    rv = DoSpellCheck(*wordUtil, spellCheckSelection, aStatus, &doneChecking);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!doneChecking) rv = ScheduleSpellCheck(std::move(aStatus));
+  return rv;
+}
+
+// mozInlineSpellChecker::IsPointInSelection
+//
+//    Determines if a given (node,offset) point is inside the given
+//    selection. If so, the specific range of the selection that
+//    intersects is places in *aRange. (There may be multiple disjoint
+//    ranges in a selection.)
+//
+//    If there is no intersection, *aRange will be nullptr.
+
+// static
+nsresult mozInlineSpellChecker::IsPointInSelection(Selection& aSelection,
+                                                   nsINode* aNode,
+                                                   uint32_t aOffset,
+                                                   nsRange** aRange) {
+  *aRange = nullptr;
+
+  nsTArray<nsRange*> ranges;
+  nsresult rv = aSelection.GetDynamicRangesForIntervalArray(
+      aNode, aOffset, aNode, aOffset, true, &ranges);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (ranges.Length() == 0) return NS_OK;  // no matches
+
+  // there may be more than one range returned, and we don't know what do
+  // do with that, so just get the first one
+  NS_ADDREF(*aRange = ranges[0]);
+  return NS_OK;
+}
+
+nsresult mozInlineSpellChecker::CleanupRangesInSelection(
+    Selection* aSelection) {
+  // integrity check - remove ranges that have collapsed to nothing. This
+  // can happen if the node containing a highlighted word was removed.
+  if (!aSelection) return NS_ERROR_FAILURE;
+
+  // TODO: Rewrite this with reversed ranged-loop, it might make this simpler.
+  int64_t count = aSelection->RangeCount();
+  for (int64_t index = 0; index < count; index++) {
+    nsRange* checkRange = aSelection->GetRangeAt(static_cast<uint32_t>(index));
+    if (MOZ_LIKELY(checkRange)) {
+      if (checkRange->Collapsed()) {
+        RemoveRange(aSelection, checkRange);
+        index--;
+        count--;
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+// mozInlineSpellChecker::RemoveRange
+//
+//    For performance reasons, we have an upper bound on the number of word
+//    ranges  in the spell check selection. When removing a range from the
+//    selection, we need to decrement mNumWordsInSpellSelection
+
+nsresult mozInlineSpellChecker::RemoveRange(Selection* aSpellCheckSelection,
+                                            nsRange* aRange) {
+  MOZ_LOG(sInlineSpellCheckerLog, LogLevel::Debug, ("%s", __FUNCTION__));
+
+  NS_ENSURE_ARG_POINTER(aSpellCheckSelection);
+  NS_ENSURE_ARG_POINTER(aRange);
+
+  ErrorResult rv;
+  RefPtr<nsRange> range{aRange};
+  RefPtr<Selection> selection{aSpellCheckSelection};
+  selection->RemoveRangeAndUnselectFramesAndNotifyListeners(*range, rv);
+  if (!rv.Failed()) {
+    if (mNumWordsInSpellSelection) {
+      mNumWordsInSpellSelection--;
+    }
+#ifdef ACCESSIBILITY
+    if (nsAccessibilityService* accService = GetAccService()) {
+      accService->SpellCheckRangeChanged(*aRange);
+    }
+#endif
+  }
+
+  return rv.StealNSResult();
+}
+
+struct mozInlineSpellChecker::CompareRangeAndNodeOffsetRange {
+  static bool Equals(const RefPtr<nsRange>& aRange,
+                     const NodeOffsetRange& aNodeOffsetRange) {
+    return aNodeOffsetRange == *aRange;
+  }
+};
+
+void mozInlineSpellChecker::UpdateRangesForMisspelledWords(
+    const nsTArray<NodeOffsetRange>& aNodeOffsetRangesForWords,
+    const nsTArray<RefPtr<nsRange>>& aOldRangesForSomeWords,
+    const nsTArray<bool>& aIsMisspelled, Selection& aSpellCheckerSelection) {
+  MOZ_LOG(sInlineSpellCheckerLog, LogLevel::Verbose, ("%s", __FUNCTION__));
+
+  MOZ_ASSERT(aNodeOffsetRangesForWords.Length() == aIsMisspelled.Length());
+
+  // When the spellchecker checks text containing words separated by "/", it may
+  // happen that some words checked in one timeslice, are checked again in a
+  // following timeslice. E.g. for "foo/baz/qwertz", it may happen that "foo"
+  // and "baz" are checked in one timeslice and two ranges are added for them.
+  // In the following timeslice "foo" and "baz" are checked again but since
+  // their corresponding ranges are already in the spellcheck-Selection
+  // they don't have to be added again and since "foo" and "baz" still contain
+  // spelling mistakes, they don't have to be removed.
+  //
+  // In this case, it's more efficient to keep the existing ranges.
+
+  AutoTArray<bool, INLINESPELL_MAXIMUM_CHUNKED_WORDS_PER_TASK>
+      oldRangesMarkedForRemoval;
+  for (size_t i = 0; i < aOldRangesForSomeWords.Length(); ++i) {
+    oldRangesMarkedForRemoval.AppendElement(true);
+  }
+
+  AutoTArray<bool, INLINESPELL_MAXIMUM_CHUNKED_WORDS_PER_TASK>
+      nodeOffsetRangesMarkedForAdding;
+  for (size_t i = 0; i < aNodeOffsetRangesForWords.Length(); ++i) {
+    nodeOffsetRangesMarkedForAdding.AppendElement(false);
+  }
+
+  for (size_t i = 0; i < aIsMisspelled.Length(); i++) {
+    if (!aIsMisspelled[i]) {
+      continue;
+    }
+
+    const NodeOffsetRange& nodeOffsetRange = aNodeOffsetRangesForWords[i];
+    const size_t indexOfOldRangeToKeep = aOldRangesForSomeWords.IndexOf(
+        nodeOffsetRange, 0, CompareRangeAndNodeOffsetRange{});
+    if (indexOfOldRangeToKeep != aOldRangesForSomeWords.NoIndex &&
+        aOldRangesForSomeWords[indexOfOldRangeToKeep]->IsInSelection(
+            aSpellCheckerSelection)) {
+      /** TODO: warn in case the old range doesn't
+        belong to the selection. This is not critical,
+        because other code can always remove them
+        before the actual spellchecking happens. */
+      MOZ_LOG(sInlineSpellCheckerLog, LogLevel::Verbose,
+              ("%s: reusing old range.", __FUNCTION__));
+
+      oldRangesMarkedForRemoval[indexOfOldRangeToKeep] = false;
+    } else {
+      nodeOffsetRangesMarkedForAdding[i] = true;
+    }
+  }
+
+  for (size_t i = 0; i < oldRangesMarkedForRemoval.Length(); ++i) {
+    if (oldRangesMarkedForRemoval[i]) {
+      RemoveRange(&aSpellCheckerSelection, aOldRangesForSomeWords[i]);
+    }
+  }
+
+  // Add ranges after removing the marked old ones, so that the Selection can
+  // become full again.
+  for (size_t i = 0; i < nodeOffsetRangesMarkedForAdding.Length(); ++i) {
+    if (nodeOffsetRangesMarkedForAdding[i]) {
+      RefPtr<nsRange> wordRange =
+          mozInlineSpellWordUtil::MakeRange(aNodeOffsetRangesForWords[i]);
+      // If we somehow can't make a range for this word, just ignore
+      // it.
+      if (wordRange) {
+        AddRange(&aSpellCheckerSelection, wordRange);
+      }
+    }
+  }
+}
+
+// mozInlineSpellChecker::AddRange
+//
+//    For performance reasons, we have an upper bound on the number of word
+//    ranges we'll add to the spell check selection. Once we reach that upper
+//    bound, stop adding the ranges
+
+nsresult mozInlineSpellChecker::AddRange(Selection* aSpellCheckSelection,
+                                         nsRange* aRange) {
+  NS_ENSURE_ARG_POINTER(aSpellCheckSelection);
+  NS_ENSURE_ARG_POINTER(aRange);
+
+  nsresult rv = NS_OK;
+
+  if (!IsSpellCheckSelectionFull()) {
+    IgnoredErrorResult err;
+    aSpellCheckSelection->AddRangeAndSelectFramesAndNotifyListeners(*aRange,
+                                                                    err);
+    if (err.Failed()) {
+      rv = err.StealNSResult();
+    } else {
+      mNumWordsInSpellSelection++;
+#ifdef ACCESSIBILITY
+      if (nsAccessibilityService* accService = GetAccService()) {
+        accService->SpellCheckRangeChanged(*aRange);
+      }
+#endif
+    }
+  }
+
+  return rv;
+}
+
+already_AddRefed<Selection> mozInlineSpellChecker::GetSpellCheckSelection() {
+  if (NS_WARN_IF(!mEditorBase)) {
+    return nullptr;
+  }
+  RefPtr<Selection> selection =
+      mEditorBase->GetSelection(SelectionType::eSpellCheck);
+  if (!selection) {
+    return nullptr;
+  }
+  return selection.forget();
+}
+
+nsresult mozInlineSpellChecker::SaveCurrentSelectionPosition() {
+  if (NS_WARN_IF(!mEditorBase)) {
+    return NS_OK;  // XXX Why NS_OK?
+  }
+
+  // figure out the old caret position based on the current selection
+  RefPtr<Selection> selection = mEditorBase->GetSelection();
+  if (NS_WARN_IF(!selection)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  mCurrentSelectionAnchorNode = selection->GetFocusNode();
+  mCurrentSelectionOffset = selection->FocusOffset();
+
+  return NS_OK;
+}
+
+// mozInlineSpellChecker::HandleNavigationEvent
+//
+//    Acts upon mouse clicks and keyboard navigation changes, spell checking
+//    the previous word if the new navigation location moves us to another
+//    word.
+//
+//    This is complicated by the fact that our mouse events are happening after
+//    selection has been changed to account for the mouse click. But keyboard
+//    events are happening before the caret selection has changed. Working
+//    around this by letting keyboard events setting forceWordSpellCheck to
+//    true. aNewPositionOffset also tries to work around this for the
+//    DOM_VK_RIGHT and DOM_VK_LEFT cases.
+
+nsresult mozInlineSpellChecker::HandleNavigationEvent(
+    bool aForceWordSpellCheck, int32_t aNewPositionOffset) {
+  nsresult rv;
+
+  // If we already handled the navigation event and there is no possibility
+  // anything has changed since then, we don't have to do anything. This
+  // optimization makes a noticeable difference when you hold down a navigation
+  // key like Page Down.
+  if (!mNeedsCheckAfterNavigation) return NS_OK;
+
+  nsCOMPtr<nsINode> currentAnchorNode = mCurrentSelectionAnchorNode;
+  uint32_t currentAnchorOffset = mCurrentSelectionOffset;
+
+  // now remember the new focus position resulting from the event
+  rv = SaveCurrentSelectionPosition();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool shouldPost;
+  Result<UniquePtr<mozInlineSpellStatus>, nsresult> res =
+      mozInlineSpellStatus::CreateForNavigation(
+          *this, aForceWordSpellCheck, aNewPositionOffset, currentAnchorNode,
+          currentAnchorOffset, mCurrentSelectionAnchorNode,
+          mCurrentSelectionOffset, &shouldPost);
+
+  if (NS_WARN_IF(res.isErr())) {
+    return res.unwrapErr();
+  }
+
+  if (shouldPost) {
+    rv = ScheduleSpellCheck(res.unwrap());
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP mozInlineSpellChecker::HandleEvent(Event* aEvent) {
+  WidgetEvent* widgetEvent = aEvent->WidgetEventPtr();
+  if (MOZ_UNLIKELY(!widgetEvent)) {
+    return NS_OK;
+  }
+
+  switch (widgetEvent->mMessage) {
+    case eBlur:
+      OnBlur(*aEvent);
+      return NS_OK;
+    case eMouseClick:
+      OnMouseClick(*aEvent);
+      return NS_OK;
+    case eKeyDown:
+      OnKeyDown(*aEvent);
+      return NS_OK;
+    default:
+      MOZ_ASSERT_UNREACHABLE("You must forgot to handle new event type");
+      return NS_OK;
+  }
+}
+
+void mozInlineSpellChecker::OnBlur(Event& aEvent) {
+  // force spellcheck on blur, for instance when tabbing out of a textbox
+  HandleNavigationEvent(true);
+}
+
+void mozInlineSpellChecker::OnMouseClick(Event& aMouseEvent) {
+  MouseEvent* mouseEvent = aMouseEvent.AsMouseEvent();
+  if (MOZ_UNLIKELY(!mouseEvent)) {
+    return;
+  }
+
+  // ignore any errors from HandleNavigationEvent as we don't want to prevent
+  // anyone else from seeing this event.
+  HandleNavigationEvent(mouseEvent->Button() != 0);
+}
+
+void mozInlineSpellChecker::OnKeyDown(Event& aKeyEvent) {
+  WidgetKeyboardEvent* widgetKeyboardEvent =
+      aKeyEvent.WidgetEventPtr()->AsKeyboardEvent();
+  if (MOZ_UNLIKELY(!widgetKeyboardEvent)) {
+    return;
+  }
+
+  // we only care about navigation keys that moved selection
+  switch (widgetKeyboardEvent->mKeyNameIndex) {
+    case KEY_NAME_INDEX_ArrowRight:
+      // XXX Does this work with RTL text?
+      HandleNavigationEvent(false, 1);
+      return;
+    case KEY_NAME_INDEX_ArrowLeft:
+      // XXX Does this work with RTL text?
+      HandleNavigationEvent(false, -1);
+      return;
+    case KEY_NAME_INDEX_ArrowUp:
+    case KEY_NAME_INDEX_ArrowDown:
+    case KEY_NAME_INDEX_Home:
+    case KEY_NAME_INDEX_End:
+    case KEY_NAME_INDEX_PageDown:
+    case KEY_NAME_INDEX_PageUp:
+      HandleNavigationEvent(true /* force a spelling correction */);
+      return;
+    default:
+      return;
+  }
+}
+
+// Used as the nsIEditorSpellCheck::UpdateCurrentDictionary callback.
+class UpdateCurrentDictionaryCallback final
+    : public nsIEditorSpellCheckCallback {
+ public:
+  NS_DECL_ISUPPORTS
+
+  explicit UpdateCurrentDictionaryCallback(mozInlineSpellChecker* aSpellChecker,
+                                           uint32_t aDisabledAsyncToken)
+      : mSpellChecker(aSpellChecker),
+        mDisabledAsyncToken(aDisabledAsyncToken) {}
+
+  NS_IMETHOD EditorSpellCheckDone() override {
+    // Ignore this callback if SetEnableRealTimeSpell(false) was called after
+    // the UpdateCurrentDictionary call that triggered it.
+    return mSpellChecker->GetDisabledAsyncToken() > mDisabledAsyncToken
+               ? NS_OK
+               : mSpellChecker->CurrentDictionaryUpdated();
+  }
+
+ private:
+  ~UpdateCurrentDictionaryCallback() {}
+
+  RefPtr<mozInlineSpellChecker> mSpellChecker;
+  uint32_t mDisabledAsyncToken;
+};
+NS_IMPL_ISUPPORTS(UpdateCurrentDictionaryCallback, nsIEditorSpellCheckCallback)
+
+NS_IMETHODIMP mozInlineSpellChecker::UpdateCurrentDictionary() {
+  // mSpellCheck is null and mPendingSpellCheck is nonnull while the spell
+  // checker is being initialized.  Calling UpdateCurrentDictionary on
+  // mPendingSpellCheck simply queues the dictionary update after the init.
+  RefPtr<EditorSpellCheck> spellCheck =
+      mSpellCheck ? mSpellCheck : mPendingSpellCheck;
+  if (!spellCheck) {
+    return NS_OK;
+  }
+
+  RefPtr<UpdateCurrentDictionaryCallback> cb =
+      new UpdateCurrentDictionaryCallback(this, mDisabledAsyncToken);
+  NS_ENSURE_STATE(cb);
+  nsresult rv = spellCheck->UpdateCurrentDictionary(cb);
+  if (NS_FAILED(rv)) {
+    cb = nullptr;
+    return rv;
+  }
+  mNumPendingUpdateCurrentDictionary++;
+  ChangeNumPendingSpellChecks(1);
+
+  return NS_OK;
+}
+
+// Called when nsIEditorSpellCheck::UpdateCurrentDictionary completes.
+nsresult mozInlineSpellChecker::CurrentDictionaryUpdated() {
+  mNumPendingUpdateCurrentDictionary--;
+  MOZ_ASSERT(mNumPendingUpdateCurrentDictionary >= 0,
+             "CurrentDictionaryUpdated called without corresponding "
+             "UpdateCurrentDictionary call!");
+  ChangeNumPendingSpellChecks(-1);
+
+  nsresult rv = SpellCheckRange(nullptr);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+mozInlineSpellChecker::GetSpellCheckPending(bool* aPending) {
+  *aPending = mNumPendingSpellChecks > 0;
+  return NS_OK;
+}