[Spellcheck] Make sure context menu and actual spellcheck state are in sync.

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/message_loop_proxy.h"
 #include "base/time.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 "chrome/renderer/spellchecker/hunspell_engine.h"
+#include "chrome/renderer/spellchecker/spellcheck_provider.h"
 #include "chrome/renderer/spellchecker/spelling_engine.h"
+#include "content/public/renderer/render_view.h"
+#include "content/public/renderer/render_view_visitor.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebTextCheckingCompletion.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebTextCheckingResult.h"
 
 using base::TimeTicks;
 using WebKit::WebVector;
 using WebKit::WebTextCheckingResult;
 using WebKit::WebTextCheckingType;
 
+namespace {
+
+class UpdateSpellcheckEnabled : public content::RenderViewVisitor {
+ public:
+  explicit UpdateSpellcheckEnabled(bool enabled) : enabled_(enabled) {}
+  virtual bool Visit(content::RenderView* render_view) OVERRIDE;
+
+ private:
+  bool enabled_;  // New spellcheck-enabled state.
+  DISALLOW_COPY_AND_ASSIGN(UpdateSpellcheckEnabled);
+};
+
+bool UpdateSpellcheckEnabled::Visit(content::RenderView* render_view) {
+  SpellCheckProvider* provider = SpellCheckProvider::Get(render_view);
+  DCHECK(provider);
+  provider->EnableSpellcheck(enabled_);
+  return true;
+}
+
+}  // namespace
+
 class SpellCheck::SpellcheckRequest {
  public:
   SpellcheckRequest(const string16& text,
                     int offset,
                     WebKit::WebTextCheckingCompletion* completion)
       : text_(text), offset_(offset), completion_(completion) {
     DCHECK(completion);
   }
   ~SpellcheckRequest() {}
 
   string16 text() { return text_; }
   int offset() { return offset_; }
   WebKit::WebTextCheckingCompletion* completion() { return completion_; }
 
  private:
   string16 text_;  // Text to be checked in this task.
   int offset_;   // The text offset from the beginning.
 
   // The interface to send the misspelled ranges to WebKit.
   WebKit::WebTextCheckingCompletion* completion_;
 
   DISALLOW_COPY_AND_ASSIGN(SpellcheckRequest);
 };
 
-SpellCheck::SpellCheck() : auto_spell_correct_turned_on_(false) {
+
+// Initializes SpellCheck object.
+// spellcheck_enabled_ currently MUST be set to true, due to peculiarities of
+// the initialization sequence.
+// Since it defaults to true, newly created SpellCheckProviders will enable
+// spellchecking. After the first word is typed, the provider requests a check,
+// which in turn triggers the delayed initialization sequence in SpellCheck.
+// This does send a message to the browser side, which triggers the creation
+// of the SpellcheckService. That does create the observer for the preference
+// responsible for enabling/disabling checking, which allows subsequent changes
+// to that preference to be sent to all SpellCheckProviders.
+// Setting |spellcheck_enabled_| to false by default prevents that mechanism,
+// and as such the SpellCheckProviders will never be notified of different
+// values.
+// TODO(groby): Simplify this.
+SpellCheck::SpellCheck()
+    : auto_spell_correct_turned_on_(false),
+      spellcheck_enabled_(true) {
   platform_spelling_engine_.reset(CreateNativeSpellingEngine());
 }
 
 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_WordRemoved, OnWordRemoved)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_EnableAutoSpellCorrect,
                         OnEnableAutoSpellCorrect)
+    IPC_MESSAGE_HANDLER(SpellCheckMsg_EnableSpellCheck, OnEnableSpellCheck)
     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) {
@@ skipping 12 matching lines @@
 
 void SpellCheck::OnWordRemoved(const std::string& word) {
   if (platform_spelling_engine_.get())
     platform_spelling_engine_->OnWordRemoved(word);
 }
 
 void SpellCheck::OnEnableAutoSpellCorrect(bool enable) {
   auto_spell_correct_turned_on_ = enable;
 }
 
+void SpellCheck::OnEnableSpellCheck(bool enable) {
+  spellcheck_enabled_ = enable;
+  UpdateSpellcheckEnabled updater(enable);
+  content::RenderView::ForEach(&updater);
+}
+
 // TODO(groby): Make sure we always have a spelling engine, even before Init()
 // is called.
 void SpellCheck::Init(base::PlatformFile file,
                       const std::vector<std::string>& custom_words,
                       const std::string& language) {
   platform_spelling_engine_->Init(file, custom_words);
 
   character_attributes_.SetDefaultLanguage(language);
   text_iterator_.Reset();
   contraction_iterator_.Reset();
@@ skipping 270 matching lines @@
         type = WebKit::WebTextCheckingTypeGrammar;
       }
     }
     list[i] = WebKit::WebTextCheckingResult(type,
                                             word_location + line_offset,
                                             word_length,
                                             spellcheck_results[i].replacement);
   }
   textcheck_results->swap(list);
 }