feat: Spellchecker Async Implementation (#14032)

* feat:Spellchecker Async Implementation

* Adhere to chromium style

* Updating dependency to use gh branch

* Update docs and electron-typescript-definitions module

* Fix lint

* Update electron typescript definitions version

* Update spec

* Address review
This commit is contained in:
Nitish Sakhawalkar 2018-10-18 09:11:53 -07:00 committed by Charles Kerr
parent 4bbb70de74
commit a9ca152069
9 changed files with 142 additions and 112 deletions

View file

@ -4,7 +4,7 @@
#include "atom/renderer/api/atom_api_spell_check_client.h" #include "atom/renderer/api/atom_api_spell_check_client.h"
#include <algorithm> #include <map>
#include <vector> #include <vector>
#include "atom/common/native_mate_converters/string16_converter.h" #include "atom/common/native_mate_converters/string16_converter.h"
@ -13,6 +13,7 @@
#include "chrome/renderer/spellchecker/spellcheck_worditerator.h" #include "chrome/renderer/spellchecker/spellcheck_worditerator.h"
#include "native_mate/converter.h" #include "native_mate/converter.h"
#include "native_mate/dictionary.h" #include "native_mate/dictionary.h"
#include "native_mate/function_template.h"
#include "third_party/blink/public/web/web_text_checking_completion.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_checking_result.h"
#include "third_party/icu/source/common/unicode/uscript.h" #include "third_party/icu/source/common/unicode/uscript.h"
@ -40,6 +41,10 @@ bool HasWordCharacters(const base::string16& text, int index) {
class SpellCheckClient::SpellcheckRequest { class SpellCheckClient::SpellcheckRequest {
public: public:
// Map of individual words to list of occurrences in text
using WordMap =
std::map<base::string16, std::vector<blink::WebTextCheckingResult>>;
SpellcheckRequest(const base::string16& text, SpellcheckRequest(const base::string16& text,
blink::WebTextCheckingCompletion* completion) blink::WebTextCheckingCompletion* completion)
: text_(text), completion_(completion) { : text_(text), completion_(completion) {
@ -47,12 +52,13 @@ class SpellCheckClient::SpellcheckRequest {
} }
~SpellcheckRequest() {} ~SpellcheckRequest() {}
base::string16 text() { return text_; } const base::string16& text() const { return text_; }
blink::WebTextCheckingCompletion* completion() { return completion_; } blink::WebTextCheckingCompletion* completion() { return completion_; }
WordMap& wordmap() { return word_map_; }
private: private:
base::string16 text_; // Text to be checked in this task. base::string16 text_; // Text to be checked in this task.
WordMap word_map_; // WordMap to hold distinct words in text
// The interface to send the misspelled ranges to WebKit. // The interface to send the misspelled ranges to WebKit.
blink::WebTextCheckingCompletion* completion_; blink::WebTextCheckingCompletion* completion_;
@ -60,10 +66,10 @@ class SpellCheckClient::SpellcheckRequest {
}; };
SpellCheckClient::SpellCheckClient(const std::string& language, SpellCheckClient::SpellCheckClient(const std::string& language,
bool auto_spell_correct_turned_on,
v8::Isolate* isolate, v8::Isolate* isolate,
v8::Local<v8::Object> provider) v8::Local<v8::Object> provider)
: isolate_(isolate), : pending_request_param_(nullptr),
isolate_(isolate),
context_(isolate, isolate->GetCurrentContext()), context_(isolate, isolate->GetCurrentContext()),
provider_(isolate, provider) { provider_(isolate, provider) {
DCHECK(!context_.IsEmpty()); DCHECK(!context_.IsEmpty());
@ -79,19 +85,6 @@ SpellCheckClient::~SpellCheckClient() {
context_.Reset(); context_.Reset();
} }
void SpellCheckClient::CheckSpelling(
const blink::WebString& text,
int& misspelling_start,
int& misspelling_len,
blink::WebVector<blink::WebString>* optional_suggestions) {
std::vector<blink::WebTextCheckingResult> results;
SpellCheckText(text.Utf16(), true, &results);
if (results.size() == 1) {
misspelling_start = results[0].location;
misspelling_len = results[0].length;
}
}
void SpellCheckClient::RequestCheckingOfText( void SpellCheckClient::RequestCheckingOfText(
const blink::WebString& textToCheck, const blink::WebString& textToCheck,
blink::WebTextCheckingCompletion* completionCallback) { blink::WebTextCheckingCompletion* completionCallback) {
@ -103,7 +96,7 @@ void SpellCheckClient::RequestCheckingOfText(
} }
// Clean up the previous request before starting a new request. // Clean up the previous request before starting a new request.
if (pending_request_param_.get()) { if (pending_request_param_) {
pending_request_param_->completion()->DidCancelCheckingText(); pending_request_param_->completion()->DidCancelCheckingText();
} }
@ -111,8 +104,7 @@ void SpellCheckClient::RequestCheckingOfText(
base::ThreadTaskRunnerHandle::Get()->PostTask( base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, FROM_HERE,
base::BindOnce(&SpellCheckClient::PerformSpellCheck, AsWeakPtr(), base::BindOnce(&SpellCheckClient::SpellCheckText, AsWeakPtr()));
base::Owned(pending_request_param_.release())));
} }
bool SpellCheckClient::IsSpellCheckingEnabled() const { bool SpellCheckClient::IsSpellCheckingEnabled() const {
@ -128,12 +120,13 @@ bool SpellCheckClient::IsShowingSpellingUI() {
void SpellCheckClient::UpdateSpellingUIWithMisspelledWord( void SpellCheckClient::UpdateSpellingUIWithMisspelledWord(
const blink::WebString& word) {} const blink::WebString& word) {}
void SpellCheckClient::SpellCheckText( void SpellCheckClient::SpellCheckText() {
const base::string16& text, const auto& text = pending_request_param_->text();
bool stop_at_first_result, if (text.empty() || spell_check_.IsEmpty()) {
std::vector<blink::WebTextCheckingResult>* results) { pending_request_param_->completion()->DidCancelCheckingText();
if (text.empty() || spell_check_.IsEmpty()) pending_request_param_ = nullptr;
return; return;
}
if (!text_iterator_.IsInitialized() && if (!text_iterator_.IsInitialized() &&
!text_iterator_.Initialize(&character_attributes_, true)) { !text_iterator_.Initialize(&character_attributes_, true)) {
@ -153,56 +146,87 @@ void SpellCheckClient::SpellCheckText(
SpellCheckScope scope(*this); SpellCheckScope scope(*this);
base::string16 word; base::string16 word;
int word_start; std::vector<base::string16> words;
int word_length; auto& word_map = pending_request_param_->wordmap();
for (auto status = blink::WebTextCheckingResult result;
text_iterator_.GetNextWord(&word, &word_start, &word_length); for (;;) { // Run until end of text
status != SpellcheckWordIterator::IS_END_OF_TEXT; const auto status =
status = text_iterator_.GetNextWord(&word, &word_start, &word_length)) { text_iterator_.GetNextWord(&word, &result.location, &result.length);
if (status == SpellcheckWordIterator::IS_END_OF_TEXT)
break;
if (status == SpellcheckWordIterator::IS_SKIPPABLE) if (status == SpellcheckWordIterator::IS_SKIPPABLE)
continue; continue;
// Found a word (or a contraction) that the spellchecker can check the
// spelling of.
if (SpellCheckWord(scope, word))
continue;
// If the given word is a concatenated word of two or more valid words // If the given word is a concatenated word of two or more valid words
// (e.g. "hello:hello"), we should treat it as a valid word. // (e.g. "hello:hello"), we should treat it as a valid word.
if (IsValidContraction(scope, word)) std::vector<base::string16> contraction_words;
continue; if (!IsContraction(scope, word, &contraction_words)) {
words.push_back(word);
blink::WebTextCheckingResult result; word_map[word].push_back(result);
result.location = word_start; } else {
result.length = word_length; // For a contraction, we want check the spellings of each individual
results->push_back(result); // part, but mark the entire word incorrect if any part is misspelled
// Hence, we use the same word_start and word_length values for every
if (stop_at_first_result) // part of the contraction.
return; for (const auto& w : contraction_words) {
words.push_back(w);
word_map[w].push_back(result);
} }
}
}
// Send out all the words data to the spellchecker to check
SpellCheckWords(scope, words);
} }
bool SpellCheckClient::SpellCheckWord( void SpellCheckClient::OnSpellCheckDone(
const std::vector<base::string16>& misspelled_words) {
std::vector<blink::WebTextCheckingResult> results;
auto* const completion_handler = pending_request_param_->completion();
auto& word_map = pending_request_param_->wordmap();
// Take each word from the list of misspelled words received, find their
// corresponding WebTextCheckingResult that's stored in the map and pass
// all the results to blink through the completion callback.
for (const auto& word : misspelled_words) {
auto iter = word_map.find(word);
if (iter != word_map.end()) {
// Word found in map, now gather all the occurrences of the word
// from the map value
auto& words = iter->second;
results.insert(results.end(), words.begin(), words.end());
words.clear();
}
}
completion_handler->DidFinishCheckingText(results);
pending_request_param_ = nullptr;
}
void SpellCheckClient::SpellCheckWords(
const SpellCheckScope& scope, const SpellCheckScope& scope,
const base::string16& word_to_check) const { const std::vector<base::string16>& words) {
DCHECK(!scope.spell_check_.IsEmpty()); DCHECK(!scope.spell_check_.IsEmpty());
v8::Local<v8::Value> word = mate::ConvertToV8(isolate_, word_to_check); v8::Local<v8::FunctionTemplate> templ = mate::CreateFunctionTemplate(
v8::Local<v8::Value> result = isolate_, base::Bind(&SpellCheckClient::OnSpellCheckDone, AsWeakPtr()));
scope.spell_check_->Call(scope.provider_, 1, &word);
if (!result.IsEmpty() && result->IsBoolean()) v8::Local<v8::Value> args[] = {mate::ConvertToV8(isolate_, words),
return result->BooleanValue(); templ->GetFunction()};
else // Call javascript with the words and the callback function
return true; scope.spell_check_->Call(scope.provider_, 2, args);
} }
// Returns whether or not the given string is a valid contraction. // Returns whether or not the given string is a contraction.
// This function is a fall-back when the SpellcheckWordIterator class // This function is a fall-back when the SpellcheckWordIterator class
// returns a concatenated word which is not in the selected dictionary // returns a concatenated word which is not in the selected dictionary
// (e.g. "in'n'out") but each word is valid. // (e.g. "in'n'out") but each word is valid.
bool SpellCheckClient::IsValidContraction(const SpellCheckScope& scope, // Output variable contraction_words will contain individual
const base::string16& contraction) { // words in the contraction.
bool SpellCheckClient::IsContraction(
const SpellCheckScope& scope,
const base::string16& contraction,
std::vector<base::string16>* contraction_words) {
DCHECK(contraction_iterator_.IsInitialized()); DCHECK(contraction_iterator_.IsInitialized());
contraction_iterator_.SetText(contraction.c_str(), contraction.length()); contraction_iterator_.SetText(contraction.c_str(), contraction.length());
@ -210,7 +234,6 @@ bool SpellCheckClient::IsValidContraction(const SpellCheckScope& scope,
base::string16 word; base::string16 word;
int word_start; int word_start;
int word_length; int word_length;
for (auto status = for (auto status =
contraction_iterator_.GetNextWord(&word, &word_start, &word_length); contraction_iterator_.GetNextWord(&word, &word_start, &word_length);
status != SpellcheckWordIterator::IS_END_OF_TEXT; status != SpellcheckWordIterator::IS_END_OF_TEXT;
@ -219,18 +242,9 @@ bool SpellCheckClient::IsValidContraction(const SpellCheckScope& scope,
if (status == SpellcheckWordIterator::IS_SKIPPABLE) if (status == SpellcheckWordIterator::IS_SKIPPABLE)
continue; continue;
if (!SpellCheckWord(scope, word)) contraction_words->push_back(word);
return false;
} }
return true; return contraction_words->size() > 1;
}
void SpellCheckClient::PerformSpellCheck(SpellcheckRequest* param) {
DCHECK(param);
std::vector<blink::WebTextCheckingResult> results;
SpellCheckText(param->text(), false, &results);
param->completion()->DidFinishCheckingText(results);
} }
SpellCheckClient::SpellCheckScope::SpellCheckScope( SpellCheckClient::SpellCheckScope::SpellCheckScope(

View file

@ -31,7 +31,6 @@ class SpellCheckClient : public blink::WebSpellCheckPanelHostClient,
public base::SupportsWeakPtr<SpellCheckClient> { public base::SupportsWeakPtr<SpellCheckClient> {
public: public:
SpellCheckClient(const std::string& language, SpellCheckClient(const std::string& language,
bool auto_spell_correct_turned_on,
v8::Isolate* isolate, v8::Isolate* isolate,
v8::Local<v8::Object> provider); v8::Local<v8::Object> provider);
~SpellCheckClient() override; ~SpellCheckClient() override;
@ -39,11 +38,6 @@ class SpellCheckClient : public blink::WebSpellCheckPanelHostClient,
private: private:
class SpellcheckRequest; class SpellcheckRequest;
// blink::WebTextCheckClient: // blink::WebTextCheckClient:
void CheckSpelling(
const blink::WebString& text,
int& misspelledOffset,
int& misspelledLength,
blink::WebVector<blink::WebString>* optionalSuggestions) override;
void RequestCheckingOfText( void RequestCheckingOfText(
const blink::WebString& textToCheck, const blink::WebString& textToCheck,
blink::WebTextCheckingCompletion* completionCallback) override; blink::WebTextCheckingCompletion* completionCallback) override;
@ -65,22 +59,27 @@ class SpellCheckClient : public blink::WebSpellCheckPanelHostClient,
~SpellCheckScope(); ~SpellCheckScope();
}; };
// Check the spelling of text. // Run through the word iterator and send out requests
void SpellCheckText(const base::string16& text, // to the JS API for checking spellings of words in the current
bool stop_at_first_result, // request.
std::vector<blink::WebTextCheckingResult>* results); void SpellCheckText();
// Call JavaScript to check spelling a word. // Call JavaScript to check spelling a word.
bool SpellCheckWord(const SpellCheckScope& scope, // The javascript function will callback OnSpellCheckDone
const base::string16& word_to_check) const; // with the results of all the misspelled words.
void SpellCheckWords(const SpellCheckScope& scope,
const std::vector<base::string16>& words);
// Returns whether or not the given word is a contraction of valid words // Returns whether or not the given word is a contraction of valid words
// (e.g. "word:word"). // (e.g. "word:word").
bool IsValidContraction(const SpellCheckScope& scope, // Output variable contraction_words will contain individual
const base::string16& word); // words in the contraction.
bool IsContraction(const SpellCheckScope& scope,
const base::string16& word,
std::vector<base::string16>* contraction_words);
// Performs spell checking from the request queue. // Callback for the JS API which returns the list of misspelled words.
void PerformSpellCheck(SpellcheckRequest* param); void OnSpellCheckDone(const std::vector<base::string16>& misspelled_words);
// Represents character attributes used for filtering out characters which // Represents character attributes used for filtering out characters which
// are not supported by this SpellCheck object. // are not supported by this SpellCheck object.

View file

@ -215,15 +215,14 @@ int WebFrame::GetWebFrameId(v8::Local<v8::Value> content_window) {
void WebFrame::SetSpellCheckProvider(mate::Arguments* args, void WebFrame::SetSpellCheckProvider(mate::Arguments* args,
const std::string& language, const std::string& language,
bool auto_spell_correct_turned_on,
v8::Local<v8::Object> provider) { v8::Local<v8::Object> provider) {
if (!provider->Has(mate::StringToV8(args->isolate(), "spellCheck"))) { if (!provider->Has(mate::StringToV8(args->isolate(), "spellCheck"))) {
args->ThrowError("\"spellCheck\" has to be defined"); args->ThrowError("\"spellCheck\" has to be defined");
return; return;
} }
auto client = std::make_unique<SpellCheckClient>( auto client =
language, auto_spell_correct_turned_on, args->isolate(), provider); std::make_unique<SpellCheckClient>(language, args->isolate(), provider);
// Set spellchecker for all live frames in the same process or // Set spellchecker for all live frames in the same process or
// in the sandbox mode for all live sub frames to this WebFrame. // in the sandbox mode for all live sub frames to this WebFrame.
FrameSpellChecker spell_checker( FrameSpellChecker spell_checker(

View file

@ -58,7 +58,6 @@ class WebFrame : public mate::Wrappable<WebFrame> {
// Set the provider that will be used by SpellCheckClient for spell check. // Set the provider that will be used by SpellCheckClient for spell check.
void SetSpellCheckProvider(mate::Arguments* args, void SetSpellCheckProvider(mate::Arguments* args,
const std::string& language, const std::string& language,
bool auto_spell_correct_turned_on,
v8::Local<v8::Object> provider); v8::Local<v8::Object> provider);
void RegisterURLSchemeAsBypassingCSP(const std::string& scheme); void RegisterURLSchemeAsBypassingCSP(const std::string& scheme);

View file

@ -57,26 +57,34 @@ Sets the maximum and minimum pinch-to-zoom level.
Sets the maximum and minimum layout-based (i.e. non-visual) zoom level. Sets the maximum and minimum layout-based (i.e. non-visual) zoom level.
### `webFrame.setSpellCheckProvider(language, autoCorrectWord, provider)` ### `webFrame.setSpellCheckProvider(language, provider)`
* `language` String * `language` String
* `autoCorrectWord` Boolean
* `provider` Object * `provider` Object
* `spellCheck` Function - Returns `Boolean`. * `spellCheck` Function.
* `text` String * `words` String[]
* `callback` Function
* `misspeltWords` String[]
Sets a provider for spell checking in input fields and text areas. Sets a provider for spell checking in input fields and text areas.
The `provider` must be an object that has a `spellCheck` method that returns The `provider` must be an object that has a `spellCheck` method that accepts
whether the word passed is correctly spelled. an array of individual words for spellchecking.
The `spellCheck` function runs asynchronously and calls the `callback` function
with an array of misspelt words when complete.
An example of using [node-spellchecker][spellchecker] as provider: An example of using [node-spellchecker][spellchecker] as provider:
```javascript ```javascript
const { webFrame } = require('electron') const { webFrame } = require('electron')
webFrame.setSpellCheckProvider('en-US', true, { const spellChecker = require('spellchecker')
spellCheck (text) { webFrame.setSpellCheckProvider('en-US', {
return !(require('spellchecker').isMisspelled(text)) spellCheck (words, callback) {
setTimeout(() => {
const spellchecker = require('spellchecker')
const misspelled = words.filter(x => spellchecker.isMisspelled(x))
callback(misspelled)
}, 0)
} }
}) })
``` ```

6
package-lock.json generated
View file

@ -2860,9 +2860,9 @@
} }
}, },
"electron-typescript-definitions": { "electron-typescript-definitions": {
"version": "2.1.1", "version": "3.0.0",
"resolved": "https://registry.npmjs.org/electron-typescript-definitions/-/electron-typescript-definitions-2.1.1.tgz", "resolved": "https://registry.npmjs.org/electron-typescript-definitions/-/electron-typescript-definitions-3.0.0.tgz",
"integrity": "sha512-vrEhi3hhPzUEDLwPGOqScYBLefNKH5r9odp3dy/lqE0nhAmUHBkrwnU5jVga3A2pJW22wzCCB1kwkEoPV7Rq4w==", "integrity": "sha512-PQEdLGY9i5IWxQKWCllCun3Lh07YDMeTt/YRbsS+kaCC13vvxoy/LprwkqRUWbzAH704MHtDU9pKrEK2MoqP2w==",
"dev": true, "dev": true,
"requires": { "requires": {
"@types/node": "^7.0.18", "@types/node": "^7.0.18",

View file

@ -14,7 +14,7 @@
"dugite": "^1.45.0", "dugite": "^1.45.0",
"electabul": "~0.0.4", "electabul": "~0.0.4",
"electron-docs-linter": "^2.4.0", "electron-docs-linter": "^2.4.0",
"electron-typescript-definitions": "^2.1.1", "electron-typescript-definitions": "^3.0.0",
"eslint": "^5.6.0", "eslint": "^5.6.0",
"eslint-config-standard": "^12.0.0", "eslint-config-standard": "^12.0.0",
"eslint-plugin-mocha": "^5.2.0", "eslint-plugin-mocha": "^5.2.0",

View file

@ -152,12 +152,22 @@ describe('webFrame module', function () {
w.focus() w.focus()
await w.webContents.executeJavaScript('document.querySelector("input").focus()', true) await w.webContents.executeJavaScript('document.querySelector("input").focus()', true)
const spellCheckerFeedback = emittedOnce(ipcMain, 'spec-spell-check') const spellCheckerFeedback =
const misspelledWord = 'spleling' new Promise((resolve, reject) => {
for (const keyCode of [...misspelledWord, ' ']) { ipcMain.on('spec-spell-check', (e, words, callback) => {
if (words.length === 2) {
// The promise is resolved only after this event is received twice
// Array contains only 1 word first time and 2 the next time
resolve([words, callback])
}
})
})
const inputText = 'spleling test '
for (const keyCode of inputText) {
w.webContents.sendInputEvent({ type: 'char', keyCode }) w.webContents.sendInputEvent({ type: 'char', keyCode })
} }
const [, text] = await spellCheckerFeedback const [words, callback] = await spellCheckerFeedback
expect(text).to.equal(misspelledWord) expect(words).to.deep.equal(['spleling', 'test'])
expect(callback).to.be.true()
}) })
}) })

View file

@ -2,9 +2,10 @@
<body> <body>
<script type="text/javascript" charset="utf-8"> <script type="text/javascript" charset="utf-8">
const {ipcRenderer, webFrame} = require('electron') const {ipcRenderer, webFrame} = require('electron')
webFrame.setSpellCheckProvider('en-US', true, { webFrame.setSpellCheckProvider('en-US', {
spellCheck: text => { spellCheck: (words, callback) => {
ipcRenderer.send('spec-spell-check', text) callback(words)
ipcRenderer.send('spec-spell-check', words, callback != undefined)
} }
}) })
</script> </script>