Split the words before sending it to spellCheck

atom/renderer/api/atom_api_spell_check_client.cc

@@ -54,22 +54,53 @@ bool HasWordCharacters(const base::string16& text, int index) {
 }  // namespace
 
 SpellCheckClient::SpellCheckClient(v8::Isolate* isolate,
+                                   const std::string& language,
                                    v8::Handle<v8::Object> provider)
-    : isolate_(isolate), provider_(isolate, provider) {}
+    : 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& misspelledOffset,
-    int& misspelledLength,
-    blink::WebVector<blink::WebString>* optionalSuggestions) {
-  blink::WebTextCheckingResult result;
-  if (!CallProviderMethod("spellCheck", text, &result))
+    int& misspelling_start,
+    int& misspelling_len,
+    blink::WebVector<blink::WebString>* optional_suggestions) {
+  if (text.length() == 0 || spell_check_.IsEmpty())
     return;
 
-  misspelledOffset = result.location;
-  misspelledLength = result.length;
+  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 (CheckSpelling(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;
+
+    misspelling_start = word_start;
+    misspelling_len = word_length;
+    return;
+  }
 }
 
 void SpellCheckClient::checkTextOfParagraph(
@@ -90,13 +121,6 @@ void SpellCheckClient::requestCheckingOfText(
     const blink::WebVector<uint32_t>& markersInText,
     const blink::WebVector<unsigned>& markerOffsets,
     blink::WebTextCheckingCompletion* completionCallback) {
-  v8::HandleScope handle_scope(isolate_);
-  v8::Handle<v8::Object> provider = provider_.NewHandle();
-  if (!provider->Has(mate::StringToV8(isolate_, "requestCheckingOfText"))) {
-    completionCallback->didCancelCheckingText();
-    return;
-  }
-
   base::string16 text(textToCheck);
   if (text.empty() || !HasWordCharacters(text, 0)) {
     completionCallback->didCancelCheckingText();
@@ -151,6 +175,46 @@ bool SpellCheckClient::CallProviderMethod(const char* method,
   return mate::ConvertFromV8(isolate_, v8_result, result);;
 }
 
+bool SpellCheckClient::CheckSpelling(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;
+}
+
+// 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 (!CheckSpelling(word))
+      return false;
+  }
+  return true;
+}
+
 }  // namespace api
 
 }  // namespace atom

atom/renderer/api/atom_api_spell_check_client.h

@@ -5,6 +5,10 @@
 #ifndef ATOM_RENDERER_API_ATOM_API_SPELL_CHECK_CLIENT_H_
 #define ATOM_RENDERER_API_ATOM_API_SPELL_CHECK_CLIENT_H_
 
+#include <string>
+
+#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"
 
@@ -14,7 +18,9 @@ namespace api {
 
 class SpellCheckClient : public blink::WebSpellCheckClient {
  public:
-  SpellCheckClient(v8::Isolate* isolate, v8::Handle<v8::Object> provider);
+  SpellCheckClient(v8::Isolate* isolate,
+                   const std::string& language,
+                   v8::Handle<v8::Object> provider);
   virtual ~SpellCheckClient();
 
  private:
@@ -44,8 +50,28 @@ class SpellCheckClient : public blink::WebSpellCheckClient {
   bool CallProviderMethod(const char* method, const blink::WebString& text,
                           T* result);
 
+  // Call JavaScript to check spelling.
+  bool CheckSpelling(const base::string16& word_to_check);
+
+  // 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_;
+
   v8::Isolate* isolate_;
   mate::ScopedPersistent<v8::Object> provider_;
+  mate::ScopedPersistent<v8::Function> spell_check_;
 
   DISALLOW_COPY_AND_ASSIGN(SpellCheckClient);
 };

atom/renderer/api/atom_api_web_frame.cc

@@ -57,9 +57,16 @@ void WebFrame::AttachGuest(int id) {
   content::RenderFrame::FromWebFrame(web_frame_)->AttachGuest(id);
 }
 
-void WebFrame::SetSpellCheckProvider(v8::Isolate* isolate,
+void WebFrame::SetSpellCheckProvider(mate::Arguments* args,
+                                     const std::string& language,
                                      v8::Handle<v8::Object> provider) {
-  spell_check_client_.reset(new SpellCheckClient(isolate, provider));
+  v8::Isolate* isolate = args->isolate();
+  if (!provider->Has(mate::StringToV8(isolate, "spellCheck"))) {
+    args->ThrowError("\"spellCheck\" has to be defined");
+    return;
+  }
+
+  spell_check_client_.reset(new SpellCheckClient(isolate, language, provider));
   web_frame_->view()->setSpellCheckClient(spell_check_client_.get());
 }
 

atom/renderer/api/atom_api_web_frame.h

@@ -15,6 +15,10 @@ namespace blink {
 class WebLocalFrame;
 }
 
+namespace mate {
+class Arguments;
+}
+
 namespace atom {
 
 namespace api {
@@ -41,7 +45,8 @@ class WebFrame : public mate::Wrappable {
   void AttachGuest(int element_instance_id);
 
   // Set the provider that will be used by SpellCheckClient for spell check.
-  void SetSpellCheckProvider(v8::Isolate* isolate,
+  void SetSpellCheckProvider(mate::Arguments* args,
+                             const std::string& language,
                              v8::Handle<v8::Object> provider);
 
   // mate::Wrappable: