Third patch in getting rid of caching MessageLoop pointers and always using C...

chrome/browser/net/chrome_url_request_context.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/net/chrome_url_request_context.h"
 
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/privacy_blacklist/blacklist.h"
@@ skipping 100 matching lines @@
     const CommandLine& command_line) {
   // The linux gconf-based proxy settings getter relies on being initialized
   // from the UI thread.
   CheckCurrentlyOnMainThread();
 
   scoped_ptr<net::ProxyConfig> proxy_config_from_cmd_line(
       CreateProxyConfig(command_line));
 
   if (!proxy_config_from_cmd_line.get()) {
     // Use system settings.
+    // TODO(port): the IO and FILE message loops are only used by Linux.  Can
+    // that code be moved to chrome/browser instead of being in net, so that it
+    // can use ChromeThread instead of raw MessageLoop pointers? See bug 25354.
     return net::ProxyService::CreateSystemProxyConfigService(
         g_browser_process->io_thread()->message_loop(),
         g_browser_process->file_thread()->message_loop());
   }
 
   // Otherwise use the fixed settings from the command line.
   return new net::ProxyConfigServiceFixed(*proxy_config_from_cmd_line.get());
 }
 
 // Create a proxy service according to the options on command line.
@@ skipping 529 matching lines @@
                                    const NotificationDetails& details) {
   CheckCurrentlyOnMainThread();
 
   if (NotificationType::PREF_CHANGED == type) {
     std::wstring* pref_name_in = Details<std::wstring>(details).ptr();
     PrefService* prefs = Source<PrefService>(source).ptr();
     DCHECK(pref_name_in && prefs);
     if (*pref_name_in == prefs::kAcceptLanguages) {
       std::string accept_language =
           WideToASCII(prefs->GetString(prefs::kAcceptLanguages));
-      g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
+      ChromeThread::PostTask(
+          ChromeThread::IO, FROM_HERE,
           NewRunnableMethod(
               this,
               &ChromeURLRequestContextGetter::OnAcceptLanguageChange,
               accept_language));
     } else if (*pref_name_in == prefs::kCookieBehavior) {
       net::CookiePolicy::Type policy_type = net::CookiePolicy::FromInt(
           prefs_->GetInteger(prefs::kCookieBehavior));
-      g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
+      ChromeThread::PostTask(
+          ChromeThread::IO, FROM_HERE,
           NewRunnableMethod(
               this,
               &ChromeURLRequestContextGetter::OnCookiePolicyChange,
               policy_type));
     } else if (*pref_name_in == prefs::kDefaultCharset) {
       std::string default_charset =
           WideToASCII(prefs->GetString(prefs::kDefaultCharset));
-      g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
+      ChromeThread::PostTask(
+          ChromeThread::IO, FROM_HERE,
           NewRunnableMethod(
               this,
               &ChromeURLRequestContextGetter::OnDefaultCharsetChange,
               default_charset));
     }
   } else {
     NOTREACHED();
   }
 }
 
@@ skipping 165 matching lines @@
   if (ChromeThread::CurrentlyOn(ChromeThread::IO))
     return GetURLRequestContext()->cookie_store();
 
   // If we aren't running on the IO thread, we cannot call
   // GetURLRequestContext(). Instead we will post a task to the IO loop
   // and wait for it to complete.
 
   base::WaitableEvent completion(false, false);
   net::CookieStore* result = NULL;
 
-  g_browser_process->io_thread()->message_loop()->PostTask(
-      FROM_HERE,
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
       NewRunnableMethod(this,
           &ChromeURLRequestContextGetter::GetCookieStoreAsyncHelper,
           &completion,
           &result));
 
   completion.Wait();
   DCHECK(result);
   return result;
 }
 
 void ChromeURLRequestContextGetter::GetCookieStoreAsyncHelper(
     base::WaitableEvent* completion,
     net::CookieStore** result) {
   // Note that CookieStore is refcounted, yet we do not add a reference.
   *result = GetURLRequestContext()->cookie_store();
   completion->Signal();
 }