Asynchronous spellchecking on Win and Linux

chrome/renderer/spellchecker/spellcheck_provider.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_provider.h"
 
 #include "base/command_line.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/spellcheck_messages.h"
 #include "chrome/common/spellcheck_result.h"
 #include "chrome/renderer/chrome_content_renderer_client.h"
 #include "chrome/renderer/spellchecker/spellcheck.h"
 #include "content/public/renderer/render_view.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #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/WebTextCheckingType.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebVector.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 
+using spellcheck::ToWebResultList;
 using WebKit::WebFrame;
 using WebKit::WebString;
 using WebKit::WebTextCheckingCompletion;
 using WebKit::WebTextCheckingResult;
 using WebKit::WebTextCheckingType;
 using WebKit::WebVector;
 
 COMPILE_ASSERT(int(WebKit::WebTextCheckingTypeSpelling) ==
                int(SpellCheckResult::SPELLING), mismatching_enums);
 COMPILE_ASSERT(int(WebKit::WebTextCheckingTypeGrammar) ==
                int(SpellCheckResult::GRAMMAR), mismatching_enums);
 COMPILE_ASSERT(int(WebKit::WebTextCheckingTypeLink) ==
                int(SpellCheckResult::LINK), mismatching_enums);
 COMPILE_ASSERT(int(WebKit::WebTextCheckingTypeQuote) ==
                int(SpellCheckResult::QUOTE), mismatching_enums);
 COMPILE_ASSERT(int(WebKit::WebTextCheckingTypeDash) ==
                int(SpellCheckResult::DASH), mismatching_enums);
 COMPILE_ASSERT(int(WebKit::WebTextCheckingTypeReplacement) ==
                int(SpellCheckResult::REPLACEMENT), mismatching_enums);
 COMPILE_ASSERT(int(WebKit::WebTextCheckingTypeCorrection) ==
                int(SpellCheckResult::CORRECTION), mismatching_enums);
 COMPILE_ASSERT(int(WebKit::WebTextCheckingTypeShowCorrectionPanel) ==
                int(SpellCheckResult::SHOWCORRECTIONPANEL), mismatching_enums);
 
-namespace {
-
-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
-
 SpellCheckProvider::SpellCheckProvider(
     content::RenderView* render_view,
     chrome::ChromeContentRendererClient* renderer_client)
     : content::RenderViewObserver(render_view),
 #if defined(OS_MACOSX)
       has_document_tag_(false),
 #endif
       document_tag_(0),
       spelling_panel_visible_(false),
       chrome_content_renderer_client_(renderer_client) {
@@ skipping 28 matching lines @@
 #else
   // Send this text to a browser. A browser checks the user profile and send
   // this text to the Spelling service only if a user enables this feature.
   // TODO(hbono) Implement a cache to avoid sending IPC messages.
   string16 line;
   int offset = -1;
   if (!GetRequestLine(text, &line, &offset)) {
     completion->didFinishCheckingText(std::vector<WebTextCheckingResult>());
     return;
   }
+
   last_line_ = line;
   Send(new SpellCheckHostMsg_CallSpellingService(
       routing_id(),
       text_check_completions_.Add(completion),
       offset,
       line));
 #endif  // !OS_MACOSX
 }
 
 bool SpellCheckProvider::OnMessageReceived(const IPC::Message& message) {
@@ skipping 72 matching lines @@
 
   EnsureDocumentTag();
 
   // Will be NULL during unit tets.
   if (!chrome_content_renderer_client_)
     return;
 
   std::vector<SpellCheckResult> tmp_results;
   chrome_content_renderer_client_->spellcheck()->SpellCheckParagraph(
       string16(text),
-      document_tag_,
       &tmp_results);
   ToWebResultList(0, tmp_results, results);
 #endif
 }
 
 void SpellCheckProvider::requestCheckingOfText(
     const WebString& text,
     WebTextCheckingCompletion* completion) {
   RequestTextChecking(text, document_tag_, completion);
 }
@@ skipping 26 matching lines @@
 #if defined(OS_MACOSX)
   Send(new SpellCheckHostMsg_UpdateSpellingPanelWithMisspelledWord(routing_id(),
                                                                    word));
 #endif
 }
 
 #if !defined(OS_MACOSX)
 void SpellCheckProvider::OnRespondSpellingService(
     int identifier,
     int offset,
+    bool succeeded,
+    const string16& text,
     const std::vector<SpellCheckResult>& results) {
   WebTextCheckingCompletion* completion =
       text_check_completions_.Lookup(identifier);
   if (!completion)
     return;
   text_check_completions_.Remove(identifier);
+
+  // If |succeeded| is false, we use local spellcheck as a fallback.
+  if (!succeeded) {
+    // |chrome_content_renderer_client| may be NULL in unit tests.
+    if (chrome_content_renderer_client_) {
+      chrome_content_renderer_client_->spellcheck()->RequestTextChecking(
+          text, offset, completion);
+      return;
+    }
+  }
+
   completion->didFinishCheckingText(ToWebResultList(offset, results));
 }
 
 bool SpellCheckProvider::HasWordCharacters(const string16& text,
                                            int index) const {
   const char16* data = text.c_str();
   int length = text.length();
   while (index < length) {
     uint32 code = 0;
     U16_NEXT(data, index, length, code);
@@ skipping 87 matching lines @@
   // TODO(darin): There's actually no reason for this to be here.  We should
   // have the browser side manage the document tag.
 #if defined(OS_MACOSX)
   if (!has_document_tag_) {
     // Make the call to get the tag.
     Send(new SpellCheckHostMsg_GetDocumentTag(routing_id(), &document_tag_));
     has_document_tag_ = true;
   }
 #endif
 }