Move code that talks to spellchecking out of content.

chrome/browser/spellcheck_host_impl.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.
 
 #include "chrome/browser/spellcheck_host_impl.h"
 
 #include <set>
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_split.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/spellcheck_host_observer.h"
 #include "chrome/browser/spellchecker_platform_engine.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/common/spellcheck_common.h"
+#include "chrome/common/spellcheck_messages.h"
+#include "content/browser/renderer_host/render_process_host.h"
 #include "content/common/notification_service.h"
 #include "googleurl/src/gurl.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "third_party/hunspell/google/bdict.h"
 #include "ui/base/l10n/l10n_util.h"
 #if defined(OS_MACOSX)
 #include "base/metrics/histogram.h"
 #endif
 
 namespace {
@@ skipping 53 matching lines @@
       tried_to_download_(false),
       use_platform_spellchecker_(false),
       request_context_getter_(request_context_getter) {
   DCHECK(observer_);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FilePath personal_file_directory;
   PathService::Get(chrome::DIR_USER_DATA, &personal_file_directory);
   custom_dictionary_file_ =
       personal_file_directory.Append(chrome::kCustomDictionaryFileName);
+
+  registrar_.Add(this, NotificationType::RENDERER_PROCESS_CREATED,
+                 NotificationService::AllSources());
 }
 
 SpellCheckHostImpl::~SpellCheckHostImpl() {
   if (file_ != base::kInvalidPlatformFileValue)
     base::ClosePlatformFile(file_);
 }
 
 void SpellCheckHostImpl::Initialize() {
   if (SpellCheckerPlatform::SpellCheckerAvailable() &&
       SpellCheckerPlatform::PlatformSupportsLanguage(language_)) {
@@ skipping 16 matching lines @@
       NewRunnableMethod(this,
                         &SpellCheckHostImpl::InitializeDictionaryLocation));
 }
 
 void SpellCheckHostImpl::UnsetObserver() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   observer_ = NULL;
   request_context_getter_ = NULL;
   fetcher_.reset();
+  registrar_.RemoveAll();
+}
+
+void SpellCheckHostImpl::InitForRenderer(RenderProcessHost* process) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  PrefService* prefs = process->profile()->GetPrefs();
+  IPC::PlatformFileForTransit file;
+
+  if (GetDictionaryFile() != base::kInvalidPlatformFileValue) {
+#if defined(OS_POSIX)
+    file = base::FileDescriptor(GetDictionaryFile(), false);
+#elif defined(OS_WIN)
+    ::DuplicateHandle(::GetCurrentProcess(),
+                      GetDictionaryFile(),
+                      process->GetHandle(),
+                      &file,
+                      0,
+                      false,
+                      DUPLICATE_SAME_ACCESS);
+#endif
+  }
+
+  process->Send(new SpellCheckMsg_Init(
+      file,
+      GetCustomWords(),
+      GetLanguage(),
+      prefs->GetBoolean(prefs::kEnableAutoSpellCorrect)));
 }
 
 void SpellCheckHostImpl::AddWord(const std::string& word) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   custom_words_.push_back(word);
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(this,
           &SpellCheckHostImpl::WriteWordToCustomDictionary, word));
-  NotificationService::current()->Notify(
-      NotificationType::SPELLCHECK_WORD_ADDED,
-      Source<SpellCheckHost>(this), NotificationService::NoDetails());
+
+  for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
+       !i.IsAtEnd(); i.Advance()) {
+    i.GetCurrentValue()->Send(new SpellCheckMsg_WordAdded(GetLastAddedFile()));
+  }
 }
 
 void SpellCheckHostImpl::InitializeDictionaryLocation() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // Initialize the BDICT path. This initialization should be in the FILE thread
   // because it checks if there is a "Dictionaries" directory and create it.
   if (bdict_file_path_.empty())
     bdict_file_path_ = GetFirstChoiceFilePath(language_);
 
@@ skipping 53 matching lines @@
 
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(this, &SpellCheckHostImpl::Initialize));
 }
 
 void SpellCheckHostImpl::InformObserverOfInitialization() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (observer_)
     observer_->SpellCheckHostInitialized();
+
+  for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
+       !i.IsAtEnd(); i.Advance()) {
+    InitForRenderer(i.GetCurrentValue());
+  }
 }
 
 void SpellCheckHostImpl::DownloadDictionary() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!request_context_getter_) {
     InitializeOnFileThread();
     return;
   }
 
@@ skipping 50 matching lines @@
     LOG(ERROR) << "Failure to download dictionary.";
     InitializeOnFileThread();
     return;
   }
 
   data_ = data;
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(this, &SpellCheckHostImpl::SaveDictionaryData));
 }
 
+void SpellCheckHostImpl::Observe(NotificationType type,
+                                 const NotificationSource& source,
+                                 const NotificationDetails& details) {
+  DCHECK(type == NotificationType::RENDERER_PROCESS_CREATED);
+  RenderProcessHost* process = Source<RenderProcessHost>(source).ptr();
+  InitForRenderer(process);
+}
+
 void SpellCheckHostImpl::SaveDictionaryData() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // To prevent corrupted dictionary data from causing a renderer crash, scan
   // the dictionary data and verify it is sane before save it to a file.
   if (!hunspell::BDict::Verify(data_.data(), data_.size())) {
     LOG(ERROR) << "Failure to verify the downloaded dictionary.";
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this,
                           &SpellCheckHostImpl::InformObserverOfInitialization));
@@ skipping 42 matching lines @@
   return custom_words_.back();
 }
 
 const std::string& SpellCheckHostImpl::GetLanguage() const {
   return language_;
 }
 
 bool SpellCheckHostImpl::IsUsingPlatformChecker() const {
   return use_platform_spellchecker_;
 }