blob: 67e8aa823ea80ace3f240be70082739faddc4b60 [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/spellcheck/renderer/spellcheck.h"
#include <stddef.h>
#include <stdint.h>
#include <algorithm>
#include <memory>
#include <utility>
#include "base/bind.h"
#include "base/command_line.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/macros.h"
#include "base/single_thread_task_runner.h"
#include "base/stl_util.h"
#include "base/threading/thread_task_runner_handle.h"
#include "build/build_config.h"
#include "components/spellcheck/common/spellcheck_common.h"
#include "components/spellcheck/common/spellcheck_features.h"
#include "components/spellcheck/common/spellcheck_result.h"
#include "components/spellcheck/common/spellcheck_switches.h"
#include "components/spellcheck/renderer/spellcheck_language.h"
#include "components/spellcheck/renderer/spellcheck_provider.h"
#include "components/spellcheck/spellcheck_buildflags.h"
#include "content/public/common/service_manager_connection.h"
#include "content/public/common/simple_connection_filter.h"
#include "content/public/renderer/render_frame.h"
#include "content/public/renderer/render_frame_visitor.h"
#include "content/public/renderer/render_thread.h"
#include "third_party/blink/public/platform/web_string.h"
#include "third_party/blink/public/platform/web_vector.h"
#include "third_party/blink/public/web/web_local_frame.h"
#include "third_party/blink/public/web/web_text_checking_completion.h"
#include "third_party/blink/public/web/web_text_checking_result.h"
#include "third_party/blink/public/web/web_text_decoration_type.h"
using blink::WebVector;
using blink::WebString;
using blink::WebTextCheckingResult;
using blink::WebTextDecorationType;
namespace {
const int kNoOffset = 0;
const int kNoTag = 0;
class UpdateSpellcheckEnabled : public content::RenderFrameVisitor {
public:
explicit UpdateSpellcheckEnabled(bool enabled) : enabled_(enabled) {}
bool Visit(content::RenderFrame* render_frame) override;
private:
bool enabled_; // New spellcheck-enabled state.
DISALLOW_COPY_AND_ASSIGN(UpdateSpellcheckEnabled);
};
bool UpdateSpellcheckEnabled::Visit(content::RenderFrame* render_frame) {
if (!enabled_) {
if (render_frame && render_frame->GetWebFrame())
render_frame->GetWebFrame()->RemoveSpellingMarkers();
}
return true;
}
WebVector<WebString> ConvertToWebStringFromUtf8(
const std::set<std::string>& words) {
WebVector<WebString> result(words.size());
std::transform(words.begin(), words.end(), result.begin(),
[](const std::string& w) { return WebString::FromUTF8(w); });
return result;
}
bool IsApostrophe(base::char16 c) {
const base::char16 kApostrophe = 0x27;
const base::char16 kRightSingleQuotationMark = 0x2019;
return c == kApostrophe || c == kRightSingleQuotationMark;
}
// Makes sure that the apostrophes in the |spelling_suggestion| are the same
// type as in the |misspelled_word| and in the same order. Ignore differences in
// the number of apostrophes.
void PreserveOriginalApostropheTypes(const base::string16& misspelled_word,
base::string16* spelling_suggestion) {
auto it = spelling_suggestion->begin();
for (const base::char16& c : misspelled_word) {
if (IsApostrophe(c)) {
it = std::find_if(it, spelling_suggestion->end(), IsApostrophe);
if (it == spelling_suggestion->end())
return;
*it++ = c;
}
}
}
std::vector<WebString> FilterReplacementSuggestions(
const base::string16& misspelled_word,
const std::vector<base::string16>& replacements) {
std::vector<WebString> replacements_filtered;
for (base::string16 replacement : replacements) {
// Use the same types of apostrophes as in the mispelled word.
PreserveOriginalApostropheTypes(misspelled_word, &replacement);
// Ignore suggestions that are just changing the apostrophe type
// (straight vs. typographical)
if (replacement == misspelled_word)
continue;
replacements_filtered.push_back(WebString::FromUTF16(replacement));
}
return replacements_filtered;
}
} // namespace
class SpellCheck::SpellcheckRequest {
public:
SpellcheckRequest(const base::string16& text,
blink::WebTextCheckingCompletion* completion)
: text_(text), completion_(completion) {
DCHECK(completion);
}
~SpellcheckRequest() {}
base::string16 text() { return text_; }
blink::WebTextCheckingCompletion* completion() { return completion_; }
private:
base::string16 text_; // Text to be checked in this task.
// The interface to send the misspelled ranges to WebKit.
blink::WebTextCheckingCompletion* completion_;
DISALLOW_COPY_AND_ASSIGN(SpellcheckRequest);
};
// Initializes SpellCheck object.
// spellcheck_enabled_ currently MUST be set to true, due to peculiarities of
// the initialization sequence.
// Since it defaults to true, newly created SpellCheckProviders will enable
// spellchecking. After the first word is typed, the provider requests a check,
// which in turn triggers the delayed initialization sequence in SpellCheck.
// This does send a message to the browser side, which triggers the creation
// of the SpellcheckService. That does create the observer for the preference
// responsible for enabling/disabling checking, which allows subsequent changes
// to that preference to be sent to all SpellCheckProviders.
// Setting |spellcheck_enabled_| to false by default prevents that mechanism,
// and as such the SpellCheckProviders will never be notified of different
// values.
// TODO(groby): Simplify this.
SpellCheck::SpellCheck(
service_manager::BinderRegistry* registry,
service_manager::LocalInterfaceProvider* embedder_provider)
: embedder_provider_(embedder_provider),
spellcheck_enabled_(true),
weak_factory_(this) {
DCHECK(embedder_provider);
if (!registry)
return; // Can be NULL in tests.
registry->AddInterface(base::BindRepeating(&SpellCheck::SpellCheckerRequest,
weak_factory_.GetWeakPtr()),
base::ThreadTaskRunnerHandle::Get());
}
SpellCheck::~SpellCheck() {
}
void SpellCheck::FillSuggestions(
const std::vector<std::vector<base::string16>>& suggestions_list,
std::vector<base::string16>* optional_suggestions) {
DCHECK(optional_suggestions);
size_t num_languages = suggestions_list.size();
// Compute maximum number of suggestions in a single language.
size_t max_suggestions = 0;
for (const auto& suggestions : suggestions_list)
max_suggestions = std::max(max_suggestions, suggestions.size());
for (size_t count = 0; count < (max_suggestions * num_languages); ++count) {
size_t language = count % num_languages;
size_t index = count / num_languages;
if (suggestions_list[language].size() <= index)
continue;
const base::string16& suggestion = suggestions_list[language][index];
// Only add the suggestion if it's unique.
if (!base::ContainsValue(*optional_suggestions, suggestion)) {
optional_suggestions->push_back(suggestion);
}
if (optional_suggestions->size() >= spellcheck::kMaxSuggestions) {
break;
}
}
}
void SpellCheck::SpellCheckerRequest(
spellcheck::mojom::SpellCheckerRequest request) {
bindings_.AddBinding(this, std::move(request));
}
void SpellCheck::Initialize(
std::vector<spellcheck::mojom::SpellCheckBDictLanguagePtr> dictionaries,
const std::vector<std::string>& custom_words,
bool enable) {
languages_.clear();
for (const auto& dictionary : dictionaries)
AddSpellcheckLanguage(std::move(dictionary->file), dictionary->language);
custom_dictionary_.Init(
std::set<std::string>(custom_words.begin(), custom_words.end()));
#if !BUILDFLAG(USE_BROWSER_SPELLCHECKER)
PostDelayedSpellCheckTask(pending_request_param_.release());
#endif
spellcheck_enabled_ = enable;
UpdateSpellcheckEnabled updater(enable);
content::RenderFrame::ForEach(&updater);
}
void SpellCheck::CustomDictionaryChanged(
const std::vector<std::string>& words_added,
const std::vector<std::string>& words_removed) {
const std::set<std::string> added(words_added.begin(), words_added.end());
NotifyDictionaryObservers(ConvertToWebStringFromUtf8(added));
custom_dictionary_.OnCustomDictionaryChanged(
added, std::set<std::string>(words_removed.begin(), words_removed.end()));
}
// TODO(groby): Make sure we always have a spelling engine, even before
// AddSpellcheckLanguage() is called.
void SpellCheck::AddSpellcheckLanguage(base::File file,
const std::string& language) {
languages_.push_back(
std::make_unique<SpellcheckLanguage>(embedder_provider_));
languages_.back()->Init(std::move(file), language);
}
bool SpellCheck::SpellCheckWord(
const base::char16* text_begin,
int position_in_text,
int text_length,
int tag,
int* misspelling_start,
int* misspelling_len,
std::vector<base::string16>* optional_suggestions) {
DCHECK(text_length >= position_in_text);
DCHECK(misspelling_start && misspelling_len) << "Out vars must be given.";
// Do nothing if we need to delay initialization. (Rather than blocking,
// report the word as correctly spelled.)
if (InitializeIfNeeded())
return true;
// These are for holding misspelling or skippable word positions and lengths
// between calls to SpellcheckLanguage::SpellCheckWord.
int possible_misspelling_start;
int possible_misspelling_len;
// The longest sequence of text that all languages agree is skippable.
int agreed_skippable_len;
// A vector of vectors containing spelling suggestions from different
// languages.
std::vector<std::vector<base::string16>> suggestions_list;
// A vector to hold a language's misspelling suggestions between spellcheck
// calls.
std::vector<base::string16> language_suggestions;
// This loop only advances if all languages agree that a sequence of text is
// skippable.
for (; position_in_text <= text_length;
position_in_text += agreed_skippable_len) {
// Reseting |agreed_skippable_len| to the worst-case length each time
// prevents some unnecessary iterations.
agreed_skippable_len = text_length;
*misspelling_start = 0;
*misspelling_len = 0;
suggestions_list.clear();
for (auto language = languages_.begin(); language != languages_.end();) {
language_suggestions.clear();
SpellcheckLanguage::SpellcheckWordResult result =
(*language)->SpellCheckWord(
text_begin, position_in_text, text_length, tag,
&possible_misspelling_start, &possible_misspelling_len,
optional_suggestions ? &language_suggestions : nullptr);
switch (result) {
case SpellcheckLanguage::SpellcheckWordResult::IS_CORRECT:
*misspelling_start = 0;
*misspelling_len = 0;
return true;
case SpellcheckLanguage::SpellcheckWordResult::IS_SKIPPABLE:
agreed_skippable_len =
std::min(agreed_skippable_len, possible_misspelling_len);
// If true, this means the spellchecker moved past a word that was
// previously determined to be misspelled or skippable, which means
// another spellcheck language marked it as correct.
if (position_in_text != possible_misspelling_start) {
*misspelling_len = 0;
position_in_text = possible_misspelling_start;
suggestions_list.clear();
language = languages_.begin();
} else {
language++;
}
break;
case SpellcheckLanguage::SpellcheckWordResult::IS_MISSPELLED:
*misspelling_start = possible_misspelling_start;
*misspelling_len = possible_misspelling_len;
// If true, this means the spellchecker moved past a word that was
// previously determined to be misspelled or skippable, which means
// another spellcheck language marked it as correct.
if (position_in_text != *misspelling_start) {
suggestions_list.clear();
language = languages_.begin();
position_in_text = *misspelling_start;
} else {
suggestions_list.push_back(language_suggestions);
language++;
}
break;
}
}
// If |*misspelling_len| is non-zero, that means at least one language
// marked a word misspelled and no other language considered it correct.
if (*misspelling_len != 0) {
if (optional_suggestions)
FillSuggestions(suggestions_list, optional_suggestions);
return false;
}
}
NOTREACHED();
return true;
}
bool SpellCheck::SpellCheckParagraph(
const base::string16& text,
WebVector<WebTextCheckingResult>* results) {
#if !BUILDFLAG(USE_BROWSER_SPELLCHECKER)
// Mac and Android have their own spell checkers,so this method won't be used
DCHECK(results);
std::vector<WebTextCheckingResult> textcheck_results;
size_t length = text.length();
size_t position_in_text = 0;
// Spellcheck::SpellCheckWord() automatically breaks text into words and
// checks the spellings of the extracted words. This function sets the
// position and length of the first misspelled word and returns false when
// the text includes misspelled words. Therefore, we just repeat calling the
// function until it returns true to check the whole text.
int misspelling_start = 0;
int misspelling_length = 0;
while (position_in_text <= length) {
if (SpellCheckWord(text.c_str(), position_in_text, length, kNoTag,
&misspelling_start, &misspelling_length, nullptr)) {
results->Assign(textcheck_results);
return true;
}
if (!custom_dictionary_.SpellCheckWord(
text, misspelling_start, misspelling_length)) {
textcheck_results.push_back(
WebTextCheckingResult(blink::kWebTextDecorationTypeSpelling,
misspelling_start, misspelling_length));
}
position_in_text = misspelling_start + misspelling_length;
}
results->Assign(textcheck_results);
return false;
#else
// This function is only invoked for spell checker functionality that runs
// on the render thread. OSX and Android builds don't have that.
NOTREACHED();
return true;
#endif
}
// OSX and Android use their own spell checkers
#if !BUILDFLAG(USE_BROWSER_SPELLCHECKER)
void SpellCheck::RequestTextChecking(
const base::string16& text,
blink::WebTextCheckingCompletion* completion) {
// Clean up the previous request before starting a new request.
if (pending_request_param_)
pending_request_param_->completion()->DidCancelCheckingText();
pending_request_param_.reset(new SpellcheckRequest(
text, completion));
// We will check this text after we finish loading the hunspell dictionary.
if (InitializeIfNeeded())
return;
PostDelayedSpellCheckTask(pending_request_param_.release());
}
#endif
bool SpellCheck::InitializeIfNeeded() {
if (languages_.empty())
return true;
bool initialize_if_needed = false;
for (auto& language : languages_)
initialize_if_needed |= language->InitializeIfNeeded();
return initialize_if_needed;
}
// OSX and Android don't have |pending_request_param_|
#if !BUILDFLAG(USE_BROWSER_SPELLCHECKER)
void SpellCheck::PostDelayedSpellCheckTask(SpellcheckRequest* request) {
if (!request)
return;
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(&SpellCheck::PerformSpellCheck, AsWeakPtr(),
base::Owned(request)));
}
#endif
// Mac and Android use their platform engines instead.
#if !BUILDFLAG(USE_BROWSER_SPELLCHECKER)
void SpellCheck::PerformSpellCheck(SpellcheckRequest* param) {
DCHECK(param);
if (languages_.empty() ||
std::find_if(languages_.begin(), languages_.end(),
[](std::unique_ptr<SpellcheckLanguage>& language) {
return !language->IsEnabled();
}) != languages_.end()) {
param->completion()->DidCancelCheckingText();
} else {
WebVector<blink::WebTextCheckingResult> results;
SpellCheckParagraph(param->text(), &results);
param->completion()->DidFinishCheckingText(results);
}
}
#endif
void SpellCheck::CreateTextCheckingResults(
ResultFilter filter,
int line_offset,
const base::string16& line_text,
const std::vector<SpellCheckResult>& spellcheck_results,
WebVector<WebTextCheckingResult>* textcheck_results) {
DCHECK(!line_text.empty());
std::vector<WebTextCheckingResult> results;
for (const SpellCheckResult& spellcheck_result : spellcheck_results) {
DCHECK_LE(static_cast<size_t>(spellcheck_result.location),
line_text.length());
DCHECK_LE(static_cast<size_t>(spellcheck_result.location +
spellcheck_result.length),
line_text.length());
const base::string16& misspelled_word =
line_text.substr(spellcheck_result.location, spellcheck_result.length);
const std::vector<base::string16>& replacements =
spellcheck_result.replacements;
SpellCheckResult::Decoration decoration = spellcheck_result.decoration;
// Ignore words in custom dictionary.
if (custom_dictionary_.SpellCheckWord(misspelled_word, 0,
misspelled_word.length())) {
continue;
}
std::vector<WebString> replacements_filtered =
FilterReplacementSuggestions(misspelled_word, replacements);
// If the spellchecker suggested replacements, but they were all just
// changing apostrophe styles, ignore this misspelling. If there were never
// any suggested replacements, keep the misspelling.
if (replacements_filtered.empty() && !replacements.empty())
continue;
if (filter == USE_NATIVE_CHECKER) {
// Double-check misspelled words with out spellchecker and attach grammar
// markers to them if our spellchecker tells us they are correct words,
// i.e. they are probably contextually-misspelled words.
int unused_misspelling_start = 0;
int unused_misspelling_length = 0;
if (decoration == SpellCheckResult::SPELLING &&
SpellCheckWord(misspelled_word.c_str(), kNoOffset,
misspelled_word.length(), kNoTag,
&unused_misspelling_start, &unused_misspelling_length,
nullptr)) {
decoration = SpellCheckResult::GRAMMAR;
}
}
results.push_back(
WebTextCheckingResult(static_cast<WebTextDecorationType>(decoration),
line_offset + spellcheck_result.location,
spellcheck_result.length, replacements_filtered));
}
textcheck_results->Assign(results);
}
bool SpellCheck::IsSpellcheckEnabled() {
#if defined(OS_ANDROID)
if (!spellcheck::IsAndroidSpellCheckFeatureEnabled()) return false;
#endif
return spellcheck_enabled_;
}
void SpellCheck::AddDictionaryUpdateObserver(
DictionaryUpdateObserver* observer) {
return dictionary_update_observers_.AddObserver(observer);
}
void SpellCheck::RemoveDictionaryUpdateObserver(
DictionaryUpdateObserver* observer) {
return dictionary_update_observers_.RemoveObserver(observer);
}
void SpellCheck::NotifyDictionaryObservers(
const WebVector<WebString>& words_added) {
for (auto& observer : dictionary_update_observers_) {
observer.OnDictionaryUpdated(words_added);
}
}