Move code that talks to spellchecking out of content.

content/browser/renderer_host/browser_render_process_host.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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/browser_render_process_host.h"
 
 #include <algorithm>
@@ skipping 17 matching lines @@
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/net/resolve_proxy_msg_helper.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_host/web_cache_manager.h"
 #include "chrome/browser/safe_browsing/client_side_detection_service.h"
-#include "chrome/browser/spellcheck_host.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/safe_browsing/safebrowsing_messages.h"
-#include "chrome/common/spellcheck_messages.h"
 #include "content/browser/appcache/appcache_dispatcher_host.h"
 #include "content/browser/browser_child_process_host.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/content_browser_client.h"
 #include "content/browser/device_orientation/message_filter.h"
 #include "content/browser/geolocation/geolocation_dispatcher_host.h"
 #include "content/browser/gpu_data_manager.h"
 #include "content/browser/gpu_process_host.h"
 #include "content/browser/in_process_webkit/dom_storage_message_filter.h"
 #include "content/browser/in_process_webkit/indexed_db_dispatcher_host.h"
@@ skipping 140 matching lines @@
       visible_widgets_(0),
       backgrounded_(true),
       ALLOW_THIS_IN_INITIALIZER_LIST(cached_dibs_cleaner_(
             base::TimeDelta::FromSeconds(5),
             this, &BrowserRenderProcessHost::ClearTransportDIBCache)),
       accessibility_enabled_(false),
       extension_process_(false),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   widget_helper_ = new RenderWidgetHelper();
 
-  registrar_.Add(this, NotificationType::SPELLCHECK_HOST_REINITIALIZED,
-                 NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::SPELLCHECK_WORD_ADDED,
-                 NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::SPELLCHECK_AUTOSPELL_TOGGLED,
-                 NotificationService::AllSources());
-
   WebCacheManager::GetInstance()->Add(id());
   ChildProcessSecurityPolicy::GetInstance()->Add(id());
 
   // Grant most file permissions to this renderer.
   // PLATFORM_FILE_TEMPORARY, PLATFORM_FILE_HIDDEN and
   // PLATFORM_FILE_DELETE_ON_CLOSE are not granted, because no existing API
   // requests them.
   ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
       id(), profile->GetPath().Append(
           fileapi::SandboxMountPointProvider::kFileSystemDirectory),
@@ skipping 594 matching lines @@
   if (msg.routing_id() == MSG_ROUTING_CONTROL) {
     // Dispatch control messages.
     bool msg_is_ok = true;
     IPC_BEGIN_MESSAGE_MAP_EX(BrowserRenderProcessHost, msg, msg_is_ok)
       IPC_MESSAGE_HANDLER(ViewHostMsg_UpdatedCacheStats,
                           OnUpdatedCacheStats)
       IPC_MESSAGE_HANDLER(ViewHostMsg_SuddenTerminationChanged,
                           SuddenTerminationChanged)
       IPC_MESSAGE_HANDLER(ViewHostMsg_UserMetricsRecordAction,
                           OnUserMetricsRecordAction)
-      IPC_MESSAGE_HANDLER(SpellCheckHostMsg_RequestDictionary,
-                          OnSpellCheckerRequestDictionary)
       IPC_MESSAGE_UNHANDLED_ERROR()
     IPC_END_MESSAGE_MAP_EX()
 
     if (!msg_is_ok) {
       // The message had a handler, but its de-serialization failed.
       // We consider this a capital crime. Kill the renderer if we have one.
       LOG(ERROR) << "bad message " << msg.type() << " terminating renderer.";
       UserMetrics::RecordAction(UserMetricsAction("BadMessageTerminate_BRPH"));
       ReceivedBadMessage();
     }
@@ skipping 99 matching lines @@
   // intercepted the stack is messed up on return from the interceptor
   // which causes random crashes in the browser process. Our hack for now
   // is to not invoke the SetPriorityClass API if the dll is loaded.
   if (GetModuleHandle(L"cbstext.dll"))
     return;
 #endif  // OS_WIN
 
   child_process_launcher_->SetProcessBackgrounded(backgrounded);
 }
 
-void BrowserRenderProcessHost::Observe(NotificationType type,
-                                       const NotificationSource& source,
-                                       const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::SPELLCHECK_HOST_REINITIALIZED: {
-      InitSpellChecker();
-      break;
-    }
-    case NotificationType::SPELLCHECK_WORD_ADDED: {
-      AddSpellCheckWord(
-          reinterpret_cast<const Source<SpellCheckHost>*>(&source)->
-          ptr()->GetLastAddedFile());
-      break;
-    }
-    case NotificationType::SPELLCHECK_AUTOSPELL_TOGGLED: {
-      PrefService* prefs = profile()->GetPrefs();
-      EnableAutoSpellCorrect(
-          prefs->GetBoolean(prefs::kEnableAutoSpellCorrect));
-      break;
-    }
-    default: {
-      NOTREACHED();
-      break;
-    }
-  }
-}
-
 void BrowserRenderProcessHost::OnProcessLaunched() {
   if (child_process_launcher_.get())
     child_process_launcher_->SetProcessBackgrounded(backgrounded_);
 
   Send(new ViewMsg_SetIsIncognitoProcess(profile()->IsOffTheRecord()));
 
-  // We don't want to initialize the spellchecker unless SpellCheckHost has been
-  // created. In InitSpellChecker(), we know if GetSpellCheckHost() is NULL
-  // then the spellchecker has been turned off, but here, we don't know if
-  // it's been turned off or just not loaded yet.
-  if (profile()->GetSpellCheckHost())
-    InitSpellChecker();
-
   InitClientSidePhishingDetection();
 
   if (max_page_id_ != -1)
     Send(new ViewMsg_SetNextPageID(max_page_id_ + 1));
 
   // NOTE: This needs to be before sending queued messages because
   // ExtensionService uses this notification to initialize the renderer process
   // with state that must be there before any JavaScript executes.
   //
   // The queued messages contain such things as "navigate". If this notification
   // was after, we can end up executing JavaScript before the initialization
   // happens.
   NotificationService::current()->Notify(
       NotificationType::RENDERER_PROCESS_CREATED,
       Source<RenderProcessHost>(this), NotificationService::NoDetails());
 
   while (!queued_messages_.empty()) {
     Send(queued_messages_.front());
     queued_messages_.pop();
   }
 }
 
 void BrowserRenderProcessHost::OnUserMetricsRecordAction(
     const std::string& action) {
   UserMetrics::RecordComputedAction(action);
 }
 
-void BrowserRenderProcessHost::OnSpellCheckerRequestDictionary() {
-  if (profile()->GetSpellCheckHost()) {
-    // The spellchecker initialization already started and finished; just send
-    // it to the renderer.
-    InitSpellChecker();
-  } else {
-    // We may have gotten multiple requests from different renderers. We don't
-    // want to initialize multiple times in this case, so we set |force| to
-    // false.
-    profile()->ReinitializeSpellCheckHost(false);
-  }
-}
-
-void BrowserRenderProcessHost::AddSpellCheckWord(const std::string& word) {
-  Send(new SpellCheckMsg_WordAdded(word));
-}
-
-void BrowserRenderProcessHost::InitSpellChecker() {
-  SpellCheckHost* spellcheck_host = profile()->GetSpellCheckHost();
-  if (spellcheck_host) {
-    PrefService* prefs = profile()->GetPrefs();
-    IPC::PlatformFileForTransit file;
-
-    if (spellcheck_host->GetDictionaryFile() !=
-        base::kInvalidPlatformFileValue) {
-#if defined(OS_POSIX)
-      file = base::FileDescriptor(spellcheck_host->GetDictionaryFile(), false);
-#elif defined(OS_WIN)
-      ::DuplicateHandle(::GetCurrentProcess(),
-                        spellcheck_host->GetDictionaryFile(),
-                        GetHandle(),
-                        &file,
-                        0,
-                        false,
-                        DUPLICATE_SAME_ACCESS);
-#endif
-    }
-
-    Send(new SpellCheckMsg_Init(
-        file,
-        spellcheck_host->GetCustomWords(),
-        spellcheck_host->GetLanguage(),
-        prefs->GetBoolean(prefs::kEnableAutoSpellCorrect)));
-  } else {
-    Send(new SpellCheckMsg_Init(
-        IPC::InvalidPlatformFileForTransit(),
-        std::vector<std::string>(),
-        std::string(),
-        false));
-  }
-}
-
-void BrowserRenderProcessHost::EnableAutoSpellCorrect(bool enable) {
-  Send(new SpellCheckMsg_EnableAutoSpellCorrect(enable));
-}
-
 void BrowserRenderProcessHost::InitClientSidePhishingDetection() {
   if (g_browser_process->safe_browsing_detection_service()) {
     // The BrowserRenderProcessHost object might get deleted before the
     // safe browsing client-side detection service class is done with opening
     // the model file.  To avoid crashing we use the callback factory which will
     // cancel the callback if |this| is destroyed.
     g_browser_process->safe_browsing_detection_service()->GetModelFile(
         callback_factory_.NewCallback(
             &BrowserRenderProcessHost::OpenPhishingModelDone));
   }
 }
 
 void BrowserRenderProcessHost::OpenPhishingModelDone(
     base::PlatformFile model_file) {
   if (model_file != base::kInvalidPlatformFileValue) {
     IPC::PlatformFileForTransit file;
 #if defined(OS_POSIX)
     file = base::FileDescriptor(model_file, false);
 #elif defined(OS_WIN)
     ::DuplicateHandle(::GetCurrentProcess(), model_file, GetHandle(), &file, 0,
                       false, DUPLICATE_SAME_ACCESS);
 #endif
     Send(new SafeBrowsingMsg_SetPhishingModel(file));
   }
 }