blob: a85d0830a1edb83a467dad98b9f6376657cc0bd2 [file] [log] [blame]
/*
* Copyright (C) 2006-2020 Apple Inc. All rights reserved.
* Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "TextCheckingHelper.h"
#include "Document.h"
#include "DocumentMarkerController.h"
#include "Frame.h"
#include "FrameSelection.h"
#include "Settings.h"
#include "TextCheckerClient.h"
#include "TextIterator.h"
#include "VisiblePosition.h"
#include "VisibleUnits.h"
#include <unicode/ubrk.h>
#include <wtf/text/StringView.h>
#include <wtf/text/TextBreakIterator.h>
namespace WebCore {
#if !USE(UNIFIED_TEXT_CHECKING)
static void findGrammaticalErrors(TextCheckerClient& client, StringView text, Vector<TextCheckingResult>& results)
{
for (unsigned checkLocation = 0; checkLocation < text.length(); ) {
int badGrammarLocation = -1;
int badGrammarLength = 0;
Vector<GrammarDetail> badGrammarDetails;
client.checkGrammarOfString(text.substring(checkLocation), badGrammarDetails, &badGrammarLocation, &badGrammarLength);
if (!badGrammarLength)
break;
ASSERT(badGrammarLocation >= 0);
ASSERT(static_cast<unsigned>(badGrammarLocation) <= text.length() - checkLocation);
ASSERT(badGrammarLength > 0);
ASSERT(static_cast<unsigned>(badGrammarLength) <= text.length() - checkLocation - badGrammarLocation);
TextCheckingResult badGrammar;
badGrammar.type = TextCheckingType::Grammar;
badGrammar.range = CharacterRange(checkLocation + badGrammarLocation, badGrammarLength);
badGrammar.details = WTFMove(badGrammarDetails);
results.append(badGrammar);
checkLocation += badGrammarLocation + badGrammarLength;
}
}
static void findMisspellings(TextCheckerClient& client, StringView text, Vector<TextCheckingResult>& results)
{
UBreakIterator* iterator = wordBreakIterator(text);
if (!iterator)
return;
for (int wordStart = ubrk_current(iterator); wordStart >= 0; ) {
int wordEnd = ubrk_next(iterator);
if (wordEnd < 0)
break;
int wordLength = wordEnd - wordStart;
int misspellingLocation = -1;
int misspellingLength = 0;
client.checkSpellingOfString(text.substring(wordStart, wordLength), &misspellingLocation, &misspellingLength);
if (misspellingLength > 0) {
ASSERT(misspellingLocation >= 0);
ASSERT(misspellingLocation <= wordLength);
ASSERT(misspellingLength > 0);
ASSERT(misspellingLocation + misspellingLength <= wordLength);
TextCheckingResult misspelling;
misspelling.type = TextCheckingType::Spelling;
misspelling.range = CharacterRange(wordStart + misspellingLocation, misspellingLength);
misspelling.replacement = client.getAutoCorrectSuggestionForMisspelledWord(text.substring(misspelling.range.location, misspelling.range.length).toStringWithoutCopying());
results.append(misspelling);
}
wordStart = wordEnd;
}
}
#endif
static Ref<Range> expandToParagraphBoundary(Range& range)
{
Ref<Range> paragraphRange = range.cloneRange();
setStart(paragraphRange.ptr(), startOfParagraph(range.startPosition()));
setEnd(paragraphRange.ptr(), endOfParagraph(range.endPosition()));
return paragraphRange;
}
TextCheckingParagraph::TextCheckingParagraph(Ref<Range>&& checkingAndAutomaticReplacementRange)
: m_checkingRange(checkingAndAutomaticReplacementRange.copyRef())
, m_automaticReplacementRange(checkingAndAutomaticReplacementRange.copyRef())
{
}
TextCheckingParagraph::TextCheckingParagraph(Ref<Range>&& checkingRange, Ref<Range>&& automaticReplacementRange, RefPtr<Range>&& paragraphRange)
: m_checkingRange(WTFMove(checkingRange))
, m_automaticReplacementRange(WTFMove(automaticReplacementRange))
, m_paragraphRange(WTFMove(paragraphRange))
{
}
void TextCheckingParagraph::expandRangeToNextEnd()
{
setEnd(&paragraphRange(), endOfParagraph(startOfNextParagraph(paragraphRange().startPosition())));
invalidateParagraphRangeValues();
}
void TextCheckingParagraph::invalidateParagraphRangeValues()
{
m_checkingStart.reset();
m_automaticReplacementStart.reset();
m_automaticReplacementLength.reset();
m_offsetAsRange = nullptr;
m_text = String();
}
uint64_t TextCheckingParagraph::rangeLength() const
{
return characterCount(paragraphRange());
}
Range& TextCheckingParagraph::paragraphRange() const
{
if (!m_paragraphRange)
m_paragraphRange = expandToParagraphBoundary(m_checkingRange);
return *m_paragraphRange;
}
Ref<Range> TextCheckingParagraph::subrange(CharacterRange range) const
{
return createLiveRange(resolveCharacterRange(paragraphRange(), range));
}
ExceptionOr<uint64_t> TextCheckingParagraph::offsetTo(const Position& position) const
{
auto start = makeBoundaryPoint(paragraphRange().startPosition());
auto end = makeBoundaryPoint(position);
if (!start || !end)
return Exception { TypeError };
return characterCount({ *start, *end });
}
bool TextCheckingParagraph::isEmpty() const
{
// Both predicates should have same result, but we check both just for sure.
// We need to investigate to remove this redundancy.
return checkingStart() >= checkingEnd() || text().isEmpty();
}
Range& TextCheckingParagraph::offsetAsRange() const
{
if (!m_offsetAsRange)
m_offsetAsRange = Range::create(paragraphRange().startContainer().document(), paragraphRange().startPosition(), m_checkingRange->startPosition());
return *m_offsetAsRange;
}
StringView TextCheckingParagraph::text() const
{
if (m_text.isNull())
m_text = plainText(paragraphRange());
return m_text;
}
uint64_t TextCheckingParagraph::checkingStart() const
{
if (!m_checkingStart)
m_checkingStart = characterCount(offsetAsRange());
return *m_checkingStart;
}
uint64_t TextCheckingParagraph::checkingEnd() const
{
return checkingStart() + checkingLength();
}
uint64_t TextCheckingParagraph::checkingLength() const
{
if (!m_checkingLength)
m_checkingLength = characterCount(m_checkingRange);
return *m_checkingLength;
}
uint64_t TextCheckingParagraph::automaticReplacementStart() const
{
if (m_automaticReplacementStart)
return *m_automaticReplacementStart;
auto start = makeBoundaryPoint(paragraphRange().startPosition());
auto end = makeBoundaryPoint(m_automaticReplacementRange->startPosition());
if (!start || !end)
return 0;
m_automaticReplacementStart = characterCount({ *start, *end });
return *m_automaticReplacementStart;
}
uint64_t TextCheckingParagraph::automaticReplacementLength() const
{
if (m_automaticReplacementLength)
return *m_automaticReplacementLength;
m_automaticReplacementLength = characterCount(m_automaticReplacementRange);
return *m_automaticReplacementLength;
}
TextCheckingHelper::TextCheckingHelper(EditorClient& client, const SimpleRange& range)
: m_client(client)
, m_range(range)
{
}
TextCheckingHelper::~TextCheckingHelper() = default;
String TextCheckingHelper::findFirstMisspelling(uint64_t& firstMisspellingOffset, bool markAll, RefPtr<Range>& firstMisspellingRange)
{
firstMisspellingOffset = 0;
String firstMisspelling;
uint64_t currentChunkOffset = 0;
for (WordAwareIterator it(m_range); !it.atEnd(); currentChunkOffset += it.text().length(), it.advance()) {
StringView text = it.text();
int textLength = text.length();
// Skip some work for one-space-char hunks.
if (textLength == 1 && text[0] == ' ')
continue;
int misspellingLocation = -1;
int misspellingLength = 0;
m_client.textChecker()->checkSpellingOfString(text, &misspellingLocation, &misspellingLength);
// 5490627 shows that there was some code path here where the String constructor below crashes.
// We don't know exactly what combination of bad input caused this, so we're making this much
// more robust against bad input on release builds.
ASSERT(misspellingLength >= 0);
ASSERT(misspellingLocation >= -1);
ASSERT(!misspellingLength || misspellingLocation >= 0);
ASSERT(misspellingLocation < textLength);
ASSERT(misspellingLength <= textLength);
ASSERT(misspellingLocation + misspellingLength <= textLength);
if (misspellingLocation >= 0 && misspellingLength > 0 && misspellingLocation < textLength && misspellingLength <= textLength && misspellingLocation + misspellingLength <= textLength) {
// Compute range of misspelled word
auto misspellingRange = resolveCharacterRange(m_range, CharacterRange(currentChunkOffset + misspellingLocation, misspellingLength));
// Remember first-encountered misspelling and its offset.
if (!firstMisspelling) {
firstMisspellingOffset = currentChunkOffset + misspellingLocation;
firstMisspelling = text.substring(misspellingLocation, misspellingLength).toString();
firstMisspellingRange = createLiveRange(misspellingRange);
}
// Store marker for misspelled word.
misspellingRange.start.document().markers().addMarker(misspellingRange, DocumentMarker::Spelling);
// Bail out if we're marking only the first misspelling, and not all instances.
if (!markAll)
break;
}
}
return firstMisspelling;
}
String TextCheckingHelper::findFirstMisspellingOrBadGrammar(bool checkGrammar, bool& outIsSpelling, uint64_t& outFirstFoundOffset, GrammarDetail& outGrammarDetail)
{
if (!unifiedTextCheckerEnabled())
return emptyString();
if (platformDrivenTextCheckerEnabled())
return emptyString();
String firstFoundItem;
String misspelledWord;
String badGrammarPhrase;
// Initialize out parameters; these will be updated if we find something to return.
outIsSpelling = true;
outFirstFoundOffset = 0;
outGrammarDetail.range = { };
outGrammarDetail.guesses.clear();
outGrammarDetail.userDescription = emptyString();
// Expand the search range to encompass entire paragraphs, since text checking needs that much context.
// Determine the character offset from the start of the paragraph to the start of the original search range,
// since we will want to ignore results in this area.
Ref<Range> paragraphRange = createLiveRange(m_range);
setStart(paragraphRange.ptr(), startOfParagraph(createLegacyEditingPosition(m_range.start)));
auto totalRangeLength = characterCount(paragraphRange);
setEnd(paragraphRange.ptr(), endOfParagraph(createLegacyEditingPosition(m_range.start)));
auto rangeStartOffset = characterCount({ *makeBoundaryPoint(paragraphRange->startPosition()), m_range.start });
uint64_t totalLengthProcessed = 0;
bool firstIteration = true;
bool lastIteration = false;
while (totalLengthProcessed < totalRangeLength) {
// Iterate through the search range by paragraphs, checking each one for spelling and grammar.
auto currentLength = characterCount(paragraphRange);
uint64_t currentStartOffset = firstIteration ? rangeStartOffset : 0;
uint64_t currentEndOffset = currentLength;
if (inSameParagraph(paragraphRange->startPosition(), createLegacyEditingPosition(m_range.end))) {
// Determine the character offset from the end of the original search range to the end of the paragraph,
// since we will want to ignore results in this area.
currentEndOffset = characterCount({ *makeBoundaryPoint(paragraphRange->startPosition()), m_range.end });
lastIteration = true;
}
if (currentStartOffset < currentEndOffset) {
String paragraphString = plainText(paragraphRange);
if (paragraphString.length() > 0) {
bool foundGrammar = false;
uint64_t spellingLocation = 0;
uint64_t grammarPhraseLocation = 0;
uint64_t grammarDetailLocation = 0;
unsigned grammarDetailIndex = 0;
Vector<TextCheckingResult> results;
OptionSet<TextCheckingType> checkingTypes { TextCheckingType::Spelling };
if (checkGrammar)
checkingTypes.add(TextCheckingType::Grammar);
VisibleSelection currentSelection;
if (Frame* frame = paragraphRange->ownerDocument().frame())
currentSelection = frame->selection().selection();
checkTextOfParagraph(*m_client.textChecker(), paragraphString, checkingTypes, results, currentSelection);
for (auto& result : results) {
if (result.type == TextCheckingType::Spelling && result.range.location >= currentStartOffset && result.range.location + result.range.length <= currentEndOffset) {
ASSERT(result.range.length > 0);
ASSERT(result.range.location >= 0);
spellingLocation = result.range.location;
misspelledWord = paragraphString.substring(result.range.location, result.range.length);
ASSERT(misspelledWord.length());
break;
}
if (checkGrammar && result.type == TextCheckingType::Grammar && result.range.location < currentEndOffset && result.range.location + result.range.length > currentStartOffset) {
ASSERT(result.range.length > 0);
ASSERT(result.range.location >= 0);
// We can't stop after the first grammar result, since there might still be a spelling result after
// it begins but before the first detail in it, but we can stop if we find a second grammar result.
if (foundGrammar)
break;
for (unsigned j = 0; j < result.details.size(); j++) {
const GrammarDetail* detail = &result.details[j];
ASSERT(detail->range.length > 0);
ASSERT(detail->range.location >= 0);
if (result.range.location + detail->range.location >= currentStartOffset && result.range.location + detail->range.location + detail->range.length <= currentEndOffset && (!foundGrammar || result.range.location + detail->range.location < grammarDetailLocation)) {
grammarDetailIndex = j;
grammarDetailLocation = result.range.location + detail->range.location;
foundGrammar = true;
}
}
if (foundGrammar) {
grammarPhraseLocation = result.range.location;
outGrammarDetail = result.details[grammarDetailIndex];
badGrammarPhrase = paragraphString.substring(result.range.location, result.range.length);
ASSERT(badGrammarPhrase.length());
}
}
}
if (!misspelledWord.isEmpty() && (!checkGrammar || badGrammarPhrase.isEmpty() || spellingLocation <= grammarDetailLocation)) {
uint64_t spellingOffset = spellingLocation - currentStartOffset;
if (!firstIteration)
spellingOffset += characterCount({ m_range.start, *makeBoundaryPoint(paragraphRange->startPosition()) });
outIsSpelling = true;
outFirstFoundOffset = spellingOffset;
firstFoundItem = misspelledWord;
break;
}
if (checkGrammar && !badGrammarPhrase.isEmpty()) {
uint64_t grammarPhraseOffset = grammarPhraseLocation - currentStartOffset;
if (!firstIteration)
grammarPhraseOffset += characterCount({ m_range.start, *makeBoundaryPoint(paragraphRange->startPosition()) });
outIsSpelling = false;
outFirstFoundOffset = grammarPhraseOffset;
firstFoundItem = badGrammarPhrase;
break;
}
}
}
if (lastIteration || totalLengthProcessed + currentLength >= totalRangeLength)
break;
VisiblePosition newParagraphStart = startOfNextParagraph(paragraphRange->endPosition());
if (!setStart(paragraphRange.ptr(), newParagraphStart))
break;
if (!setEnd(paragraphRange.ptr(), endOfParagraph(newParagraphStart)))
break;
firstIteration = false;
totalLengthProcessed += currentLength;
}
return firstFoundItem;
}
int TextCheckingHelper::findFirstGrammarDetail(const Vector<GrammarDetail>& grammarDetails, uint64_t badGrammarPhraseLocation, uint64_t startOffset, uint64_t endOffset, bool markAll) const
{
// Found some bad grammar. Find the earliest detail range that starts in our search range (if any).
// Optionally add a DocumentMarker for each detail in the range.
uint64_t earliestDetailLocationSoFar = 0;
int earliestDetailIndex = -1;
for (unsigned i = 0; i < grammarDetails.size(); i++) {
const GrammarDetail* detail = &grammarDetails[i];
ASSERT(detail->range.length > 0);
ASSERT(detail->range.location >= 0);
uint64_t detailStartOffsetInParagraph = badGrammarPhraseLocation + detail->range.location;
// Skip this detail if it starts before the original search range
if (detailStartOffsetInParagraph < startOffset)
continue;
// Skip this detail if it starts after the original search range
if (detailStartOffsetInParagraph >= endOffset)
continue;
if (markAll) {
auto badGrammarRange = resolveCharacterRange(m_range, { badGrammarPhraseLocation - startOffset + detail->range.location, detail->range.length });
badGrammarRange.start.document().markers().addMarker(badGrammarRange, DocumentMarker::Grammar, detail->userDescription);
}
// Remember this detail only if it's earlier than our current candidate (the details aren't in a guaranteed order)
if (earliestDetailIndex < 0 || earliestDetailLocationSoFar > detail->range.location) {
earliestDetailIndex = i;
earliestDetailLocationSoFar = detail->range.location;
}
}
return earliestDetailIndex;
}
String TextCheckingHelper::findFirstBadGrammar(GrammarDetail& outGrammarDetail, uint64_t& outGrammarPhraseOffset, bool markAll) const
{
// Initialize out parameters; these will be updated if we find something to return.
outGrammarDetail.range = { };
outGrammarDetail.guesses.clear();
outGrammarDetail.userDescription = emptyString();
outGrammarPhraseOffset = 0;
StringView firstBadGrammarPhrase;
// Expand the search range to encompass entire paragraphs, since grammar checking needs that much context.
// Determine the character offset from the start of the paragraph to the start of the original search range,
// since we will want to ignore results in this area.
TextCheckingParagraph paragraph(createLiveRange(m_range));
// Start checking from beginning of paragraph, but skip past results that occur before the start of the original search range.
for (uint64_t startOffset = 0; startOffset < paragraph.checkingEnd(); ) {
Vector<GrammarDetail> grammarDetails;
int badGrammarPhraseLocation = -1;
int badGrammarPhraseLength = 0;
m_client.textChecker()->checkGrammarOfString(paragraph.text().substring(startOffset), grammarDetails, &badGrammarPhraseLocation, &badGrammarPhraseLength);
if (!badGrammarPhraseLength) {
ASSERT(badGrammarPhraseLocation == -1);
return String();
}
ASSERT(badGrammarPhraseLocation >= 0);
badGrammarPhraseLocation += startOffset;
// Found some bad grammar. Find the earliest detail range that starts in our search range (if any).
int badGrammarIndex = findFirstGrammarDetail(grammarDetails, badGrammarPhraseLocation, paragraph.checkingStart(), paragraph.checkingEnd(), markAll);
if (badGrammarIndex >= 0) {
ASSERT(static_cast<unsigned>(badGrammarIndex) < grammarDetails.size());
outGrammarDetail = grammarDetails[badGrammarIndex];
}
// If we found a detail in range, then we have found the first bad phrase (unless we found one earlier but
// kept going so we could mark all instances).
if (badGrammarIndex >= 0 && firstBadGrammarPhrase.isEmpty()) {
outGrammarPhraseOffset = badGrammarPhraseLocation - paragraph.checkingStart();
firstBadGrammarPhrase = paragraph.text().substring(badGrammarPhraseLocation, badGrammarPhraseLength);
// Found one. We're done now, unless we're marking each instance.
if (!markAll)
break;
}
// These results were all between the start of the paragraph and the start of the search range; look
// beyond this phrase.
startOffset = badGrammarPhraseLocation + badGrammarPhraseLength;
}
return firstBadGrammarPhrase.toString();
}
bool TextCheckingHelper::isUngrammatical() const
{
if (m_range.collapsed())
return false;
// Returns true only if the passed range exactly corresponds to a bad grammar detail range. This is analogous
// to isSelectionMisspelled. It's not good enough for there to be some bad grammar somewhere in the range,
// or overlapping the range; the ranges must exactly match.
uint64_t grammarPhraseOffset;
GrammarDetail grammarDetail;
String badGrammarPhrase = findFirstBadGrammar(grammarDetail, grammarPhraseOffset, false);
// No bad grammar in these parts at all.
if (badGrammarPhrase.isEmpty())
return false;
// Bad grammar, but phrase (e.g. sentence) starts beyond start of range.
if (grammarPhraseOffset > 0)
return false;
ASSERT(grammarDetail.range.location >= 0);
ASSERT(grammarDetail.range.length > 0);
// Bad grammar, but start of detail (e.g. ungrammatical word) doesn't match start of range
if (grammarDetail.range.location + grammarPhraseOffset)
return false;
// Bad grammar at start of range, but end of bad grammar is before or after end of range
if (grammarDetail.range.length != characterCount(m_range))
return false;
// Update the spelling panel to be displaying this error (whether or not the spelling panel is on screen).
// This is necessary to make a subsequent call to [NSSpellChecker ignoreWord:inSpellDocumentWithTag:] work
// correctly; that call behaves differently based on whether the spelling panel is displaying a misspelling
// or a grammar error.
m_client.updateSpellingUIWithGrammarString(badGrammarPhrase, grammarDetail);
return true;
}
Vector<String> TextCheckingHelper::guessesForMisspelledOrUngrammaticalRange(bool checkGrammar, bool& misspelled, bool& ungrammatical) const
{
if (!unifiedTextCheckerEnabled())
return Vector<String>();
if (platformDrivenTextCheckerEnabled())
return Vector<String>();
Vector<String> guesses;
misspelled = false;
ungrammatical = false;
if (m_range.collapsed())
return guesses;
// Expand the range to encompass entire paragraphs, since text checking needs that much context.
TextCheckingParagraph paragraph(createLiveRange(m_range));
if (paragraph.isEmpty())
return guesses;
Vector<TextCheckingResult> results;
OptionSet<TextCheckingType> checkingTypes { TextCheckingType::Spelling };
if (checkGrammar)
checkingTypes.add(TextCheckingType::Grammar);
VisibleSelection currentSelection;
if (auto frame = m_range.start.document().frame())
currentSelection = frame->selection().selection();
checkTextOfParagraph(*m_client.textChecker(), paragraph.text(), checkingTypes, results, currentSelection);
for (auto& result : results) {
if (result.type == TextCheckingType::Spelling && paragraph.checkingRangeMatches(result.range)) {
String misspelledWord = paragraph.checkingSubstring().toString();
ASSERT(misspelledWord.length());
m_client.textChecker()->getGuessesForWord(misspelledWord, String(), currentSelection, guesses);
m_client.updateSpellingUIWithMisspelledWord(misspelledWord);
misspelled = true;
return guesses;
}
}
if (!checkGrammar)
return guesses;
for (auto& result : results) {
if (result.type == TextCheckingType::Grammar && paragraph.isCheckingRangeCoveredBy(result.range)) {
for (auto& detail : result.details) {
ASSERT(detail.range.length > 0);
ASSERT(detail.range.location >= 0);
if (paragraph.checkingRangeMatches({ result.range.location + detail.range.location, detail.range.length })) {
String badGrammarPhrase = paragraph.text().substring(result.range.location, result.range.length).toString();
ASSERT(badGrammarPhrase.length());
for (auto& guess : detail.guesses)
guesses.append(guess);
m_client.updateSpellingUIWithGrammarString(badGrammarPhrase, detail);
ungrammatical = true;
return guesses;
}
}
}
}
return guesses;
}
void TextCheckingHelper::markAllMisspellings(RefPtr<Range>& firstMisspellingRange)
{
// Use the "markAll" feature of findFirstMisspelling. Ignore the return value and the "out parameter";
// all we need to do is mark every instance.
uint64_t ignoredOffset;
findFirstMisspelling(ignoredOffset, true, firstMisspellingRange);
}
void TextCheckingHelper::markAllBadGrammar()
{
// Use the "markAll" feature of ofindFirstBadGrammar. Ignore the return value and "out parameters"; all we need to
// do is mark every instance.
GrammarDetail ignoredGrammarDetail;
uint64_t ignoredOffset;
findFirstBadGrammar(ignoredGrammarDetail, ignoredOffset, true);
}
bool TextCheckingHelper::unifiedTextCheckerEnabled() const
{
return WebCore::unifiedTextCheckerEnabled(m_range.start.document().frame());
}
void checkTextOfParagraph(TextCheckerClient& client, StringView text, OptionSet<TextCheckingType> checkingTypes, Vector<TextCheckingResult>& results, const VisibleSelection& currentSelection)
{
#if USE(UNIFIED_TEXT_CHECKING)
results = client.checkTextOfParagraph(text, checkingTypes, currentSelection);
#else
UNUSED_PARAM(currentSelection);
Vector<TextCheckingResult> misspellings;
if (checkingTypes.contains(TextCheckingType::Spelling))
findMisspellings(client, text, misspellings);
// Look for grammatical errors that occur before the first misspelling.
Vector<TextCheckingResult> grammaticalErrors;
if (checkingTypes.contains(TextCheckingType::Grammar)) {
unsigned grammarCheckLength = text.length();
for (auto& misspelling : misspellings)
grammarCheckLength = std::min<unsigned>(grammarCheckLength, misspelling.range.location);
findGrammaticalErrors(client, text.substring(0, grammarCheckLength), grammaticalErrors);
}
results = WTFMove(grammaticalErrors);
if (results.isEmpty())
results = WTFMove(misspellings);
else
results.appendVector(misspellings);
#endif // USE(UNIFIED_TEXT_CHECKING)
}
bool unifiedTextCheckerEnabled(const Frame* frame)
{
if (!frame)
return false;
return frame->settings().unifiedTextCheckerEnabled();
}
bool platformDrivenTextCheckerEnabled()
{
#if ENABLE(PLATFORM_DRIVEN_TEXT_CHECKING)
return true;
#else
return false;
#endif
}
}