Cancel unnecessary spellcheck requests.

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"
@@ skipping 205 matching lines @@
   }
 
   return true;
 }
 
 bool SpellCheck::SpellCheckParagraph(
     const string16& text,
     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
   // checks the spellings of the extracted words. This function sets the
   // position and length of the first misspelled word and returns false when
   // the text includes misspelled words. Therefore, we just repeat calling the
   // function until it returns true to check the whole text.
   int misspelling_start = 0;
   int misspelling_length = 0;
   while (offset <= length) {
+    std::vector<string16> suggestions;
     if (SpellCheckWord(&text[offset],
                        length - offset,
                        0,
                        &misspelling_start,
                        &misspelling_length,
-                       NULL)) {
+                       &suggestions)) {
       return true;
     }
 
-    if (results) {
-      results->push_back(SpellCheckResult(
-          SpellCheckResult::SPELLING,
-          misspelling_start + offset,
-          misspelling_length));
-    }
+    string16 replacement;
+    if (!suggestions.empty())
+      replacement = JoinString(suggestions, '\n');
+    results->push_back(SpellCheckResult(
+        SpellCheckResult::SPELLING,
+        misspelling_start + offset,
+        misspelling_length,
+        replacement));
     offset += misspelling_start + misspelling_length;
   }
 
   return false;
 #else
   return true;
 #endif
 }
 
 string16 SpellCheck::GetAutoCorrectionWord(const string16& word, int tag) {
@@ skipping 46 matching lines @@
 }
 
 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_->completion()->didCancelCheckingText();
     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;
@@ skipping 83 matching lines @@
   }
 
   return word_correct;
 }
 
 void SpellCheck::PostDelayedSpellCheckTask() {
   if (!pending_request_param_)
     return;
 
   if (file_ == base::kInvalidPlatformFileValue) {
-    pending_request_param_->completion()->didFinishCheckingText(
-        WebKit::WebVector<WebKit::WebTextCheckingResult>());
+    pending_request_param_->completion()->didCancelCheckingText();
   } 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() {
@@ skipping 61 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;
 }