Move initialization of ChromeURLRequestContexts to the IO thread.

chrome/browser/spellchecker.cc

 // Copyright (c) 2006-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/spellchecker.h"
 
 #include "app/l10n_util.h"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
@@ skipping 445 matching lines @@
           language + special_version_string[i].version + ".bdic";
       break;
     }
   }
 
   return dict_dir.AppendASCII(versioned_bdict_file_name);
 }
 
 SpellChecker::SpellChecker(const FilePath& dict_dir,
                            const std::string& language,
-                           URLRequestContext* request_context,
+                           URLRequestContextGetter* request_context_getter,
                            const FilePath& custom_dictionary_file_name)
     : given_dictionary_directory_(dict_dir),
       custom_dictionary_file_name_(custom_dictionary_file_name),
       tried_to_init_(false),
       language_(language),
       worker_loop_(NULL),
       tried_to_download_dictionary_file_(false),
       file_loop_(NULL),
-      url_request_context_(request_context),
+      request_context_getter_(request_context_getter),
       obtaining_dictionary_(false),
       auto_spell_correct_turned_on_(false),
       is_using_platform_spelling_engine_(false),
       fetcher_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
   if (SpellCheckerPlatform::SpellCheckerAvailable()) {
     SpellCheckerPlatform::Init();
     if (SpellCheckerPlatform::PlatformSupportsLanguage(language)) {
       // If we have reached here, then we know that the current platform
       // supports the given language and we will use it instead of hunspell.
@@ skipping 31 matching lines @@
     DCHECK(MessageLoop::current() == worker_loop_);
 }
 
 void SpellChecker::StartDictionaryDownload(const FilePath& file_name) {
   // 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(bdic_file_name_.ToWStringHack())));
   fetcher_.reset(new URLFetcher(url, URLFetcher::GET, this));
-  fetcher_->set_request_context(url_request_context_);
+  fetcher_->set_request_context(request_context_getter_);
   obtaining_dictionary_ = true;
   fetcher_->Start();
 }
 
 void SpellChecker::OnURLFetchComplete(const URLFetcher* source,
                                       const GURL& url,
                                       const URLRequestStatus& status,
                                       int response_code,
                                       const ResponseCookies& cookies,
                                       const std::string& data) {
@@ skipping 109 matching lines @@
     hunspell_->add(custom_words_.front().c_str());
     custom_words_.pop();
   }
 
   // Balances AddRef() in Initialize().
   Release();
 }
 
 void SpellChecker::DoDictionaryDownload() {
   // Download the dictionary file.
-  if (file_loop_ && url_request_context_) {
+  if (file_loop_ && request_context_getter_) {
     if (!tried_to_download_dictionary_file_) {
       FilePath dictionary_file_name_app = GetVersionedFileName(language_,
           given_dictionary_directory_);
       StartDictionaryDownload(dictionary_file_name_app);
       tried_to_download_dictionary_file_ = true;
     } else {
       // Don't try to download a dictionary more than once.
       tried_to_init_ = true;
     }
   } else {
@@ skipping 222 matching lines @@
 
   // Populate the vector of WideStrings.
   for (int i = 0; i < number_of_suggestions; i++) {
     if (i < kMaxSuggestions)
       optional_suggestions->push_back(UTF8ToUTF16(suggestions[i]));
     free(suggestions[i]);
   }
   if (suggestions != NULL)
     free(suggestions);
 }