Move the spellchecker to the renderer....

chrome/browser/profile.cc

 // Copyright (c) 2006-2008 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/browser/profile.h"
 
 #include "app/theme_provider.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 460 matching lines @@
   }
 
   virtual SpellChecker* GetSpellChecker() {
     return profile_->GetSpellChecker();
   }
 
   virtual void DeleteSpellChecker() {
     profile_->DeleteSpellChecker();
   }
 
+#if defined(SPELLCHECKER_IN_RENDERER)
+  virtual SpellCheckHost* GetSpellCheckHost() {
+    return profile_->GetSpellCheckHost();
+  }
+
+  virtual void ReinitializeSpellCheckHost(bool force) {
+    profile_->ReinitializeSpellCheckHost(force);
+  }
+#endif
+
   virtual WebKitContext* GetWebKitContext() {
   if (!webkit_context_.get())
     webkit_context_ = new WebKitContext(GetPath(), true);
   DCHECK(webkit_context_.get());
   return webkit_context_.get();
 }
 
   virtual ThumbnailStore* GetThumbnailStore() {
     return NULL;
   }
@@ skipping 71 matching lines @@
       extensions_request_context_(NULL),
       blacklist_(NULL),
       history_service_created_(false),
       favicon_service_created_(false),
       created_web_data_service_(false),
       created_password_store_(false),
       created_download_manager_(false),
       created_theme_provider_(false),
       start_time_(Time::Now()),
       spellchecker_(NULL),
+#if defined(OS_LINUX)
+      spellcheck_host_(NULL),
+      spellcheck_host_ready_(false),
+#endif
       shutdown_session_service_(false) {
   DCHECK(!path.empty()) << "Using an empty path will attempt to write " <<
                             "profile files to the root directory!";
   create_session_service_timer_.Start(
       TimeDelta::FromMilliseconds(kCreateSessionServiceDelayMS), this,
       &ProfileImpl::EnsureSessionServiceCreated);
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableExtensionTimelineApi)) {
     extension_devtools_manager_ = new ExtensionDevToolsManager(this);
@@ skipping 151 matching lines @@
   // increased the ref count of the service. In such a situation, when we
   // decrement the refcount, it won't be 0, and the threads/databases aren't
   // properly shut down. By explicitly calling Cleanup/Shutdown we ensure the
   // databases are properly closed.
   if (web_data_service_.get())
     web_data_service_->Shutdown();
 
   if (history_service_.get())
     history_service_->Cleanup();
 
+#if defined(SPELLCHECKER_IN_RENDERER)
+  if (spellcheck_host_.get())
+    spellcheck_host_->UnsetObserver();
+#endif
   DeleteSpellCheckerImpl(false);
 
   if (default_request_context_ == request_context_) {
 #if defined(OS_LINUX)
     // We use default_request_context_ for OCSP.
     // Release URLRequestContext used in OCSP handlers.
     net::SetURLRequestContextForOCSP(NULL);
 #endif
     default_request_context_ = NULL;
   }
@@ skipping 500 matching lines @@
     // Set auto spell correct status for spellchecker.
     spellchecker_->EnableAutoSpellCorrect(
         prefs->GetBoolean(prefs::kEnableAutoSpellCorrect));
 
     NotifySpellCheckerChanged();
   } else {
     DeleteSpellCheckerImpl(true);
   }
 }
 
+#if defined(SPELLCHECKER_IN_RENDERER)
+SpellCheckHost* ProfileImpl::GetSpellCheckHost() {
+  return spellcheck_host_ready_ ? spellcheck_host_.get() : NULL;
+}
+
+void ProfileImpl::ReinitializeSpellCheckHost(bool force) {
+  // If we are already loading the spellchecker, and this is just a hint to
+  // load the spellchecker, do nothing.
+  if (!force && spellcheck_host_.get())
+    return;
+
+  bool notify = false;
+  if (spellcheck_host_.get()) {
+    spellcheck_host_->UnsetObserver();
+    spellcheck_host_.release();
+    spellcheck_host_ready_ = false;
+    notify = true;
+  }
+
+  PrefService* prefs = GetPrefs();
+  if (prefs->GetBoolean(prefs::kEnableSpellCheck)) {
+    // Retrieve the (perhaps updated recently) dictionary name from preferences.
+    spellcheck_host_ = new SpellCheckHost(this,
+        WideToASCII(prefs->GetString(prefs::kSpellCheckDictionary)),
+        GetRequestContext());
+    spellcheck_host_->AddRef();
+  } else if (notify) {
+    // The spellchecker has been disabled.
+    SpellCheckHostInitialized();
+  }
+}
+
+void ProfileImpl::SpellCheckHostInitialized() {
+  spellcheck_host_ready_ =
+      spellcheck_host_ && spellcheck_host_->bdict_fd().fd != -1;
+  NotificationService::current()->Notify(
+      NotificationType::SPELLCHECK_HOST_REINITIALIZED,
+          Source<Profile>(this), NotificationService::NoDetails());
+}
+#endif
+
 void ProfileImpl::NotifySpellCheckerChanged() {
   SpellcheckerReinitializedDetails scoped_spellchecker;
   scoped_spellchecker.spellchecker = spellchecker_;
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
       new NotifySpellcheckerChangeTask(this, scoped_spellchecker));
 }
 
 void ProfileImpl::DeleteSpellCheckerImpl(bool notify) {
   if (!spellchecker_)
@@ skipping 48 matching lines @@
 }
 
 void ProfileImpl::Observe(NotificationType type,
                           const NotificationSource& source,
                           const NotificationDetails& details) {
   if (NotificationType::PREF_CHANGED == type) {
     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::kSpellCheckDictionary ||
-        *pref_name_in == prefs::kEnableSpellCheck ||
-        *pref_name_in == prefs::kEnableAutoSpellCorrect) {
+#if !defined(SPELLCHECKER_IN_RENDERER)
+        *pref_name_in == prefs::kEnableAutoSpellCorrect ||
+#endif
+        *pref_name_in == prefs::kEnableSpellCheck) {
       ReinitializeSpellChecker();
+#if defined(SPELLCHECKER_IN_RENDERER)
+      ReinitializeSpellCheckHost(true);
+#endif
     }
   } else if (NotificationType::THEME_INSTALLED == type) {
     Extension* extension = Details<Extension>(details).ptr();
     SetTheme(extension);
   } else if (NotificationType::BOOKMARK_MODEL_LOADED == type) {
     GetProfileSyncService();  // Causes lazy-load if sync is enabled.
     registrar_.Remove(this, NotificationType::BOOKMARK_MODEL_LOADED,
                       Source<Profile>(this));
   }
 }
@@ skipping 10 matching lines @@
     return sync_service_.get();
   }
 #endif
   return NULL;
 }
 
 void ProfileImpl::InitSyncService() {
   sync_service_.reset(new ProfileSyncService(this));
   sync_service_->Initialize();
 }