Asynchronous spellchecking on Win and Linux

chrome/renderer/spellchecker/spellcheck.cc

 // 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 "chrome/renderer/spellchecker/spellcheck.h"
 
+#include "base/bind.h"
 #include "base/file_util.h"
 #include "base/metrics/histogram.h"
+#include "base/message_loop.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/spellcheck_common.h"
 #include "chrome/common/spellcheck_messages.h"
 #include "content/public/renderer/render_thread.h"
 #include "third_party/hunspell/src/hunspell/hunspell.hxx"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebTextCheckingCompletion.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebTextCheckingResult.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebVector.h"
 
 using base::TimeTicks;
 using content::RenderThread;
 
+// A request that checks the spellings of the specified text.
+class SpellCheck::SpellCheckRequest
+    : public base::RefCountedThreadSafe<SpellCheck::SpellCheckRequest> {

[Hironori Bono, 2012/01/27 06:17:41]

I do not think we need a new class for this use-case now. (We can now use
base::Bind() to call a member method safely and it makes this change much
simpler.)

[shinyak, 2012/01/30 06:53:05]

Actually |text| is a temporary object, so the reference may be deleted after
escaping SpellCheck::RequestTextChecking. So I want to have some references to
it. I made a queue in SpellCheck class to achieve it.

+ public:
+  SpellCheckRequest(const string16& text,
+                    int tag,
+                    WebKit::WebTextCheckingCompletion* completion,
+                    SpellCheck* spellcheck)
+      : text_(text),
+        tag_(tag),
+        completion_(completion),
+        spellcheck_(spellcheck) {
+    DCHECK(completion);
+    DCHECK(spellcheck);
+  }
+
+  // Performs spellchecking and calls the callback function.
+  void PerformSpellCheck() {
+#if !defined(OS_MACOSX)
+    std::vector<WebKit::WebTextCheckingResult> results;
+    spellcheck_->SpellCheckParagraph(text_, tag_, &results);

[Hironori Bono, 2012/01/27 06:17:41]

This call surely creates confusing crashes when a renderer calls function after
this SpellCheck object has been deleted. We need to use WeakPtr to access an
object from a task. (As written above, I do not recommend to use a task,
though.)

[shinyak, 2012/01/30 06:53:05]

Done.

+    completion_->didFinishCheckingText(results);
+#else
+    // SpellCheck::SpellCheckParagraph is not implemented on Mac,
+    // so we return without spellchecking. Note that Mac uses its own
+    // spellchecker, this function won't be used.

[Hironori Bono, 2012/01/27 06:17:41]

Use NOTREACHED() and let a renderer crash when someone call this function by
mistake.

[shinyak, 2012/01/30 06:53:05]

Done.

+    completion_->didFinishCheckingText(
+        WebKit::WebVector<WebKit::WebTextCheckingResult>());
+#endif
+  }
+
+  // Calls the callback function without doing spellchecking.
+  // Text is considered as having no misspellings.
+  void CancelSpellCheckRequest() {
+    completion_->didFinishCheckingText(
+        WebKit::WebVector<WebKit::WebTextCheckingResult>());
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<SpellCheckRequest>;
+
+  ~SpellCheckRequest() {
+  }
+
+  // Text to be checked in this task.
+  string16 text_;
+
+  // The document tag provided by WebKit.
+  int tag_;
+
+  // The interface to send the misspelled ranges to WebKit.
+  WebKit::WebTextCheckingCompletion* completion_;
+
+  // The spellchecker shared in this process.
+  SpellCheck* spellcheck_;
+};
+
 SpellCheck::SpellCheck()
     : file_(base::kInvalidPlatformFileValue),
       auto_spell_correct_turned_on_(false),
       is_using_platform_spelling_engine_(false),
-      initialized_(false) {
+      initialized_(false),
+      dictionary_requested_(false) {
   // Wait till we check the first word before doing any initializing.
 }
 
 SpellCheck::~SpellCheck() {
 }
 
 bool SpellCheck::OnControlMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(SpellCheck, message)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_Init, OnInit)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_WordAdded, OnWordAdded)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_EnableAutoSpellCorrect,
                         OnEnableAutoSpellCorrect)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 void SpellCheck::OnInit(IPC::PlatformFileForTransit bdict_file,
                         const std::vector<std::string>& custom_words,
                         const std::string& language,
                         bool auto_spell_correct) {
   Init(IPC::PlatformFileForTransitToPlatformFile(bdict_file),
        custom_words, language);
   auto_spell_correct_turned_on_ = auto_spell_correct;
+
+  PostDelayedSpellCheckTask();
 }
 
 void SpellCheck::OnWordAdded(const std::string& word) {
   if (is_using_platform_spelling_engine_)
     return;
 
   if (!hunspell_.get()) {
     // Save it for later---add it when hunspell is initialized.
     custom_words_.push_back(word);
   } else {
@@ skipping 169 matching lines @@
         break;
       }
     }
 
     // Restore the swapped characters.
     std::swap(misspelled_word[i], misspelled_word[i + 1]);
   }
   return autocorrect_word;
 }
 
+void SpellCheck::RequestTextChecking(
+    const string16& text,
+    int tag,
+    WebKit::WebTextCheckingCompletion* completion) {
+#if !defined(OS_MACOSX)
+  // Commented out on Mac, because SpellCheckRequest::PerformSpellCheck is not
+  // implemented on Mac. Mac uses its own spellchecker, so this method
+  // will not be used.
+
+  DCHECK(!is_using_platform_spelling_engine_);
+
+  // Clean up the previous request before starting a new request.
+  if (pending_request_) {
+    pending_request_->CancelSpellCheckRequest();
+    pending_request_ = NULL;
+  }
+
+  if (InitializeIfNeeded()) {
+    // We will check this text after we finish loading the hunspell dictionary.
+    // Save parameters so that we can use them when we receive an init message
+    // from the browser process.
+    pending_request_ = new SpellCheckRequest(text, tag, completion, this);
+    return;
+  }
+
+  scoped_refptr<SpellCheckRequest> request(
+      new SpellCheckRequest(text, tag, completion, this));
+  MessageLoop::current()->PostTask(FROM_HERE,
+      base::Bind(&SpellCheckRequest::PerformSpellCheck, request));
+#endif
+}
+
 void SpellCheck::InitializeHunspell() {
   if (hunspell_.get())
     return;
 
   bdict_file_.reset(new file_util::MemoryMappedFile);
 
   if (bdict_file_->Initialize(file_)) {
     TimeTicks debug_start_time = base::Histogram::DebugNow();
 
     hunspell_.reset(
@@ skipping 14 matching lines @@
 
 void SpellCheck::AddWordToHunspell(const std::string& word) {
   if (!word.empty() && word.length() < MAXWORDUTF8LEN)
     hunspell_->add(word.c_str());
 }
 
 bool SpellCheck::InitializeIfNeeded() {
   if (is_using_platform_spelling_engine_)
     return false;
 
-  if (!initialized_) {
-    RenderThread::Get()->Send(new SpellCheckHostMsg_RequestDictionary);
-    initialized_ = true;
+  if (!initialized_ && !dictionary_requested_) {
+    // RenderThread will not exist in test.
+    if (RenderThread::Get())
+      RenderThread::Get()->Send(new SpellCheckHostMsg_RequestDictionary);
+    dictionary_requested_ = true;
     return true;
   }
 
   // Don't initialize if hunspell is disabled.
   if (file_ != base::kInvalidPlatformFileValue)
     InitializeHunspell();
 
-  return false;
+  return !initialized_;
 }
 
 // When called, relays the request to check the spelling to the proper
 // backend, either hunspell or a platform-specific backend.
 bool SpellCheck::CheckSpelling(const string16& word_to_check, int tag) {
   bool word_correct = false;
 
   if (is_using_platform_spelling_engine_) {
 #if defined(OS_MACOSX)
     RenderThread::Get()->Send(new SpellCheckHostMsg_CheckSpelling(
@@ skipping 11 matching lines @@
         // If |hunspell_| is NULL here, an error has occurred, but it's better
         // to check rather than crash.
         word_correct = true;
       }
     }
   }
 
   return word_correct;
 }
 
+void SpellCheck::PostDelayedSpellCheckTask() {
+  if (!pending_request_)
+    return;
+
+  if (file_ == base::kInvalidPlatformFileValue) {
+    pending_request_->CancelSpellCheckRequest();
+  } else {
+    MessageLoop::current()->PostTask(FROM_HERE,

[Hironori Bono, 2012/01/27 06:17:41]

This is an old way to post a task. (This code crashes when
MessageLoop::current() does not exist.) We can now use MessageLoopProxy instead
of using MessageLoop directly.

[shinyak, 2012/01/30 06:53:05]

Done.

+        base::Bind(&SpellCheckRequest::PerformSpellCheck, pending_request_));
+  }
+
+  pending_request_ = NULL;
+}
+
 void SpellCheck::FillSuggestionList(
     const string16& wrong_word,
     std::vector<string16>* optional_suggestions) {
   if (is_using_platform_spelling_engine_) {
 #if defined(OS_MACOSX)
     RenderThread::Get()->Send(new SpellCheckHostMsg_FillSuggestionList(
         wrong_word, optional_suggestions));
 #endif
     return;
   }
@@ skipping 33 matching lines @@
 
   string16 word;
   int word_start;
   int word_length;
   while (contraction_iterator_.GetNextWord(&word, &word_start, &word_length)) {
     if (!CheckSpelling(word, tag))
       return false;
   }
   return true;
 }