chrome/browser/renderer_context_menu/spelling_menu_observer.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/renderer_context_menu/spelling_menu_observer.h"
   6
   7 #include "base/bind.h"
   8 #include "base/command_line.h"
   9 #include "base/i18n/case_conversion.h"
  10 #include "base/prefs/pref_service.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "chrome/app/chrome_command_ids.h"
  13 #include "chrome/browser/profiles/profile.h"
  14 #include "chrome/browser/renderer_context_menu/render_view_context_menu.h"
  15 #include "chrome/browser/renderer_context_menu/spelling_bubble_model.h"
  16 #include "chrome/browser/spellchecker/spellcheck_factory.h"
  17 #include "chrome/browser/spellchecker/spellcheck_host_metrics.h"
  18 #include "chrome/browser/spellchecker/spellcheck_platform_mac.h"
  19 #include "chrome/browser/spellchecker/spellcheck_service.h"
  20 #include "chrome/browser/spellchecker/spelling_service_client.h"
  21 #include "chrome/browser/ui/confirm_bubble.h"
  22 #include "chrome/common/chrome_switches.h"
  23 #include "chrome/common/pref_names.h"
  24 #include "chrome/common/spellcheck_result.h"
  25 #include "content/public/browser/render_view_host.h"
  26 #include "content/public/browser/render_widget_host_view.h"
  27 #include "content/public/browser/web_contents.h"
  28 #include "content/public/common/context_menu_params.h"
  29 #include "extensions/browser/view_type_utils.h"
  30 #include "grit/generated_resources.h"
  31 #include "ui/base/l10n/l10n_util.h"
  32 #include "ui/gfx/rect.h"
  33
  34 using content::BrowserThread;
  35
  36 SpellingMenuObserver::SpellingMenuObserver(RenderViewContextMenuProxy* proxy)
  37     : proxy_(proxy),
  38       loading_frame_(0),
  39       succeeded_(false),
  40       misspelling_hash_(0),
  41       client_(new SpellingServiceClient) {
  42   if (proxy && proxy->GetProfile()) {
  43     integrate_spelling_service_.Init(prefs::kSpellCheckUseSpellingService,
  44                                      proxy->GetProfile()->GetPrefs());
  45     autocorrect_spelling_.Init(prefs::kEnableAutoSpellCorrect,
  46                                proxy->GetProfile()->GetPrefs());
  47   }
  48 }
  49
  50 SpellingMenuObserver::~SpellingMenuObserver() {
  51 }
  52
  53 void SpellingMenuObserver::InitMenu(const content::ContextMenuParams& params) {
  54   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  55   DCHECK(!params.misspelled_word.empty() ||
  56       params.dictionary_suggestions.empty());
  57
  58   // Exit if we are not in an editable element because we add a menu item only
  59   // for editable elements.
  60   Profile* profile = proxy_->GetProfile();
  61   if (!params.is_editable || !profile)
  62     return;
  63
  64   // Exit if there is no misspelled word.
  65   if (params.misspelled_word.empty())
  66     return;
  67
  68   suggestions_ = params.dictionary_suggestions;
  69   misspelled_word_ = params.misspelled_word;
  70   misspelling_hash_ = params.misspelling_hash;
  71
  72   bool use_suggestions = SpellingServiceClient::IsAvailable(
  73       profile, SpellingServiceClient::SUGGEST);
  74
  75   if (!suggestions_.empty() || use_suggestions)
  76     proxy_->AddSeparator();
  77
  78   // Append Dictionary spell check suggestions.
  79   for (size_t i = 0; i < params.dictionary_suggestions.size() &&
  80        IDC_SPELLCHECK_SUGGESTION_0 + i <= IDC_SPELLCHECK_SUGGESTION_LAST;
  81        ++i) {
  82     proxy_->AddMenuItem(IDC_SPELLCHECK_SUGGESTION_0 + static_cast<int>(i),
  83                         params.dictionary_suggestions[i]);
  84   }
  85
  86   // The service types |SpellingServiceClient::SPELLCHECK| and
  87   // |SpellingServiceClient::SUGGEST| are mutually exclusive. Only one is
  88   // available at at time.
  89   //
  90   // When |SpellingServiceClient::SPELLCHECK| is available, the contextual
  91   // suggestions from |SpellingServiceClient| are already stored in
  92   // |params.dictionary_suggestions|.  |SpellingMenuObserver| places these
  93   // suggestions in the slots |IDC_SPELLCHECK_SUGGESTION_[0-LAST]|. If
  94   // |SpellingMenuObserver| queried |SpellingServiceClient| again, then quality
  95   // of suggestions would be reduced by lack of context around the misspelled
  96   // word.
  97   //
  98   // When |SpellingServiceClient::SUGGEST| is available,
  99   // |params.dictionary_suggestions| contains suggestions only from Hunspell
 100   // dictionary. |SpellingMenuObserver| queries |SpellingServiceClient| with the
 101   // misspelled word without the surrounding context. Spellcheck suggestions
 102   // from |SpellingServiceClient::SUGGEST| are not available until
 103   // |SpellingServiceClient| responds to the query. While |SpellingMenuObserver|
 104   // waits for |SpellingServiceClient|, it shows a placeholder text "Loading
 105   // suggestion..." in the |IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION| slot. After
 106   // |SpellingServiceClient| responds to the query, |SpellingMenuObserver|
 107   // replaces the placeholder text with either the spelling suggestion or the
 108   // message "No more suggestions from Google." The "No more suggestions"
 109   // message is there when |SpellingServiceClient| returned the same suggestion
 110   // as Hunspell.
 111   if (use_suggestions) {
 112     // Append a placeholder item for the suggestion from the Spelling service
 113     // and send a request to the service if we can retrieve suggestions from it.
 114     // Also, see if we can use the spelling service to get an ideal suggestion.
 115     // Otherwise, we'll fall back to the set of suggestions.  Initialize
 116     // variables used in OnTextCheckComplete(). We copy the input text to the
 117     // result text so we can replace its misspelled regions with suggestions.
 118     succeeded_ = false;
 119     result_ = params.misspelled_word;
 120
 121     // Add a placeholder item. This item will be updated when we receive a
 122     // response from the Spelling service. (We do not have to disable this
 123     // item now since Chrome will call IsCommandIdEnabled() and disable it.)
 124     loading_message_ =
 125         l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_SPELLING_CHECKING);
 126     proxy_->AddMenuItem(IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION,
 127                         loading_message_);
 128     // Invoke a JSON-RPC call to the Spelling service in the background so we
 129     // can update the placeholder item when we receive its response. It also
 130     // starts the animation timer so we can show animation until we receive
 131     // it.
 132     bool result = client_->RequestTextCheck(
 133         profile, SpellingServiceClient::SUGGEST, params.misspelled_word,
 134         base::Bind(&SpellingMenuObserver::OnTextCheckComplete,
 135                    base::Unretained(this), SpellingServiceClient::SUGGEST));
 136     if (result) {
 137       loading_frame_ = 0;
 138       animation_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(1),
 139           this, &SpellingMenuObserver::OnAnimationTimerExpired);
 140     }
 141   }
 142
 143   if (params.dictionary_suggestions.empty()) {
 144     proxy_->AddMenuItem(
 145         IDC_CONTENT_CONTEXT_NO_SPELLING_SUGGESTIONS,
 146         l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_NO_SPELLING_SUGGESTIONS));
 147     bool use_spelling_service = SpellingServiceClient::IsAvailable(
 148         profile, SpellingServiceClient::SPELLCHECK);
 149     if (use_suggestions || use_spelling_service)
 150       proxy_->AddSeparator();
 151   } else {
 152     proxy_->AddSeparator();
 153
 154     // |spellcheck_service| can be null when the suggested word is
 155     // provided by Web SpellCheck API.
 156     SpellcheckService* spellcheck_service =
 157         SpellcheckServiceFactory::GetForContext(profile);
 158     if (spellcheck_service && spellcheck_service->GetMetrics())
 159       spellcheck_service->GetMetrics()->RecordSuggestionStats(1);
 160   }
 161
 162   // If word is misspelled, give option for "Add to dictionary" and a check item
 163   // "Ask Google for suggestions".
 164   proxy_->AddMenuItem(IDC_SPELLCHECK_ADD_TO_DICTIONARY,
 165       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_ADD_TO_DICTIONARY));
 166
 167   proxy_->AddCheckItem(IDC_CONTENT_CONTEXT_SPELLING_TOGGLE,
 168       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_SPELLING_ASK_GOOGLE));
 169
 170   const CommandLine* command_line = CommandLine::ForCurrentProcess();
 171   if (command_line->HasSwitch(switches::kEnableSpellingAutoCorrect)) {
 172     proxy_->AddCheckItem(IDC_CONTENT_CONTEXT_AUTOCORRECT_SPELLING_TOGGLE,
 173         l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_SPELLING_AUTOCORRECT));
 174   }
 175
 176   proxy_->AddSeparator();
 177 }
 178
 179 bool SpellingMenuObserver::IsCommandIdSupported(int command_id) {
 180   if (command_id >= IDC_SPELLCHECK_SUGGESTION_0 &&
 181       command_id <= IDC_SPELLCHECK_SUGGESTION_LAST)
 182     return true;
 183
 184   switch (command_id) {
 185     case IDC_SPELLCHECK_ADD_TO_DICTIONARY:
 186     case IDC_CONTENT_CONTEXT_NO_SPELLING_SUGGESTIONS:
 187     case IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION:
 188     case IDC_CONTENT_CONTEXT_SPELLING_TOGGLE:
 189     case IDC_CONTENT_CONTEXT_AUTOCORRECT_SPELLING_TOGGLE:
 190       return true;
 191
 192     default:
 193       return false;
 194   }
 195 }
 196
 197 bool SpellingMenuObserver::IsCommandIdChecked(int command_id) {
 198   DCHECK(IsCommandIdSupported(command_id));
 199
 200   if (command_id == IDC_CONTENT_CONTEXT_SPELLING_TOGGLE)
 201     return integrate_spelling_service_.GetValue() &&
 202         !proxy_->GetProfile()->IsOffTheRecord();
 203   if (command_id == IDC_CONTENT_CONTEXT_AUTOCORRECT_SPELLING_TOGGLE)
 204     return autocorrect_spelling_.GetValue() &&
 205         !proxy_->GetProfile()->IsOffTheRecord();
 206   return false;
 207 }
 208
 209 bool SpellingMenuObserver::IsCommandIdEnabled(int command_id) {
 210   DCHECK(IsCommandIdSupported(command_id));
 211
 212   if (command_id >= IDC_SPELLCHECK_SUGGESTION_0 &&
 213       command_id <= IDC_SPELLCHECK_SUGGESTION_LAST)
 214     return true;
 215
 216   switch (command_id) {
 217     case IDC_SPELLCHECK_ADD_TO_DICTIONARY:
 218       return !misspelled_word_.empty();
 219
 220     case IDC_CONTENT_CONTEXT_NO_SPELLING_SUGGESTIONS:
 221       return false;
 222
 223     case IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION:
 224       return succeeded_;
 225
 226     case IDC_CONTENT_CONTEXT_SPELLING_TOGGLE:
 227       return integrate_spelling_service_.IsUserModifiable() &&
 228           !proxy_->GetProfile()->IsOffTheRecord();
 229
 230     case IDC_CONTENT_CONTEXT_AUTOCORRECT_SPELLING_TOGGLE:
 231       return integrate_spelling_service_.IsUserModifiable() &&
 232           !proxy_->GetProfile()->IsOffTheRecord();
 233
 234     default:
 235       return false;
 236   }
 237 }
 238
 239 void SpellingMenuObserver::ExecuteCommand(int command_id) {
 240   DCHECK(IsCommandIdSupported(command_id));
 241
 242   if (command_id >= IDC_SPELLCHECK_SUGGESTION_0 &&
 243       command_id <= IDC_SPELLCHECK_SUGGESTION_LAST) {
 244     int suggestion_index = command_id - IDC_SPELLCHECK_SUGGESTION_0;
 245     proxy_->GetWebContents()->ReplaceMisspelling(
 246         suggestions_[suggestion_index]);
 247     // GetSpellCheckHost() can return null when the suggested word is provided
 248     // by Web SpellCheck API.
 249     Profile* profile = proxy_->GetProfile();
 250     if (profile) {
 251       SpellcheckService* spellcheck =
 252           SpellcheckServiceFactory::GetForContext(profile);
 253       if (spellcheck) {
 254         if (spellcheck->GetMetrics())
 255           spellcheck->GetMetrics()->RecordReplacedWordStats(1);
 256         spellcheck->GetFeedbackSender()->SelectedSuggestion(
 257             misspelling_hash_, suggestion_index);
 258       }
 259     }
 260     return;
 261   }
 262
 263   // When we choose the suggestion sent from the Spelling service, we replace
 264   // the misspelled word with the suggestion and add it to our custom-word
 265   // dictionary so this word is not marked as misspelled any longer.
 266   if (command_id == IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION) {
 267     proxy_->GetWebContents()->ReplaceMisspelling(result_);
 268     misspelled_word_ = result_;
 269   }
 270
 271   if (command_id == IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION ||
 272       command_id == IDC_SPELLCHECK_ADD_TO_DICTIONARY) {
 273     // GetHostForProfile() can return null when the suggested word is provided
 274     // by Web SpellCheck API.
 275     Profile* profile = proxy_->GetProfile();
 276     if (profile) {
 277       SpellcheckService* spellcheck =
 278           SpellcheckServiceFactory::GetForContext(profile);
 279       if (spellcheck) {
 280         spellcheck->GetCustomDictionary()->AddWord(base::UTF16ToUTF8(
 281             misspelled_word_));
 282         spellcheck->GetFeedbackSender()->AddedToDictionary(misspelling_hash_);
 283       }
 284     }
 285 #if defined(OS_MACOSX)
 286     spellcheck_mac::AddWord(misspelled_word_);
 287 #endif
 288   }
 289
 290   // The spelling service can be toggled by the user only if it is not managed.
 291   if (command_id == IDC_CONTENT_CONTEXT_SPELLING_TOGGLE &&
 292       integrate_spelling_service_.IsUserModifiable()) {
 293     // When a user enables the "Ask Google for spelling suggestions" item, we
 294     // show a bubble to confirm it. On the other hand, when a user disables this
 295     // item, we directly update/ the profile and stop integrating the spelling
 296     // service immediately.
 297     if (!integrate_spelling_service_.GetValue()) {
 298       content::RenderViewHost* rvh = proxy_->GetRenderViewHost();
 299       gfx::Rect rect = rvh->GetView()->GetViewBounds();
 300       chrome::ShowConfirmBubble(
 301 #if defined(TOOLKIT_VIEWS)
 302           proxy_->GetWebContents()->GetTopLevelNativeWindow(),
 303 #else
 304           rvh->GetView()->GetNativeView(),
 305 #endif
 306           gfx::Point(rect.CenterPoint().x(), rect.y()),
 307           new SpellingBubbleModel(proxy_->GetProfile(),
 308                                   proxy_->GetWebContents(),
 309                                   false));
 310     } else {
 311       Profile* profile = proxy_->GetProfile();
 312       if (profile)
 313         profile->GetPrefs()->SetBoolean(prefs::kSpellCheckUseSpellingService,
 314                                         false);
 315         profile->GetPrefs()->SetBoolean(prefs::kEnableAutoSpellCorrect,
 316                                         false);
 317     }
 318   }
 319   // Autocorrect requires use of the spelling service and the spelling service
 320   // can be toggled by the user only if it is not managed.
 321   if (command_id == IDC_CONTENT_CONTEXT_AUTOCORRECT_SPELLING_TOGGLE &&
 322       integrate_spelling_service_.IsUserModifiable()) {
 323     // When the user enables autocorrect, we'll need to make sure that we can
 324     // ask Google for suggestions since that service is required. So we show
 325     // the bubble and just make sure to enable autocorrect as well.
 326     if (!integrate_spelling_service_.GetValue()) {
 327       content::RenderViewHost* rvh = proxy_->GetRenderViewHost();
 328       gfx::Rect rect = rvh->GetView()->GetViewBounds();
 329       chrome::ShowConfirmBubble(rvh->GetView()->GetNativeView(),
 330                                 gfx::Point(rect.CenterPoint().x(), rect.y()),
 331                                 new SpellingBubbleModel(
 332                                     proxy_->GetProfile(),
 333                                     proxy_->GetWebContents(),
 334                                     true));
 335     } else {
 336       Profile* profile = proxy_->GetProfile();
 337       if (profile) {
 338         bool current_value = autocorrect_spelling_.GetValue();
 339         profile->GetPrefs()->SetBoolean(prefs::kEnableAutoSpellCorrect,
 340                                         !current_value);
 341       }
 342     }
 343   }
 344 }
 345
 346 void SpellingMenuObserver::OnMenuCancel() {
 347   Profile* profile = proxy_->GetProfile();
 348   if (!profile)
 349     return;
 350   SpellcheckService* spellcheck =
 351       SpellcheckServiceFactory::GetForContext(profile);
 352   if (!spellcheck)
 353     return;
 354   spellcheck->GetFeedbackSender()->IgnoredSuggestions(misspelling_hash_);
 355 }
 356
 357 void SpellingMenuObserver::OnTextCheckComplete(
 358     SpellingServiceClient::ServiceType type,
 359     bool success,
 360     const base::string16& text,
 361     const std::vector<SpellCheckResult>& results) {
 362   animation_timer_.Stop();
 363
 364   // Scan the text-check results and replace the misspelled regions with
 365   // suggested words. If the replaced text is included in the suggestion list
 366   // provided by the local spellchecker, we show a "No suggestions from Google"
 367   // message.
 368   succeeded_ = success;
 369   if (results.empty()) {
 370     succeeded_ = false;
 371   } else {
 372     typedef std::vector<SpellCheckResult> SpellCheckResults;
 373     for (SpellCheckResults::const_iterator it = results.begin();
 374          it != results.end(); ++it) {
 375       result_.replace(it->location, it->length, it->replacement);
 376     }
 377     base::string16 result = base::i18n::ToLower(result_);
 378     for (std::vector<base::string16>::const_iterator it = suggestions_.begin();
 379          it != suggestions_.end(); ++it) {
 380       if (result == base::i18n::ToLower(*it)) {
 381         succeeded_ = false;
 382         break;
 383       }
 384     }
 385   }
 386   if (type != SpellingServiceClient::SPELLCHECK) {
 387     if (!succeeded_) {
 388       result_ = l10n_util::GetStringUTF16(
 389           IDS_CONTENT_CONTEXT_SPELLING_NO_SUGGESTIONS_FROM_GOOGLE);
 390     }
 391
 392     // Update the menu item with the result text. We disable this item and hide
 393     // it when the spelling service does not provide valid suggestions.
 394     proxy_->UpdateMenuItem(IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION, succeeded_,
 395                            false, result_);
 396   }
 397 }
 398
 399 void SpellingMenuObserver::OnAnimationTimerExpired() {
 400   // Append '.' characters to the end of "Checking".
 401   loading_frame_ = (loading_frame_ + 1) & 3;
 402   base::string16 loading_message =
 403       loading_message_ + base::string16(loading_frame_,'.');
 404
 405   // Update the menu item with the text. We disable this item to prevent users
 406   // from selecting it.
 407   proxy_->UpdateMenuItem(IDC_CONTENT_CONTEXT_SPELLING_SUGGESTION, false, false,
 408                          loading_message);
 409 }