Merge pull request #942 from atom/spell-check-client

Add support for spell checking

atom/renderer/api/atom_api_spell_check_client.cc

@@ -0,0 +1,247 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/renderer/api/atom_api_spell_check_client.h"
+
+#include <algorithm>
+#include <vector>
+
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "base/logging.h"
+#include "native_mate/converter.h"
+#include "native_mate/dictionary.h"
+#include "third_party/icu/source/common/unicode/uscript.h"
+#include "third_party/WebKit/public/web/WebTextCheckingCompletion.h"
+#include "third_party/WebKit/public/web/WebTextCheckingResult.h"
+
+namespace atom {
+
+namespace api {
+
+namespace {
+
+const int kMaxAutoCorrectWordSize = 8;
+
+bool HasWordCharacters(const base::string16& text, int index) {
+  const base::char16* data = text.data();
+  int length = text.length();
+  while (index < length) {
+    uint32 code = 0;
+    U16_NEXT(data, index, length, code);
+    UErrorCode error = U_ZERO_ERROR;
+    if (uscript_getScript(code, &error) != USCRIPT_COMMON)
+      return true;
+  }
+  return false;
+}
+
+}  // namespace
+
+SpellCheckClient::SpellCheckClient(const std::string& language,
+                                   bool auto_spell_correct_turned_on,
+                                   v8::Isolate* isolate,
+                                   v8::Handle<v8::Object> provider)
+    : auto_spell_correct_turned_on_(auto_spell_correct_turned_on),
+      isolate_(isolate),
+      provider_(isolate, provider) {
+  character_attributes_.SetDefaultLanguage(language);
+
+  // Persistent the method.
+  mate::Dictionary dict(isolate, provider);
+  dict.Get("spellCheck", &spell_check_);
+}
+
+SpellCheckClient::~SpellCheckClient() {}
+
+void SpellCheckClient::spellCheck(
+    const blink::WebString& text,
+    int& misspelling_start,
+    int& misspelling_len,
+    blink::WebVector<blink::WebString>* optional_suggestions) {
+  std::vector<blink::WebTextCheckingResult> results;
+  SpellCheckText(base::string16(text), true, &results);
+  if (results.size() == 1) {
+    misspelling_start = results[0].location;
+    misspelling_len = results[0].length;
+  }
+}
+
+void SpellCheckClient::checkTextOfParagraph(
+    const blink::WebString& text,
+    blink::WebTextCheckingTypeMask mask,
+    blink::WebVector<blink::WebTextCheckingResult>* results) {
+  if (!results)
+    return;
+
+  if (!(mask & blink::WebTextCheckingTypeSpelling))
+    return;
+
+  NOTREACHED() << "checkTextOfParagraph should never be called";
+}
+
+void SpellCheckClient::requestCheckingOfText(
+    const blink::WebString& textToCheck,
+    const blink::WebVector<uint32_t>& markersInText,
+    const blink::WebVector<unsigned>& markerOffsets,
+    blink::WebTextCheckingCompletion* completionCallback) {
+  base::string16 text(textToCheck);
+  if (text.empty() || !HasWordCharacters(text, 0)) {
+    completionCallback->didCancelCheckingText();
+    return;
+  }
+
+  std::vector<blink::WebTextCheckingResult> results;
+  SpellCheckText(text, false, &results);
+  completionCallback->didFinishCheckingText(results);
+}
+
+blink::WebString SpellCheckClient::autoCorrectWord(
+    const blink::WebString& misspelledWord) {
+  if (auto_spell_correct_turned_on_)
+    return GetAutoCorrectionWord(base::string16(misspelledWord));
+  else
+    return blink::WebString();
+}
+
+void SpellCheckClient::showSpellingUI(bool show) {
+}
+
+bool SpellCheckClient::isShowingSpellingUI() {
+  return false;
+}
+
+void SpellCheckClient::updateSpellingUIWithMisspelledWord(
+    const blink::WebString& word) {
+}
+
+void SpellCheckClient::SpellCheckText(
+    const base::string16& text,
+    bool stop_at_first_result,
+    std::vector<blink::WebTextCheckingResult>* results) {
+  if (text.length() == 0 || spell_check_.IsEmpty())
+    return;
+
+  base::string16 word;
+  int word_start;
+  int word_length;
+  if (!text_iterator_.IsInitialized() &&
+      !text_iterator_.Initialize(&character_attributes_, true)) {
+      // We failed to initialize text_iterator_, return as spelled correctly.
+      VLOG(1) << "Failed to initialize SpellcheckWordIterator";
+      return;
+  }
+
+  base::string16 in_word(text);
+  text_iterator_.SetText(in_word.c_str(), in_word.size());
+  while (text_iterator_.GetNextWord(&word, &word_start, &word_length)) {
+    // Found a word (or a contraction) that the spellchecker can check the
+    // spelling of.
+    if (SpellCheckWord(word))
+      continue;
+
+    // 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.
+    if (IsValidContraction(word))
+      continue;
+
+    blink::WebTextCheckingResult result;
+    result.location = word_start;
+    result.length = word_length;
+    results->push_back(result);
+
+    if (stop_at_first_result)
+      return;
+  }
+}
+
+bool SpellCheckClient::SpellCheckWord(const base::string16& word_to_check) {
+  if (spell_check_.IsEmpty())
+    return true;
+
+  v8::HandleScope handle_scope(isolate_);
+  v8::Handle<v8::Value> word = mate::ConvertToV8(isolate_, word_to_check);
+  v8::Handle<v8::Value> result = spell_check_.NewHandle()->Call(
+      provider_.NewHandle(), 1, &word);
+
+  if (result->IsBoolean())
+    return result->BooleanValue();
+  else
+    return true;
+}
+
+base::string16 SpellCheckClient::GetAutoCorrectionWord(
+    const base::string16& word) {
+  base::string16 autocorrect_word;
+
+  int word_length = static_cast<int>(word.size());
+  if (word_length < 2 || word_length > kMaxAutoCorrectWordSize)
+    return autocorrect_word;
+
+  base::char16 misspelled_word[kMaxAutoCorrectWordSize + 1];
+  const base::char16* word_char = word.c_str();
+  for (int i = 0; i <= kMaxAutoCorrectWordSize; ++i) {
+    if (i >= word_length)
+      misspelled_word[i] = 0;
+    else
+      misspelled_word[i] = word_char[i];
+  }
+
+  // Swap adjacent characters and spellcheck.
+  int misspelling_start, misspelling_len;
+  for (int i = 0; i < word_length - 1; i++) {
+    // Swap.
+    std::swap(misspelled_word[i], misspelled_word[i + 1]);
+
+    // Check spelling.
+    misspelling_start = misspelling_len = 0;
+    spellCheck(blink::WebString(misspelled_word, word_length),
+               misspelling_start,
+               misspelling_len,
+               NULL);
+
+    // Make decision: if only one swap produced a valid word, then we want to
+    // return it. If we found two or more, we don't do autocorrection.
+    if (misspelling_len == 0) {
+      if (autocorrect_word.empty()) {
+        autocorrect_word.assign(misspelled_word);
+      } else {
+        autocorrect_word.clear();
+        break;
+      }
+    }
+
+    // Restore the swapped characters.
+    std::swap(misspelled_word[i], misspelled_word[i + 1]);
+  }
+  return autocorrect_word;
+}
+
+// Returns whether or not the given string is a valid contraction.
+// This function is a fall-back when the SpellcheckWordIterator class
+// returns a concatenated word which is not in the selected dictionary
+// (e.g. "in'n'out") but each word is valid.
+bool SpellCheckClient::IsValidContraction(const base::string16& contraction) {
+  if (!contraction_iterator_.IsInitialized() &&
+      !contraction_iterator_.Initialize(&character_attributes_, false)) {
+    // We failed to initialize the word iterator, return as spelled correctly.
+    VLOG(1) << "Failed to initialize contraction_iterator_";
+    return true;
+  }
+
+  contraction_iterator_.SetText(contraction.c_str(), contraction.length());
+
+  base::string16 word;
+  int word_start;
+  int word_length;
+
+  while (contraction_iterator_.GetNextWord(&word, &word_start, &word_length)) {
+    if (!SpellCheckWord(word))
+      return false;
+  }
+  return true;
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/renderer/api/atom_api_spell_check_client.h

@@ -0,0 +1,93 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_RENDERER_API_ATOM_API_SPELL_CHECK_CLIENT_H_
+#define ATOM_RENDERER_API_ATOM_API_SPELL_CHECK_CLIENT_H_
+
+#include <string>
+#include <vector>
+
+#include "base/callback.h"
+#include "chrome/renderer/spellchecker/spellcheck_worditerator.h"
+#include "native_mate/scoped_persistent.h"
+#include "third_party/WebKit/public/web/WebSpellCheckClient.h"
+
+namespace atom {
+
+namespace api {
+
+class SpellCheckClient : public blink::WebSpellCheckClient {
+ public:
+  SpellCheckClient(const std::string& language,
+                   bool auto_spell_correct_turned_on,
+                   v8::Isolate* isolate,
+                   v8::Handle<v8::Object> provider);
+  virtual ~SpellCheckClient();
+
+ private:
+  // blink::WebSpellCheckClient:
+  void spellCheck(
+      const blink::WebString& text,
+      int& misspelledOffset,
+      int& misspelledLength,
+      blink::WebVector<blink::WebString>* optionalSuggestions) override;
+  void checkTextOfParagraph(
+      const blink::WebString&,
+      blink::WebTextCheckingTypeMask mask,
+      blink::WebVector<blink::WebTextCheckingResult>* results) override;
+  void requestCheckingOfText(
+      const blink::WebString& textToCheck,
+      const blink::WebVector<uint32_t>& markersInText,
+      const blink::WebVector<unsigned>& markerOffsets,
+      blink::WebTextCheckingCompletion* completionCallback) override;
+  blink::WebString autoCorrectWord(
+      const blink::WebString& misspelledWord) override;
+  void showSpellingUI(bool show) override;
+  bool isShowingSpellingUI() override;
+  void updateSpellingUIWithMisspelledWord(
+      const blink::WebString& word) override;
+
+  // Check the spelling of text.
+  void SpellCheckText(const base::string16& text,
+                      bool stop_at_first_result,
+                      std::vector<blink::WebTextCheckingResult>* results);
+
+  // Call JavaScript to check spelling a word.
+  bool SpellCheckWord(const base::string16& word_to_check);
+
+  // Find a possible correctly spelled word for a misspelled word. Computes an
+  // empty string if input misspelled word is too long, there is ambiguity, or
+  // the correct spelling cannot be determined.
+  base::string16 GetAutoCorrectionWord(const base::string16& word);
+
+  // Returns whether or not the given word is a contraction of valid words
+  // (e.g. "word:word").
+  bool IsValidContraction(const base::string16& word);
+
+  // Represents character attributes used for filtering out characters which
+  // are not supported by this SpellCheck object.
+  SpellcheckCharAttribute character_attributes_;
+
+  // Represents word iterators used in this spellchecker. The |text_iterator_|
+  // splits text provided by WebKit into words, contractions, or concatenated
+  // words. The |contraction_iterator_| splits a concatenated word extracted by
+  // |text_iterator_| into word components so we can treat a concatenated word
+  // consisting only of correct words as a correct word.
+  SpellcheckWordIterator text_iterator_;
+  SpellcheckWordIterator contraction_iterator_;
+
+  bool auto_spell_correct_turned_on_;
+
+  v8::Isolate* isolate_;
+  mate::ScopedPersistent<v8::Object> provider_;
+  mate::ScopedPersistent<v8::Function> spell_check_;
+
+  DISALLOW_COPY_AND_ASSIGN(SpellCheckClient);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_RENDERER_API_ATOM_API_SPELL_CHECK_CLIENT_H_

atom/renderer/api/atom_api_web_frame.cc

@@ -5,6 +5,7 @@
 #include "atom/renderer/api/atom_api_web_frame.h"
 
 #include "atom/common/native_mate_converters/string16_converter.h"
+#include "atom/renderer/api/atom_api_spell_check_client.h"
 #include "content/public/renderer/render_frame.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
@@ -56,6 +57,20 @@ void WebFrame::AttachGuest(int id) {
   content::RenderFrame::FromWebFrame(web_frame_)->AttachGuest(id);
 }
 
+void WebFrame::SetSpellCheckProvider(mate::Arguments* args,
+                                     const std::string& language,
+                                     bool auto_spell_correct_turned_on,
+                                     v8::Handle<v8::Object> provider) {
+  if (!provider->Has(mate::StringToV8(args->isolate(), "spellCheck"))) {
+    args->ThrowError("\"spellCheck\" has to be defined");
+    return;
+  }
+
+  spell_check_client_.reset(new SpellCheckClient(
+      language, auto_spell_correct_turned_on, args->isolate(), provider));
+  web_frame_->view()->setSpellCheckClient(spell_check_client_.get());
+}
+
 mate::ObjectTemplateBuilder WebFrame::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   return mate::ObjectTemplateBuilder(isolate)
@@ -66,7 +81,8 @@ mate::ObjectTemplateBuilder WebFrame::GetObjectTemplateBuilder(
       .SetMethod("getZoomFactor", &WebFrame::GetZoomFactor)
       .SetMethod("registerEmbedderCustomElement",
                  &WebFrame::RegisterEmbedderCustomElement)
-      .SetMethod("attachGuest", &WebFrame::AttachGuest);
+      .SetMethod("attachGuest", &WebFrame::AttachGuest)
+      .SetMethod("setSpellCheckProvider", &WebFrame::SetSpellCheckProvider);
 }
 
 // static

atom/renderer/api/atom_api_web_frame.h

@@ -7,6 +7,7 @@
 
 #include <string>
 
+#include "base/memory/scoped_ptr.h"
 #include "native_mate/handle.h"
 #include "native_mate/wrappable.h"
 
@@ -14,10 +15,16 @@ namespace blink {
 class WebLocalFrame;
 }
 
+namespace mate {
+class Arguments;
+}
+
 namespace atom {
 
 namespace api {
 
+class SpellCheckClient;
+
 class WebFrame : public mate::Wrappable {
  public:
   static mate::Handle<WebFrame> Create(v8::Isolate* isolate);
@@ -37,10 +44,18 @@ class WebFrame : public mate::Wrappable {
       const base::string16& name, v8::Handle<v8::Object> options);
   void AttachGuest(int element_instance_id);
 
+  // Set the provider that will be used by SpellCheckClient for spell check.
+  void SetSpellCheckProvider(mate::Arguments* args,
+                             const std::string& language,
+                             bool auto_spell_correct_turned_on,
+                             v8::Handle<v8::Object> provider);
+
   // mate::Wrappable:
   virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
       v8::Isolate* isolate);
 
+  scoped_ptr<SpellCheckClient> spell_check_client_;
+
   blink::WebLocalFrame* web_frame_;
 
   DISALLOW_COPY_AND_ASSIGN(WebFrame);