Adds a bubble that asks a user whether to integrate the Spelling service.

chrome/browser/tab_contents/spelling_menu_observer.cc

 // Copyright (c) 2011 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/browser/tab_contents/spelling_menu_observer.h"
 
 #include <string>
 
 #include "base/json/json_reader.h"
 #include "base/json/string_escape.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/spellchecker/spellcheck_host.h"
+#include "chrome/browser/spellchecker/spellcheck_host_metrics.h"
 #include "chrome/browser/tab_contents/render_view_context_menu.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/public/common/url_fetcher.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "unicode/uloc.h"
 #include "webkit/glue/context_menu.h"
 
@@ skipping 21 matching lines @@
 
   // Exit if we are not in an editable element because we add a menu item only
   // for editable elements.
   if (!params.is_editable)
     return;
 
   Profile* profile = proxy_->GetProfile();
   if (!profile || !profile->GetRequestContext())
     return;
 
-  // Retrieve the misspelled word to be sent to the Spelling service.
-  string16 text = params.misspelled_word;
-  if (text.empty())
-    return;
+  PrefService* pref = profile->GetPrefs();
+  if (pref->GetBoolean(prefs::kEnableSpellCheck) &&
+      pref->GetBoolean(prefs::kSpellCheckUseSpellingService)) {
+    // Retrieve the misspelled word to be sent to the Spelling service.
+    string16 text = params.misspelled_word;
+    if (text.empty())
+      return;
 
-  // Initialize variables used in OnURLFetchComplete(). We copy the input text
-  // to the result text so we can replace its misspelled regions with
-  // suggestions.
-  loading_frame_ = 0;
-  succeeded_ = false;
-  result_ = text;
+    // Initialize variables used in OnURLFetchComplete(). We copy the input text
+    // to the result text so we can replace its misspelled regions with
+    // suggestions.
+    loading_frame_ = 0;
+    succeeded_ = false;
+    result_ = text;
 
-  // Add a placeholder item. This item will be updated when we receive a
-  // response from the Spelling service. (We do not have to disable this item
-  // now since Chrome will call IsCommandIdEnabled() and disable it.)
-  loading_message_ =
-      l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_SPELLING_CHECKING);
-  proxy_->AddMenuItem(IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION,
-                      loading_message_);
+    // Add a placeholder item. This item will be updated when we receive a
+    // response from the Spelling service. (We do not have to disable this item
+    // now since Chrome will call IsCommandIdEnabled() and disable it.)
+    loading_message_ =
+        l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_SPELLING_CHECKING);
+    proxy_->AddMenuItem(IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION,
+                        loading_message_);
 
-  // Invoke a JSON-RPC call to the Spelling service in the background so we can
-  // update the placeholder item when we receive its response. It also starts
-  // the animation timer so we can show animation until we receive it.
-  const PrefService* pref = profile->GetPrefs();
-  std::string language =
-      pref ? pref->GetString(prefs::kSpellCheckDictionary) : "en-US";
-  Invoke(text, language, profile->GetRequestContext());
+    // Invoke a JSON-RPC call to the Spelling service in the background so we
+    // can update the placeholder item when we receive its response. It also
+    // starts the animation timer so we can show animation until we receive it.
+    const PrefService* pref = profile->GetPrefs();
+    std::string language =
+        pref ? pref->GetString(prefs::kSpellCheckDictionary) : "en-US";
+    Invoke(text, language, profile->GetRequestContext());
+  }
+
+  // Append Dictionary spell check suggestions.
+  suggestions_ = params.dictionary_suggestions;
+  for (size_t i = 0; i < params.dictionary_suggestions.size() &&
+       IDC_SPELLCHECK_SUGGESTION_0 + i <= IDC_SPELLCHECK_SUGGESTION_LAST;
+       ++i) {
+    proxy_->AddMenuItem(IDC_SPELLCHECK_SUGGESTION_0 + static_cast<int>(i),
+                        params.dictionary_suggestions[i]);
+  }
 }
 
 bool SpellingMenuObserver::IsCommandIdSupported(int command_id) {
+  if (command_id >= IDC_SPELLCHECK_SUGGESTION_0 &&
+      command_id <= IDC_SPELLCHECK_SUGGESTION_4)
+      return true;
+
   return command_id == IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION;
 }
 
 bool SpellingMenuObserver::IsCommandIdEnabled(int command_id) {
-  return command_id == IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION && succeeded_;
+  DCHECK(IsCommandIdSupported(command_id));
+
+  if (command_id >= IDC_SPELLCHECK_SUGGESTION_0 &&
+      command_id <= IDC_SPELLCHECK_SUGGESTION_4)
+      return true;
+
+  if (command_id == IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION)
+    return succeeded_;
+  return false;
 }
 
 void SpellingMenuObserver::ExecuteCommand(int command_id) {
-  if (IsCommandIdEnabled(command_id))
+  DCHECK(IsCommandIdSupported(command_id));
+
+  if (command_id >= IDC_SPELLCHECK_SUGGESTION_0 &&
+      command_id <= IDC_SPELLCHECK_SUGGESTION_4) {
+    proxy_->GetRenderViewHost()->Replace(
+        suggestions_[command_id - IDC_SPELLCHECK_SUGGESTION_0]);
+    // GetSpellCheckHost() can return null when the suggested word is
+    // provided by Web SpellCheck API.
+    Profile* profile = proxy_->GetProfile();
+    if (profile) {
+      SpellCheckHost* spellcheck_host = profile->GetSpellCheckHost();
+      if (spellcheck_host && spellcheck_host->GetMetrics())
+        spellcheck_host->GetMetrics()->RecordReplacedWordStats(1);
+    }
+    return;
+  }
+
+  if (command_id == IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION)
     proxy_->GetRenderViewHost()->Replace(result_);
 }
 
 bool SpellingMenuObserver::Invoke(const string16& text,
                                   const std::string& locale,
                                   net::URLRequestContextGetter* context) {
   // Create the parameters needed by Spelling API. Spelling API needs three
   // parameters: ISO language code, ISO3 country code, and text to be checked by
   // the service. On the other hand, Chrome uses an ISO locale ID and it may
   // not include a country ID, e.g. "fr", "de", etc. To create the input
@@ skipping 49 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   scoped_ptr<content::URLFetcher> clean_up_fetcher(fetcher_.release());
   animation_timer_.Stop();
 
   // Parse the response JSON and replace misspelled words in the |result_| text
   // with their suggestions.
   std::string data;
   source->GetResponseAsString(&data);
   succeeded_ = ParseResponse(source->GetResponseCode(), data);
-  if (!succeeded_)
-    result_ = l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_SPELLING_CORRECT);
 
-  // Update the menu item with the result text. We enable this item only when
-  // the request text has misspelled words. (We disable this item not only when
-  // we receive a server error but also when the input text consists only of
-  // well-spelled words. For either case, we do not need to replace the input
-  // text.)
+  // Update the menu item with the result text. We disable this item and hide it
+  // when the spelling service does not provide valid suggestions.
   proxy_->UpdateMenuItem(IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION, succeeded_,
-                         false, result_);
+                         !succeeded_, result_);
 }
 
 bool SpellingMenuObserver::ParseResponse(int response,
                                          const std::string& data) {
   // When this JSON-RPC call finishes successfully, the Spelling service returns
   // an JSON object listed below.
   // * result - an envelope object representing the result from the APIARY
   //   server, which is the JSON-API front-end for the Spelling service. This
   //   object consists of the following variable:
   //   - spellingCheckResponse (SpellingCheckResponse).
@@ skipping 62 matching lines @@
     // alternative.
     DictionaryValue* suggestion = NULL;
     string16 text;
     if (!suggestions->GetDictionary(0, &suggestion) ||
         !suggestion->GetString("suggestion", &text)) {
       return false;
     }
     result_.replace(start, length, text);
   }
 
+  // If the above result text is included in the suggestion list provided by the
+  // local spellchecker, we return false to hide this item.
+  for (std::vector<string16>::const_iterator it = suggestions_.begin();
+       it != suggestions_.end(); ++it) {
+    if (result_ == *it)
+      return false;
+  }
+
   return true;
 }
 
 void SpellingMenuObserver::OnAnimationTimerExpired() {
   if (!fetcher_.get())
     return;
 
   // Append '.' characters to the end of "Checking".
   loading_frame_ = (loading_frame_ + 1) & 3;
   string16 loading_message = loading_message_;
   for (int i = 0; i < loading_frame_; ++i)
     loading_message.push_back('.');
 
   // Update the menu item with the text. We disable this item to prevent users
   // from selecting it.
   proxy_->UpdateMenuItem(IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION, false, false,
                          loading_message);
 }