Move Mac to using renderer spellchecker.

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 20 matching lines @@
 #include "chrome/browser/notifications/desktop_notification_service.h"
 #include "chrome/browser/password_manager/password_store_default.h"
 #include "chrome/browser/privacy_blacklist/blacklist_io.h"
 #include "chrome/browser/profile_manager.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/search_versus_navigate_classifier.h"
 #include "chrome/browser/search_engines/template_url_fetcher.h"
 #include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
-#include "chrome/browser/spellchecker.h"
 #include "chrome/browser/ssl/ssl_host_state.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/thumbnail_store.h"
 #include "chrome/browser/visitedlink_master.h"
 #include "chrome/browser/visitedlink_event_listener.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/common/appcache/chrome_appcache_service.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 418 matching lines @@
     return start_time_;
   }
 
   virtual TabRestoreService* GetTabRestoreService() {
     return NULL;
   }
 
   virtual void ResetTabRestoreService() {
   }
 
-  virtual void ReinitializeSpellChecker() {
-    profile_->ReinitializeSpellChecker();
-  }
-
-  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();
-}
+    if (!webkit_context_.get())
+      webkit_context_ = new WebKitContext(GetPath(), true);
+    DCHECK(webkit_context_.get());
+    return webkit_context_.get();
+  }
 
   virtual ThumbnailStore* GetThumbnailStore() {
     return NULL;
   }
 
   virtual void MarkAsCleanShutdown() {
   }
 
   virtual void InitExtensions() {
     NOTREACHED();
@@ skipping 68 matching lines @@
       media_request_context_(NULL),
       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);
@@ skipping 155 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_)
     default_request_context_ = NULL;
 
   CleanupRequestContext(request_context_);
   CleanupRequestContext(media_request_context_);
   CleanupRequestContext(extensions_request_context_);
 
   // When the request contexts are gone, the blacklist wont be needed anymore.
   blacklist_.reset();
@@ skipping 458 matching lines @@
     thumbnail_store_->Init(
         GetPath().Append(chrome::kNewTabThumbnailsFilename), this);
   }
   return thumbnail_store_.get();
 }
 
 void ProfileImpl::ResetTabRestoreService() {
   tab_restore_service_ = NULL;
 }
 
-// To be run in the IO thread to notify all resource message filters that the
-// spellchecker has changed.
-class NotifySpellcheckerChangeTask : public Task {
- public:
-  NotifySpellcheckerChangeTask(
-      Profile* profile,
-      const SpellcheckerReinitializedDetails& spellchecker)
-      : profile_(profile),
-        spellchecker_(spellchecker) {
-  }
-
- private:
-  void Run(void) {
-    NotificationService::current()->Notify(
-        NotificationType::SPELLCHECKER_REINITIALIZED,
-        Source<Profile>(profile_),
-        Details<SpellcheckerReinitializedDetails>(&spellchecker_));
-  }
-
-  Profile* profile_;
-  SpellcheckerReinitializedDetails spellchecker_;
-};
-
-void ProfileImpl::ReinitializeSpellChecker() {
-  PrefService* prefs = GetPrefs();
-  if (prefs->GetBoolean(prefs::kEnableSpellCheck)) {
-    DeleteSpellCheckerImpl(false);
-
-    // Retrieve the (perhaps updated recently) dictionary name from preferences.
-    FilePath dict_dir;
-    PathService::Get(chrome::DIR_APP_DICTIONARIES, &dict_dir);
-    // Note that, as the object pointed to by previously by spellchecker_
-    // is being deleted in the io thread, the spellchecker_ can be made to point
-    // to a new object (RE-initialized) in parallel in this UI thread.
-    spellchecker_ = new SpellChecker(dict_dir,
-        WideToASCII(prefs->GetString(prefs::kSpellCheckDictionary)),
-        GetRequestContext(),
-        FilePath());
-    spellchecker_->AddRef();  // Manual refcounting.
-
-    // 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;
 
@@ skipping 14 matching lines @@
         GetRequestContext());
     spellcheck_host_->Initialize();
   } else if (notify) {
     // The spellchecker has been disabled.
     SpellCheckHostInitialized();
   }
 }
 
 void ProfileImpl::SpellCheckHostInitialized() {
   spellcheck_host_ready_ = spellcheck_host_ &&
-      spellcheck_host_->bdict_file() != base::kInvalidPlatformFileValue;
+      (spellcheck_host_->bdict_file() != base::kInvalidPlatformFileValue ||
+       spellcheck_host_->use_platform_spellchecker());
   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_)
-    return;
-
-  // The spellchecker must be deleted on the I/O thread.
-  ChromeThread::ReleaseSoon(ChromeThread::IO, FROM_HERE, spellchecker_);
-  spellchecker_ = NULL;
-
-  if (notify)
-    NotifySpellCheckerChanged();
-}
-
-SpellChecker* ProfileImpl::GetSpellChecker() {
-  if (!spellchecker_) {
-    // This is where spellchecker gets initialized. Note that this is being
-    // initialized in the ui_thread. However, this is not a problem as long as
-    // it is *used* in the io thread.
-    // TODO(sidchat): One day, change everything so that spellchecker gets
-    // initialized in the IO thread itself.
-    ReinitializeSpellChecker();
-  }
-
-  return spellchecker_;
-}
 
 WebKitContext* ProfileImpl::GetWebKitContext() {
   if (!webkit_context_.get())
     webkit_context_ = new WebKitContext(path_, false);
   DCHECK(webkit_context_.get());
   return webkit_context_.get();
 }
 
 DesktopNotificationService* ProfileImpl::GetDesktopNotificationService() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
@@ skipping 16 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 ||
-#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 (*pref_name_in == prefs::kEnableAutoSpellCorrect) {
+      NotificationService::current()->Notify(
+          NotificationType::SPELLCHECK_AUTOSPELL_TOGGLED,
+              Source<Profile>(this), NotificationService::NoDetails());
     }
   } 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));
   }
 }
 
 void ProfileImpl::StopCreateSessionServiceTimer() {
   create_session_service_timer_.Stop();
 }
 
 ProfileSyncService* ProfileImpl::GetProfileSyncService() {
   if (!ProfileSyncService::IsSyncEnabled()) {
     return NULL;
   }
   if (!sync_service_.get())
     InitSyncService();
   return sync_service_.get();
 }
 
 void ProfileImpl::InitSyncService() {
   sync_service_.reset(new ProfileSyncService(this));
   sync_service_->Initialize();
 }