Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
/**
* 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;
}