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_proxy.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 "chrome/common/spellcheck_result.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"
 
 using base::TimeTicks;
 using content::RenderThread;
+using WebKit::WebVector;
+using WebKit::WebTextCheckingResult;
+using WebKit::WebTextCheckingType;
+
+namespace spellcheck {
+void ToWebResultList(
+    int offset,
+    const std::vector<SpellCheckResult>& results,
+    WebVector<WebTextCheckingResult>* web_results) {
+  WebVector<WebTextCheckingResult> list(results.size());
+  for (size_t i = 0; i < results.size(); ++i) {
+    list[i] = WebTextCheckingResult(
+        static_cast<WebTextCheckingType>(results[i].type),
+        results[i].location + offset,
+        results[i].length,
+        results[i].replacement);
+  }
+
+  list.swap(*web_results);
+}
+
+WebVector<WebTextCheckingResult> ToWebResultList(
+    int offset,
+    const std::vector<SpellCheckResult>& results) {
+  WebVector<WebTextCheckingResult> web_results;
+  ToWebResultList(offset, results, &web_results);
+  return web_results;
+}
+} // namespace spellcheck
+
+class SpellCheck::SpellCheckRequestParam
+    : public base::RefCountedThreadSafe<SpellCheck::SpellCheckRequestParam> {
+ public:
+  SpellCheckRequestParam(const string16& text,
+                         int offset,
+                         WebKit::WebTextCheckingCompletion* completion)
+      : text_(text),
+        offset_(offset),
+        completion_(completion) {
+    DCHECK(completion);
+  }
+
+  string16 text() {
+    return text_;
+  }
+
+  int offset() {
+    return offset_;
+  }
+
+  WebKit::WebTextCheckingCompletion* completion() {
+    return completion_;
+  }
+
+ private:
+  // Text to be checked in this task.
+  string16 text_;
+
+  // The text offset from the beginning.
+  int offset_;
+
+  // The interface to send the misspelled ranges to WebKit.
+  WebKit::WebTextCheckingCompletion* completion_;
+
+  DISALLOW_COPY_AND_ASSIGN(SpellCheckRequestParam);
+};
 
 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 78 matching lines @@
     if (optional_suggestions)
       FillSuggestionList(word, optional_suggestions);
     return false;
   }
 
   return true;
 }
 
 bool SpellCheck::SpellCheckParagraph(
     const string16& text,
-    int tag,
     std::vector<SpellCheckResult>* results) {
 #if !defined(OS_MACOSX)
   // Mac has its own spell checker, so this method will not be used.
 
   DCHECK(results);
 
   size_t length = text.length();
   size_t offset = 0;
 
   // Spellcheck::SpellCheckWord() automatically breaks text into words and
@@ skipping 70 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 offset,
+    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_param_.get()) {
+    pending_request_param_->completion()->didFinishCheckingText(
+        WebKit::WebVector<WebKit::WebTextCheckingResult>());
+    pending_request_param_ = 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_param_ = new SpellCheckRequestParam(
+        text, offset, completion);
+    return;
+  }
+
+  requested_params_.push(new SpellCheckRequestParam(text, offset, completion));
+  base::MessageLoopProxy::current()->PostTask(FROM_HERE,
+      base::Bind(&SpellCheck::PerformSpellCheck, AsWeakPtr()));
+#else
+  NOTREACHED();
+#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_param_)
+    return;
+
+  if (file_ == base::kInvalidPlatformFileValue) {
+    pending_request_param_->completion()->didFinishCheckingText(
+        WebKit::WebVector<WebKit::WebTextCheckingResult>());
+  } else {
+    requested_params_.push(pending_request_param_);
+    base::MessageLoopProxy::current()->PostTask(FROM_HERE,
+        base::Bind(&SpellCheck::PerformSpellCheck, AsWeakPtr()));
+  }
+
+  pending_request_param_ = NULL;
+}
+
+void SpellCheck::PerformSpellCheck() {
+#if !defined(OS_MACOSX)
+  DCHECK(!requested_params_.empty());
+  scoped_refptr<SpellCheckRequestParam> param = requested_params_.front();
+  DCHECK(param);
+  requested_params_.pop();
+
+  std::vector<SpellCheckResult> results;
+  SpellCheckParagraph(param->text(), &results);
+  param->completion()->didFinishCheckingText(
+      spellcheck::ToWebResultList(param->offset(), 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.
+  NOTREACHED();
+#endif
+}
+
 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;
 }