Move initialization of ChromeURLRequestContexts to the IO thread.

chrome/browser/automation/automation_provider.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/automation/automation_provider.h"
 
 #include <set>
 
 #include "app/l10n_util.h"
 #include "app/message_box_flags.h"
@@ skipping 22 matching lines @@
 #include "chrome/browser/download/download_manager.h"
 #include "chrome/browser/download/download_shelf.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/extensions/extension_message_service.h"
 #include "chrome/browser/find_bar.h"
 #include "chrome/browser/find_bar_controller.h"
 #include "chrome/browser/find_notification_details.h"
 #include "chrome/browser/location_bar.h"
 #include "chrome/browser/login_prompt.h"
+#include "chrome/browser/net/url_request_context_getter.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/profile_manager.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/ssl/ssl_manager.h"
 #include "chrome/browser/ssl/ssl_blocking_page.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
 #include "chrome/common/automation_constants.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 915 matching lines @@
 
   return browser;
 }
 
 void AutomationProvider::GetCookies(const GURL& url, int handle,
                                     int* value_size,
                                     std::string* value) {
   *value_size = -1;
   if (url.is_valid() && tab_tracker_->ContainsHandle(handle)) {
     NavigationController* tab = tab_tracker_->GetResource(handle);
-    *value =
-        tab->profile()->GetRequestContext()->cookie_store()->GetCookies(url);
+
+    // Since we are running on the UI thread don't call GetURLRequestContext().
+    net::CookieStore* cookie_store =
+        tab->profile()->GetRequestContext()->GetCookieStore();
+
+    *value = cookie_store->GetCookies(url);
     *value_size = static_cast<int>(value->size());
   }
 }
 
 void AutomationProvider::SetCookie(const GURL& url,
                                    const std::string value,
                                    int handle,
                                    int* response_value) {
   *response_value = -1;
 
   if (url.is_valid() && tab_tracker_->ContainsHandle(handle)) {
     NavigationController* tab = tab_tracker_->GetResource(handle);
-    URLRequestContext* context = tab->profile()->GetRequestContext();
-    if (context->cookie_store()->SetCookie(url, value))
+
+    // Since we are running on the UI thread don't call GetURLRequestContext().
+    scoped_refptr<net::CookieStore> cookie_store =
+        tab->profile()->GetRequestContext()->GetCookieStore();
+
+    if (cookie_store->SetCookie(url, value))
       *response_value = 1;
   }
 }
 
 void AutomationProvider::GetTabURL(int handle, bool* success, GURL* url) {
   *success = false;
   if (tab_tracker_->ContainsHandle(handle)) {
     NavigationController* tab = tab_tracker_->GetResource(handle);
     // Return what the user would see in the location bar.
     *url = tab->GetActiveEntry()->virtual_url();
@@ skipping 170 matching lines @@
   if (reply_message_) {
     AutomationMsg_InspectElement::WriteReplyParams(reply_message_,
                                                    num_resources);
     Send(reply_message_);
     reply_message_ = NULL;
   }
 }
 
 class SetProxyConfigTask : public Task {
  public:
-  explicit SetProxyConfigTask(net::ProxyService* proxy_service,
-                              const std::string& new_proxy_config)
-      : proxy_service_(proxy_service), proxy_config_(new_proxy_config) {}
+  SetProxyConfigTask(URLRequestContextGetter* request_context_getter,
+                     const std::string& new_proxy_config)
+      : request_context_getter_(request_context_getter), proxy_config_(new_proxy_config) {}
   virtual void Run() {
     // First, deserialize the JSON string. If this fails, log and bail.
     JSONStringValueSerializer deserializer(proxy_config_);
     std::string error_message;
     scoped_ptr<Value> root(deserializer.Deserialize(&error_message));
     if (!root.get() || root->GetType() != Value::TYPE_DICTIONARY) {
       DLOG(WARNING) << "Received bad JSON string for ProxyConfig: "
                     << error_message;
       return;
     }
 
     scoped_ptr<DictionaryValue> dict(
         static_cast<DictionaryValue*>(root.release()));
     // Now put together a proxy configuration from the deserialized string.
     net::ProxyConfig pc;
     PopulateProxyConfig(*dict.get(), &pc);
 
-    DCHECK(proxy_service_);
+    net::ProxyService* proxy_service =
+        request_context_getter_->GetURLRequestContext()->proxy_service();
+    DCHECK(proxy_service);
     scoped_ptr<net::ProxyConfigService> proxy_config_service(
         new net::ProxyConfigServiceFixed(pc));
-    proxy_service_->ResetConfigService(proxy_config_service.release());
+    proxy_service->ResetConfigService(proxy_config_service.release());
   }
 
   void PopulateProxyConfig(const DictionaryValue& dict, net::ProxyConfig* pc) {
     DCHECK(pc);
     bool no_proxy = false;
     if (dict.GetBoolean(automation::kJSONProxyNoProxy, &no_proxy)) {
       // Make no changes to the ProxyConfig.
       return;
     }
     bool auto_config;
     if (dict.GetBoolean(automation::kJSONProxyAutoconfig, &auto_config)) {
       pc->auto_detect = true;
     }
     std::string pac_url;
     if (dict.GetString(automation::kJSONProxyPacUrl, &pac_url)) {
       pc->pac_url = GURL(pac_url);
     }
     std::string proxy_bypass_list;
     if (dict.GetString(automation::kJSONProxyBypassList, &proxy_bypass_list)) {
       pc->ParseNoProxyList(proxy_bypass_list);
     }
     std::string proxy_server;
     if (dict.GetString(automation::kJSONProxyServer, &proxy_server)) {
       pc->proxy_rules.ParseFromString(proxy_server);
     }
   }
 
  private:
-  net::ProxyService* proxy_service_;
+  scoped_refptr<URLRequestContextGetter> request_context_getter_;
   std::string proxy_config_;
 };
 
 
 void AutomationProvider::SetProxyConfig(const std::string& new_proxy_config) {
-  URLRequestContext* context = Profile::GetDefaultRequestContext();
-  if (!context) {
+  URLRequestContextGetter* context_getter = Profile::GetDefaultRequestContext();
+  if (!context_getter) {
     FilePath user_data_dir;
     PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
     ProfileManager* profile_manager = g_browser_process->profile_manager();
     DCHECK(profile_manager);
     Profile* profile = profile_manager->GetDefaultProfile(user_data_dir);
     DCHECK(profile);
-    context = profile->GetRequestContext();
+    context_getter = profile->GetRequestContext();
   }
-  DCHECK(context);
-  // Every URLRequestContext should have a proxy service.
-  net::ProxyService* proxy_service = context->proxy_service();
-  DCHECK(proxy_service);
+  DCHECK(context_getter);
 
   g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
-      new SetProxyConfigTask(proxy_service, new_proxy_config));
+      new SetProxyConfigTask(context_getter, new_proxy_config));
 }
 
 void AutomationProvider::GetDownloadDirectory(
     int handle, FilePath* download_directory) {
   DLOG(INFO) << "Handling download directory request";
   if (tab_tracker_->ContainsHandle(handle)) {
     NavigationController* tab = tab_tracker_->GetResource(handle);
     DownloadManager* dlm = tab->profile()->GetDownloadManager();
     DCHECK(dlm);
     *download_directory = dlm->download_path();
@@ skipping 881 matching lines @@
                                       reply_message);
 
     profile_->GetExtensionsService()->LoadExtension(extension_dir);
     profile_->GetUserScriptMaster()->AddWatchedPath(extension_dir);
   } else {
     AutomationMsg_LoadExpandedExtension::WriteReplyParams(
         reply_message, AUTOMATION_MSG_EXTENSION_INSTALL_FAILED);
     Send(reply_message);
   }
 }