SpellCheck refactoring: Moved user custom dictionary for spell check to SpellCheckProfile.

chrome/browser/spellchecker/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/spellchecker/spellcheck_host_impl.h"
 
 #include <set>
 
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 76 matching lines @@
     : profile_(profile),
       language_(language),
       file_(base::kInvalidPlatformFileValue),
       tried_to_download_(false),
       use_platform_spellchecker_(false),
       request_context_getter_(request_context_getter),
       metrics_(metrics) {
   DCHECK(profile_);
   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, content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  NotificationService::AllSources());
 }
 
 SpellCheckHostImpl::~SpellCheckHostImpl() {
   if (file_ != base::kInvalidPlatformFileValue)
     base::ClosePlatformFile(file_);
 }
 
 void SpellCheckHostImpl::Initialize() {
   if (SpellCheckerPlatform::SpellCheckerAvailable() &&
       SpellCheckerPlatform::PlatformSupportsLanguage(language_)) {
 #if defined(OS_MACOSX)
     RecordSpellCheckStats(true, language_);
 #endif
     use_platform_spellchecker_ = true;
     SpellCheckerPlatform::SetLanguage(language_);
     MessageLoop::current()->PostTask(FROM_HERE,
         NewRunnableMethod(this,
             &SpellCheckHostImpl::InformProfileOfInitialization));
     return;
   }
 
 #if defined(OS_MACOSX)
   RecordSpellCheckStats(false, language_);
 #endif
 
+  if (profile_)
+    profile_->LoadCustomDictionary();

[Hironori Bono, 2011/10/13 09:29:59]

It seems this code start loading a custom-dictionary file in a FILE thread.
Also, the following PostTask() initializes a dictionary file in a FILE thread,
and sends IPC messages (consisting of its handle and the list of custom words)
to renderer processes in a UI thread. It may be safer to have a method that
verifies we finish loading the custom-dictionary file to prevent sending IPC
messages before we finish loading the custom-dictionary file?

   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(this,
                         &SpellCheckHostImpl::InitializeDictionaryLocation));
 }
 
 void SpellCheckHostImpl::UnsetProfile() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   profile_ = NULL;
   request_context_getter_ = NULL;
@@ skipping 27 matching lines @@
       profile_ ? profile_->GetCustomWords() : CustomWordList(),
       GetLanguage(),
       prefs->GetBoolean(prefs::kEnableAutoSpellCorrect)));
 }
 
 void SpellCheckHostImpl::AddWord(const std::string& word) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (profile_)
     profile_->CustomWordAddedLocally(word);
-  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-      NewRunnableMethod(this,
-          &SpellCheckHostImpl::WriteWordToCustomDictionary, word));
+
   for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     i.GetCurrentValue()->Send(new SpellCheckMsg_WordAdded(word));
   }
 }
 
 void SpellCheckHostImpl::InitializeDictionaryLocation() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // Initialize the BDICT path. This initialization should be in the FILE thread
@@ skipping 40 matching lines @@
       request_context_getter_) {
     // We download from the ui thread because we need to know that
     // |request_context_getter_| is still valid before initiating the download.
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this, &SpellCheckHostImpl::DownloadDictionary));
     return;
   }
 
   request_context_getter_ = NULL;
 
-  scoped_ptr<CustomWordList> custom_words(new CustomWordList());
-  if (file_ != base::kInvalidPlatformFileValue) {
-    // Load custom dictionary.
-    std::string contents;
-    file_util::ReadFileToString(custom_dictionary_file_, &contents);
-    CustomWordList list_of_words;
-    base::SplitString(contents, '\n', &list_of_words);
-    for (size_t i = 0; i < list_of_words.size(); ++i)
-      custom_words->push_back(list_of_words[i]);
-  }
-
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(
           this,
-          &SpellCheckHostImpl::InformProfileOfInitializationWithCustomWords,
-          custom_words.release()));
+          &SpellCheckHostImpl::InformProfileOfInitialization));
 }
 
 void SpellCheckHostImpl::InitializeOnFileThread() {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(this, &SpellCheckHostImpl::Initialize));
 }
 
 void SpellCheckHostImpl::InformProfileOfInitialization() {
-  InformProfileOfInitializationWithCustomWords(NULL);
-}
-
-void SpellCheckHostImpl::InformProfileOfInitializationWithCustomWords(
-    CustomWordList* custom_words) {
-  // Non-null |custom_words| should be given only if the profile is available
-  // for simplifying the life-cycle management of the word list.
-  DCHECK(profile_ || !custom_words);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (profile_)
-    profile_->SpellCheckHostInitialized(custom_words);
+    profile_->SpellCheckHostInitialized();
 
   for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     RenderProcessHost* process = i.GetCurrentValue();
     if (process)
       InitForRenderer(process);
   }
 }
 
 void SpellCheckHostImpl::DownloadDictionary() {
@@ skipping 14 matching lines @@
   }
   GURL url = GURL(std::string(kDownloadServerUrl) +
                   StringToLowerASCII(bdict_file));
   fetcher_.reset(new URLFetcher(url, URLFetcher::GET, this));
   fetcher_->set_request_context(request_context_getter_);
   tried_to_download_ = true;
   fetcher_->Start();
   request_context_getter_ = NULL;
 }
 
-void SpellCheckHostImpl::WriteWordToCustomDictionary(const std::string& word) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-
-  // Stored in UTF-8.
-  std::string word_to_add(word + "\n");
-  FILE* f = file_util::OpenFile(custom_dictionary_file_, "a+");
-  if (f)
-    fputs(word_to_add.c_str(), f);
-  file_util::CloseFile(f);
-}
-
 void SpellCheckHostImpl::OnURLFetchComplete(const URLFetcher* source,
                                             const GURL& url,
                                             const net::URLRequestStatus& status,
                                             int response_code,
                                             const net::ResponseCookies& cookies,
                                             const std::string& data) {
   DCHECK(source);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   fetcher_.reset();
 
@@ skipping 100 matching lines @@
   return file_;
 }
 
 const std::string& SpellCheckHostImpl::GetLanguage() const {
   return language_;
 }
 
 bool SpellCheckHostImpl::IsUsingPlatformChecker() const {
   return use_platform_spellchecker_;
 }