Move Mac to using renderer spellchecker.

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 <algorithm>
@@ skipping 22 matching lines @@
 #include "chrome/browser/net/url_request_context_getter.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/logging_chrome.h"
 #include "chrome/common/notification_service.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/common/process_watcher.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/result_codes.h"
 #include "chrome/renderer/render_process.h"
 #include "chrome/renderer/render_thread.h"
 #include "grit/generated_resources.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_platform_file.h"
 #include "ipc/ipc_switches.h"
 
@@ skipping 129 matching lines @@
       visible_widgets_(0),
       backgrounded_(true),
       ALLOW_THIS_IN_INITIALIZER_LIST(cached_dibs_cleaner_(
             base::TimeDelta::FromSeconds(5),
             this, &BrowserRenderProcessHost::ClearTransportDIBCache)),
       extension_process_(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
+  registrar_.Add(this, NotificationType::SPELLCHECK_AUTOSPELL_TOGGLED,
+                 NotificationService::AllSources());
 
   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();
   while (!queued_messages_.empty()) {
     delete queued_messages_.front();
     queued_messages_.pop();
   }
 
@@ skipping 31 matching lines @@
   audio_renderer_host_ = new AudioRendererHost();
 
   scoped_refptr<ResourceMessageFilter> resource_message_filter =
       new ResourceMessageFilter(g_browser_process->resource_dispatcher_host(),
                                 id(),
                                 audio_renderer_host_.get(),
                                 PluginService::GetInstance(),
                                 g_browser_process->print_job_manager(),
                                 profile(),
                                 widget_helper_,
-                                profile()->GetSpellChecker(),
                                 request_context);
 
   // Find the renderer before creating the channel so if this fails early we
   // return without creating the channel.
   FilePath renderer_path = ChildProcessHost::GetChildPath();
   if (renderer_path.empty())
     return false;
 
   // Setup the IPC channel.
   const std::string channel_id =
@@ skipping 96 matching lines @@
 
   DCHECK_EQ(backgrounded_, (visible_widgets_ == 0));
   visible_widgets_--;
   DCHECK_GE(visible_widgets_, 0);
   if (visible_widgets_ == 0) {
     DCHECK(!backgrounded_);
     SetBackgrounded(true);
   }
 }
 
-void BrowserRenderProcessHost::AddWord(const string16& word) {
-  SpellChecker* spellchecker = profile()->GetSpellChecker();
-  if (spellchecker) {
-    ChromeThread::PostTask(
-        ChromeThread::IO, FROM_HERE,
-        NewRunnableMethod(spellchecker, &SpellChecker::AddWord, word));
-  }
-}
-
 void BrowserRenderProcessHost::SendVisitedLinkTable(
     base::SharedMemory* table_memory) {
   // Check if the process is still starting and we don't have a handle for it
   // yet, in which case this will happen later when InitVisitedLinks is called.
   if (!run_renderer_in_process() &&
       (!child_process_.get() || child_process_->IsStarting())) {
     return;
   }
 
   base::SharedMemoryHandle handle_for_process;
@@ skipping 339 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 114 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.
+    case NotificationType::SPELLCHECK_AUTOSPELL_TOGGLED: {
+      PrefService* prefs = profile()->GetPrefs();
+      EnableAutoSpellCorrect(
+          prefs->GetBoolean(prefs::kEnableAutoSpellCorrect));
+      break;
     }
-#endif
     default: {
       NOTREACHED();
       break;
     }
   }
 }
 
 void BrowserRenderProcessHost::OnProcessLaunched() {
   // 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)
     Send(new ViewMsg_SetNextPageID(max_page_id_ + 1));
 
   while (!queued_messages_.empty()) {
     Send(queued_messages_.front());
     queued_messages_.pop();
   }
 
   NotificationService::current()->Notify(
@@ skipping 16 matching lines @@
         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) {
   Send(new ViewMsg_SpellChecker_WordAdded(word));
 }
 
 void BrowserRenderProcessHost::InitSpellChecker() {
   SpellCheckHost* spellcheck_host = profile()->GetSpellCheckHost();
   if (spellcheck_host) {
     PrefService* prefs = profile()->GetPrefs();
     IPC::PlatformFileForTransit file;
+
+    if (spellcheck_host->bdict_file() != base::kInvalidPlatformFileValue) {
 #if defined(OS_POSIX)
-    file = base::FileDescriptor(spellcheck_host->bdict_file(), false);
+      file = base::FileDescriptor(spellcheck_host->bdict_file(), false);
 #elif defined(OS_WIN)
-    ::DuplicateHandle(::GetCurrentProcess(), spellcheck_host->bdict_file(),
-                      GetHandle(), &file, 0, false, DUPLICATE_SAME_ACCESS);
+      ::DuplicateHandle(::GetCurrentProcess(), spellcheck_host->bdict_file(),
+                        GetHandle(), &file, 0, false, DUPLICATE_SAME_ACCESS);
 #endif
+    }
+
     Send(new ViewMsg_SpellChecker_Init(
         file,
         spellcheck_host->custom_words(),
         spellcheck_host->language(),
         prefs->GetBoolean(prefs::kEnableAutoSpellCorrect)));
   } else {
     Send(new ViewMsg_SpellChecker_Init(
         IPC::PlatformFileForTransit(),
         std::vector<std::string>(),
         std::string(),
         false));
   }
 }
 
 void BrowserRenderProcessHost::EnableAutoSpellCorrect(bool enable) {
   Send(new ViewMsg_SpellChecker_EnableAutoSpellCorrect(enable));
 }
-#endif