Editing the custom spelling dictionary

chrome/browser/spellchecker/spellcheck_service.cc

 // Copyright (c) 2012 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/spellchecker/spellcheck_service.h"
 
 #include "base/platform_file.h"
 #include "base/string_split.h"
 #include "base/synchronization/waitable_event.h"
 #include "chrome/browser/api/prefs/pref_member.h"
@@ skipping 32 matching lines @@
   pref_change_registrar_.Add(prefs::kEnableSpellCheck, this);
   pref_change_registrar_.Add(prefs::kEnableAutoSpellCorrect, this);
 
   hunspell_dictionary_.reset(new SpellcheckHunspellDictionary(
       profile, prefs->GetString(prefs::kSpellCheckDictionary),
       profile->GetRequestContext(), this));
 
   hunspell_dictionary_->Load();
 
   custom_dictionary_.reset(new SpellcheckCustomDictionary(profile_));
+  custom_dictionary_->AddObserver(this);
   custom_dictionary_->Load();
 
   registrar_.Add(weak_ptr_factory_.GetWeakPtr(),
                  content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  content::NotificationService::AllSources());
 
 }
 
 SpellcheckService::~SpellcheckService() {
   // Remove pref observers
@@ skipping 60 matching lines @@
     SpellcheckService::EventType status_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   if (!g_status_event)
     return false;
   g_status_type = status_type;
   g_status_event->Signal();
   return true;
 }
 
-// static
-void SpellcheckService::AttachStatusEvent(base::WaitableEvent* status_event) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  g_status_event = status_event;
-}
-
-// static
-SpellcheckService::EventType SpellcheckService::WaitStatusEvent() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (g_status_event)
-    g_status_event->Wait();
-  return g_status_type;
-}
-
 void SpellcheckService::StartRecordingMetrics(bool spellcheck_enabled) {
   metrics_.reset(new SpellCheckHostMetrics());
   metrics_->RecordEnabledStats(spellcheck_enabled);
 }
 
+void SpellcheckService::InitForAllRenderers() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  for (content::RenderProcessHost::iterator i(
+          content::RenderProcessHost::AllHostsIterator());
+       !i.IsAtEnd(); i.Advance()) {
+    content::RenderProcessHost* process = i.GetCurrentValue();
+    if (process)
+      InitForRenderer(process);
+  }
+}
+
 void SpellcheckService::InitForRenderer(content::RenderProcessHost* process) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   Profile* profile = Profile::FromBrowserContext(process->GetBrowserContext());
   if (SpellcheckServiceFactory::GetForProfile(profile) != this)
     return;
 
   PrefService* prefs = profile->GetPrefs();
   IPC::PlatformFileForTransit file = IPC::InvalidPlatformFileForTransit();
 
   if (hunspell_dictionary_->GetDictionaryFile() !=
       base::kInvalidPlatformFileValue) {
 #if defined(OS_POSIX)
     file = base::FileDescriptor(hunspell_dictionary_->GetDictionaryFile(),
                                 false);
 #elif defined(OS_WIN)
     BOOL ok = ::DuplicateHandle(::GetCurrentProcess(),
                                 hunspell_dictionary_->GetDictionaryFile(),
                                 process->GetHandle(),
                                 &file,
                                 0,
                                 false,
                                 DUPLICATE_SAME_ACCESS);
     DCHECK(ok) << ::GetLastError();
 #endif
   }
 
-  WordList custom_words = GetCustomDictionary()->GetCustomWords();
-
   process->Send(new SpellCheckMsg_Init(
       file,
-      custom_words,
+      custom_dictionary_->GetWords(),
       hunspell_dictionary_->GetLanguage(),
       prefs->GetBoolean(prefs::kEnableAutoSpellCorrect)));
 }
 
+SpellCheckHostMetrics* SpellcheckService::GetMetrics() const {
+  return metrics_.get();
+}
+
+SpellcheckCustomDictionary* SpellcheckService::GetCustomDictionary() {
+  return custom_dictionary_.get();
+}
+
 void SpellcheckService::Observe(int type,
                                 const content::NotificationSource& source,
                                 const content::NotificationDetails& details) {
   DCHECK(type == content::NOTIFICATION_RENDERER_PROCESS_CREATED);
   content::RenderProcessHost* process =
       content::Source<content::RenderProcessHost>(source).ptr();
   InitForRenderer(process);
 }
 
 void SpellcheckService::OnPreferenceChanged(PrefServiceBase* prefs,
                                             const std::string& pref_name_in) {
   DCHECK(prefs);
   if (pref_name_in == prefs::kSpellCheckDictionary ||
       pref_name_in == prefs::kEnableSpellCheck) {
-    InformProfileOfInitializationWithCustomWords(NULL);
+    InitForAllRenderers();
   } else if (pref_name_in == prefs::kEnableAutoSpellCorrect) {
     bool enabled = prefs->GetBoolean(prefs::kEnableAutoSpellCorrect);
     for (content::RenderProcessHost::iterator i(
              content::RenderProcessHost::AllHostsIterator());
          !i.IsAtEnd(); i.Advance()) {
       content::RenderProcessHost* process = i.GetCurrentValue();
       process->Send(new SpellCheckMsg_EnableAutoSpellCorrect(enabled));
     }
   }
 }
 
-SpellCheckHostMetrics* SpellcheckService::GetMetrics() const {
-  return metrics_.get();
+void SpellcheckService::OnCustomDictionaryLoaded() {
+  InitForAllRenderers();
 }
 
-SpellcheckCustomDictionary* SpellcheckService::GetCustomDictionary() {
-  return custom_dictionary_.get();
+void SpellcheckService::OnCustomDictionaryWordAdded(const std::string& word) {
 }
 
-// TODO(rlp): rename to something more logical.
-void SpellcheckService::InformProfileOfInitializationWithCustomWords(
-    WordList* custom_words) {
+void SpellcheckService::OnCustomDictionaryWordRemoved(const std::string& word) {
+}
+
+// static
+void SpellcheckService::AttachStatusEvent(base::WaitableEvent* status_event) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (custom_words) {
-    GetCustomDictionary()->SetCustomWordList(custom_words);
-  }
+  g_status_event = status_event;
+}
 
-  for (content::RenderProcessHost::iterator i(
-          content::RenderProcessHost::AllHostsIterator());
-       !i.IsAtEnd(); i.Advance()) {
-    content::RenderProcessHost* process = i.GetCurrentValue();
-    if (process)
-      InitForRenderer(process);
-  }
+// static
+SpellcheckService::EventType SpellcheckService::WaitStatusEvent() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (g_status_event)
+    g_status_event->Wait();
+  return g_status_type;
 }