Always destruct url request context getter on io thread....

chrome/browser/spellcheck_host.cc

 // Copyright (c) 2009 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.h"
 
 #include <fcntl.h>
 
 #include "app/l10n_util.h"
 #include "base/file_util.h"
@@ skipping 151 matching lines @@
 
 void SpellCheckHost::Initialize() {
   ChromeThread::PostTask(ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(this, &SpellCheckHost::InitializeDictionaryLocation));
 }
 
 void SpellCheckHost::UnsetObserver() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
   observer_ = NULL;
+  request_context_getter_ = NULL;
+  fetcher_.reset();
 }
 
 void SpellCheckHost::AddWord(const std::string& word) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
   custom_words_.push_back(word);
   ChromeThread::PostTask(ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(this,
           &SpellCheckHost::WriteWordToCustomDictionary, word));
   NotificationService::current()->Notify(
@@ skipping 21 matching lines @@
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
 
   if (!observer_)
     return;
 
   file_ = base::CreatePlatformFile(bdict_file_path_,
       base::PLATFORM_FILE_READ | base::PLATFORM_FILE_OPEN,
       NULL);
 
   // File didn't exist. Download it.
-  if (file_ == base::kInvalidPlatformFileValue && !tried_to_download_) {
-    DownloadDictionary();
+  if (file_ == base::kInvalidPlatformFileValue && !tried_to_download_ &&
+      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.
+    ChromeThread::PostTask(ChromeThread::UI, FROM_HERE,
+        NewRunnableMethod(this, &SpellCheckHost::DownloadDictionary));
     return;
   }
 
+  request_context_getter_ = NULL;
+
   if (file_ != base::kInvalidPlatformFileValue) {
     // Load custom dictionary.
     std::string contents;
     file_util::ReadFileToString(custom_dictionary_file_, &contents);
     std::vector<std::string> list_of_words;
     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]);
   }
 
   ChromeThread::PostTask(ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(this,
           &SpellCheckHost::InformObserverOfInitialization));
 }
 
+void SpellCheckHost::InitializeOnFileThread() {
+  DCHECK(!ChromeThread::CurrentlyOn(ChromeThread::FILE));
+
+  ChromeThread::PostTask(ChromeThread::FILE, FROM_HERE,
+      NewRunnableMethod(this, &SpellCheckHost::Initialize));
+}
+
 void SpellCheckHost::InformObserverOfInitialization() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
   if (observer_)
     observer_->SpellCheckHostInitialized();
 }
 
 void SpellCheckHost::DownloadDictionary() {
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+
+  if (!request_context_getter_) {
+    InitializeOnFileThread();
+    return;
+  }
 
   // Determine URL of file to download.
   static const char kDownloadServerUrl[] =
       "http://cache.pack.google.com/edgedl/chrome/dict/";
   GURL url = GURL(std::string(kDownloadServerUrl) + WideToUTF8(
       l10n_util::ToLower(bdict_file_path_.BaseName().ToWStringHack())));
   fetcher_.reset(new URLFetcher(url, URLFetcher::GET, this));
-  fetcher_->set_request_context(request_context_getter_.get());
+  fetcher_->set_request_context(request_context_getter_);
   tried_to_download_ = true;
   fetcher_->Start();
+  request_context_getter_ = NULL;
 }
 
 void SpellCheckHost::WriteWordToCustomDictionary(const std::string& word) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
 
   // Stored in UTF-8.
   std::string word_to_add(word + "\n");
   FILE* f = file_util::OpenFile(custom_dictionary_file_, "a+");
   if (f != NULL)
     fputs(word_to_add.c_str(), f);
   file_util::CloseFile(f);
 }
 
 void SpellCheckHost::OnURLFetchComplete(const URLFetcher* source,
                                         const GURL& url,
                                         const URLRequestStatus& status,
                                         int response_code,
                                         const ResponseCookies& cookies,
                                         const std::string& data) {
   DCHECK(source);
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+  fetcher_.reset();
 
   if ((response_code / 100) != 2) {
     // Initialize will not try to download the file a second time.
     LOG(ERROR) << "Failure to download dictionary.";
-    Initialize();
+    InitializeOnFileThread();
     return;
   }
 
   // Basic sanity check on the dictionary.
   // There's the small chance that we might see a 200 status code for a body
   // that represents some form of failure.
   if (data.size() < 4 || data[0] != 'B' || data[1] != 'D' || data[2] != 'i' ||
       data[3] != 'c') {
     LOG(ERROR) << "Failure to download dictionary.";
-    Initialize();
+    InitializeOnFileThread();
     return;
   }
 
+  data_ = data;
+  ChromeThread::PostTask(ChromeThread::FILE, FROM_HERE,
+      NewRunnableMethod(this, &SpellCheckHost::SaveDictionaryData));
+}
+
+void SpellCheckHost::SaveDictionaryData() {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
+
   size_t bytes_written =
-      file_util::WriteFile(bdict_file_path_, data.data(), data.length());
-  if (bytes_written != data.length()) {
+      file_util::WriteFile(bdict_file_path_, data_.data(), data_.length());
+  if (bytes_written != data_.length()) {
     bool success = false;
 #if defined(OS_WIN)
     bdict_file_path_ = GetFallbackFilePath(bdict_file_path_);
     bytes_written =
         file_util::WriteFile(GetFallbackFilePath(bdict_file_path_),
-                                                 data.data(), data.length());
-    if (bytes_written == data.length())
+                                                 data_.data(), data_.length());
+    if (bytes_written == data_.length())
       success = true;
 #endif
+    data_.clear();
 
     if (!success) {
       LOG(ERROR) << "Failure to save dictionary.";
+      file_util::Delete(bdict_file_path_, false);
       // To avoid trying to load a partially saved dictionary, shortcut the
       // Initialize() call.
       ChromeThread::PostTask(ChromeThread::UI, FROM_HERE,
           NewRunnableMethod(this,
               &SpellCheckHost::InformObserverOfInitialization));
       return;
     }
   }
 
+  data_.clear();
   Initialize();
 }