Move RenderProcessObserver and RenderViewVisitor to content\public\renderer and put them in the c...

chrome/renderer/spellchecker/spellcheck.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/renderer/spellchecker/spellcheck.h"
 
 #include "base/file_util.h"
 #include "base/metrics/histogram.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/spellcheck_common.h"
 #include "chrome/common/spellcheck_messages.h"
+#include "content/renderer/render_thread.h"
 #include "third_party/hunspell/src/hunspell/hunspell.hxx"
 
 using base::TimeTicks;
 
 SpellCheck::SpellCheck()
     : file_(base::kInvalidPlatformFileValue),
       auto_spell_correct_turned_on_(false),
       is_using_platform_spelling_engine_(false),
       initialized_(false) {
   // Wait till we check the first word before doing any initializing.
@@ skipping 190 matching lines @@
 void SpellCheck::AddWordToHunspell(const std::string& word) {
   if (!word.empty() && word.length() < MAXWORDUTF8LEN)
     hunspell_->add(word.c_str());
 }
 
 bool SpellCheck::InitializeIfNeeded() {
   if (is_using_platform_spelling_engine_)
     return false;
 
   if (!initialized_) {
-    Send(new SpellCheckHostMsg_RequestDictionary);
+    RenderThread::current()->Send(new SpellCheckHostMsg_RequestDictionary);
     initialized_ = true;
     return true;
   }
 
   // Don't initialize if hunspell is disabled.
   if (file_ != base::kInvalidPlatformFileValue)
     InitializeHunspell();
 
   return false;
 }
 
 // When called, relays the request to check the spelling to the proper
 // backend, either hunspell or a platform-specific backend.
 bool SpellCheck::CheckSpelling(const string16& word_to_check, int tag) {
   bool word_correct = false;
 
   if (is_using_platform_spelling_engine_) {
-    Send(new SpellCheckHostMsg_PlatformCheckSpelling(word_to_check, tag,
-                                                    &word_correct));
+    RenderThread::current()->Send(new SpellCheckHostMsg_PlatformCheckSpelling(
+        word_to_check, tag, &word_correct));
   } else {
     std::string word_to_check_utf8(UTF16ToUTF8(word_to_check));
     // Hunspell shouldn't let us exceed its max, but check just in case
     if (word_to_check_utf8.length() < MAXWORDUTF8LEN) {
       if (hunspell_.get()) {
         // |hunspell_->spell| returns 0 if the word is spelled correctly and
         // non-zero otherwsie.
         word_correct = (hunspell_->spell(word_to_check_utf8.c_str()) != 0);
       } else {
         // If |hunspell_| is NULL here, an error has occurred, but it's better
         // to check rather than crash.
         word_correct = true;
       }
     }
   }
 
   return word_correct;
 }
 
 void SpellCheck::FillSuggestionList(
     const string16& wrong_word,
     std::vector<string16>* optional_suggestions) {
   if (is_using_platform_spelling_engine_) {
-    Send(new SpellCheckHostMsg_PlatformFillSuggestionList(
-        wrong_word, optional_suggestions));
+    RenderThread::current()->Send(
+        new SpellCheckHostMsg_PlatformFillSuggestionList(
+            wrong_word, optional_suggestions));
     return;
   }
 
   // If |hunspell_| is NULL here, an error has occurred, but it's better
   // to check rather than crash.
   if (!hunspell_.get())
     return;
 
   char** suggestions;
   int number_of_suggestions =
@@ skipping 20 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;
 }