Move the spellchecker to the renderer....

chrome/browser/renderer_host/browser_render_process_host.cc

 // Copyright (c) 2009 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 "chrome/browser/renderer_host/browser_render_process_host.h"
 
 #include "build/build_config.h"
@@ skipping 22 matching lines @@
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/plugin_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/audio_renderer_host.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_view_host_delegate.h"
 #include "chrome/browser/renderer_host/render_widget_helper.h"
 #include "chrome/browser/renderer_host/render_widget_host.h"
 #include "chrome/browser/renderer_host/resource_message_filter.h"
 #include "chrome/browser/renderer_host/web_cache_manager.h"
+#if defined(SPELLCHECKER_IN_RENDERER)
+#include "chrome/browser/spellcheck_host.h"
+#endif
 #include "chrome/browser/spellchecker.h"
 #include "chrome/browser/visitedlink_master.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/child_process_info.h"
 #include "chrome/common/child_process_host.h"
 #include "chrome/common/chrome_descriptors.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/process_watcher.h"
 #include "chrome/common/render_messages.h"
@@ skipping 143 matching lines @@
       visible_widgets_(0),
       backgrounded_(true),
       ALLOW_THIS_IN_INITIALIZER_LIST(cached_dibs_cleaner_(
             base::TimeDelta::FromSeconds(5),
             this, &BrowserRenderProcessHost::ClearTransportDIBCache)),
       zygote_child_(false) {
   widget_helper_ = new RenderWidgetHelper();
 
   registrar_.Add(this, NotificationType::USER_SCRIPTS_UPDATED,
                  NotificationService::AllSources());
+#if defined(SPELLCHECKER_IN_RENDERER)
+  registrar_.Add(this, NotificationType::SPELLCHECK_HOST_REINITIALIZED,
+                 NotificationService::AllSources());
+  registrar_.Add(this, NotificationType::SPELLCHECK_WORD_ADDED,
+                 NotificationService::AllSources());
+
+  PrefService* prefs = profile->GetPrefs();
+  prefs->AddPrefObserver(prefs::kEnableAutoSpellCorrect, this);
+#endif
+
   visited_link_updater_.reset(new VisitedLinkUpdater());
 
   WebCacheManager::GetInstance()->Add(id());
   ChildProcessSecurityPolicy::GetInstance()->Add(id());
 
   // Note: When we create the BrowserRenderProcessHost, it's technically
   //       backgrounded, because it has no visible listeners.  But the process
   //       doesn't actually exist yet, so we'll Background it later, after
   //       creation.
 }
 
 BrowserRenderProcessHost::~BrowserRenderProcessHost() {
+#if defined(SPELLCHECKER_IN_RENDERER)
+  PrefService* prefs = profile()->GetPrefs();
+  prefs->RemovePrefObserver(prefs::kEnableAutoSpellCorrect, this);
+#endif
+
   WebCacheManager::GetInstance()->Remove(id());
   ChildProcessSecurityPolicy::GetInstance()->Remove(id());
 
   // We may have some unsent messages at this point, but that's OK.
   channel_.reset();
 
   // Destroy the AudioRendererHost properly.
   if (audio_renderer_host_.get())
     audio_renderer_host_->Destroy();
 
@@ skipping 113 matching lines @@
   }
 
   resource_message_filter->Init();
 
   // Now that the process is created, set its backgrounding accordingly.
   SetBackgrounded(backgrounded_);
 
   InitVisitedLinks();
   InitUserScripts();
   InitExtensions();
+#if defined(SPELLCHECKER_IN_RENDERER)
+  // 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();
+#endif
 
   if (max_page_id_ != -1)
     channel_->Send(new ViewMsg_SetNextPageID(max_page_id_ + 1));
 
   return true;
 }
 
 int BrowserRenderProcessHost::GetNextRoutingID() {
   return widget_helper_->GetNextRoutingID();
 }
@@ skipping 445 matching lines @@
       IPC_MESSAGE_HANDLER(ViewHostMsg_UpdatedCacheStats,
                           OnUpdatedCacheStats)
       IPC_MESSAGE_HANDLER(ViewHostMsg_SuddenTerminationChanged,
                           SuddenTerminationChanged);
       IPC_MESSAGE_HANDLER(ViewHostMsg_ExtensionAddListener,
                           OnExtensionAddListener)
       IPC_MESSAGE_HANDLER(ViewHostMsg_ExtensionRemoveListener,
                           OnExtensionRemoveListener)
       IPC_MESSAGE_HANDLER(ViewHostMsg_ExtensionCloseChannel,
                           OnExtensionCloseChannel)
+#if defined(SPELLCHECKER_IN_RENDERER)
+      IPC_MESSAGE_HANDLER(ViewHostMsg_SpellChecker_RequestDictionary,
+                          OnSpellCheckerRequestDictionary)
+#endif
       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.
       ReceivedBadMessage(msg.type());
     }
     return;
   }
@@ skipping 186 matching lines @@
                                        const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::USER_SCRIPTS_UPDATED: {
       base::SharedMemory* shared_memory =
           Details<base::SharedMemory>(details).ptr();
       if (shared_memory) {
         SendUserScriptsUpdate(shared_memory);
       }
       break;
     }
+#if defined(SPELLCHECKER_IN_RENDERER)
+    case NotificationType::SPELLCHECK_HOST_REINITIALIZED: {
+      InitSpellChecker();
+      break;
+    }
+    case NotificationType::SPELLCHECK_WORD_ADDED: {
+      AddSpellCheckWord(
+          reinterpret_cast<const Source<SpellCheckHost>*>(&source)->
+          ptr()->last_added_word());
+      break;
+    }
+    case NotificationType::PREF_CHANGED: {
+      std::wstring* pref_name_in = Details<std::wstring>(details).ptr();
+      PrefService* prefs = Source<PrefService>(source).ptr();
+      DCHECK(pref_name_in && prefs);
+      if (*pref_name_in == prefs::kEnableAutoSpellCorrect) {
+        EnableAutoSpellCorrect(
+            prefs->GetBoolean(prefs::kEnableAutoSpellCorrect));
+        break;
+      }
+      // Fall through.
+    }
+#endif
     default: {
       NOTREACHED();
       break;
     }
   }
 }
 
 void BrowserRenderProcessHost::OnExtensionAddListener(
     const std::string& event_name) {
   if (profile()->GetExtensionMessageService()) {
     profile()->GetExtensionMessageService()->AddEventListener(
         event_name, id());
   }
 }
 
 void BrowserRenderProcessHost::OnExtensionRemoveListener(
     const std::string& event_name) {
   if (profile()->GetExtensionMessageService()) {
     profile()->GetExtensionMessageService()->RemoveEventListener(
         event_name, id());
   }
 }
 
 void BrowserRenderProcessHost::OnExtensionCloseChannel(int port_id) {
   if (profile()->GetExtensionMessageService()) {
     profile()->GetExtensionMessageService()->CloseChannel(port_id);
   }
 }
+
+#if defined(SPELLCHECKER_IN_RENDERER)
+void BrowserRenderProcessHost::OnSpellCheckerRequestDictionary() {
+  // 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) {
+  channel_->Send(new ViewMsg_SpellChecker_WordAdded(word));
+}
+
+void BrowserRenderProcessHost::InitSpellChecker() {
+  SpellCheckHost* spellcheck_host = profile()->GetSpellCheckHost();
+  if (spellcheck_host) {
+    PrefService* prefs = profile()->GetPrefs();
+    channel_->Send(new ViewMsg_SpellChecker_Init(
+        spellcheck_host->bdict_fd(), spellcheck_host->custom_words(),
+        spellcheck_host->language(),
+        prefs->GetBoolean(prefs::kEnableAutoSpellCorrect)));
+  } else {
+    channel_->Send(new ViewMsg_SpellChecker_Init(
+        base::FileDescriptor(), std::vector<std::string>(), std::string(),
+        false));
+  }
+}
+
+void BrowserRenderProcessHost::EnableAutoSpellCorrect(bool enable) {
+  channel_->Send(new ViewMsg_SpellChecker_EnableAutoSpellCorrect(enable));
+}
+#endif