Editing the custom spelling dictionary

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"
@@ skipping 38 matching lines @@
 }
 
 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_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) {
   Init(IPC::PlatformFileForTransitToPlatformFile(bdict_file),
        custom_words, language);
   auto_spell_correct_turned_on_ = auto_spell_correct;
 #if !defined(OS_MACOSX)
   PostDelayedSpellCheckTask(pending_request_param_.release());
 #endif
 }
 
 void SpellCheck::OnWordAdded(const std::string& word) {
-  if (platform_spelling_engine_)
+  if (platform_spelling_engine_.get())
     platform_spelling_engine_->OnWordAdded(word);
 }
 
+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;
 }
 
 // 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) {
   bool use_platform_spelling_engine =
@@ skipping 23 matching lines @@
     std::vector<string16>* optional_suggestions) {
   DCHECK(in_word_len >= 0);
   DCHECK(misspelling_start && misspelling_len) << "Out vars must be given.";
 
   // Do nothing if we need to delay initialization. (Rather than blocking,
   // report the word as correctly spelled.)
   if (InitializeIfNeeded())
     return true;
 
   // Do nothing if spell checking is disabled.
   if (!platform_spelling_engine_ ||

[rpetterson, 2012/11/14 19:47:09]

Can you update this to platform_spelling_engine_.get() as well for consistency?
(since you updated the one above)

[please use gerrit instead, 2012/11/14 22:54:46]

Done.

       !platform_spelling_engine_->IsEnabled())
     return true;
 
   *misspelling_start = 0;
   *misspelling_len = 0;
   if (in_word_len == 0)
     return true;  // No input means always spelled correctly.
 
   string16 word;
   int word_start;
@@ skipping 246 matching lines @@
       }
     }
     list[i] = WebKit::WebTextCheckingResult(type,
                                             word_location + line_offset,
                                             word_length,
                                             spellcheck_results[i].replacement);
   }
   textcheck_results->swap(list);
 }
 #endif