Move initialization of ChromeURLRequestContexts to the IO thread.

chrome/browser/net/url_fetcher.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/url_fetcher.h"
 
 #include "base/compiler_specific.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_thread.h"
+#include "chrome/browser/net/url_request_context_getter.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/load_flags.h"
 #include "net/base/io_buffer.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 
 static const int kBufferSize = 4096;
 
 bool URLFetcher::g_interception_enabled = false;
@@ skipping 42 matching lines @@
   RequestType request_type_;         // What type of request is this?
   URLFetcher::Delegate* delegate_;   // Object to notify on completion
   MessageLoop* delegate_loop_;       // Message loop of the creating thread
   MessageLoop* io_loop_;             // Message loop of the IO thread
   URLRequest* request_;              // The actual request this wraps
   int load_flags_;                   // Flags for the load operation
   int response_code_;                // HTTP status code for the request
   std::string data_;                 // Results of the request
   scoped_refptr<net::IOBuffer> buffer_;
                                      // Read buffer
-  scoped_refptr<URLRequestContext> request_context_;
+  scoped_refptr<URLRequestContextGetter> request_context_getter_;
                                      // Cookie/cache info for the request
   ResponseCookies cookies_;          // Response cookies
   std::string extra_request_headers_;// Extra headers for the request, if any
   scoped_refptr<net::HttpResponseHeaders> response_headers_;
 
   std::string upload_content_;       // HTTP POST payload
   std::string upload_content_type_;  // MIME type of POST payload
 
   // The overload protection entry for this URL.  This is used to
   // incrementally back off how rapidly we'll send requests to a particular
@@ skipping 46 matching lines @@
       response_code_(-1),
       buffer_(new net::IOBuffer(kBufferSize)),
       protect_entry_(URLFetcherProtectManager::GetInstance()->Register(
           original_url_.host())),
       num_retries_(0) {
 }
 
 void URLFetcher::Core::Start() {
   DCHECK(delegate_loop_);
   DCHECK(io_loop_);
-  DCHECK(request_context_) << "We need an URLRequestContext!";
+  DCHECK(request_context_getter_) << "We need an URLRequestContextGetter!";
   io_loop_->PostDelayedTask(FROM_HERE, NewRunnableMethod(
           this, &Core::StartURLRequest),
       protect_entry_->UpdateBackoff(URLFetcherProtectEntry::SEND));
 }
 
 void URLFetcher::Core::Stop() {
   DCHECK_EQ(MessageLoop::current(), delegate_loop_);
   delegate_ = NULL;
   io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
       this, &Core::CancelURLRequest));
@@ skipping 44 matching lines @@
 void URLFetcher::Core::StartURLRequest() {
   DCHECK(MessageLoop::current() == io_loop_);
   DCHECK(!request_);
 
   request_ = new URLRequest(original_url_, this);
   int flags = request_->load_flags() | load_flags_;
   if (!g_interception_enabled) {
     flags = flags | net::LOAD_DISABLE_INTERCEPT;
   }
   request_->set_load_flags(flags);
-  request_->set_context(request_context_.get());
+  request_->set_context(request_context_getter_->GetURLRequestContext());
 
   switch (request_type_) {
     case GET:
       break;
 
     case POST:
       DCHECK(!upload_content_.empty());
       DCHECK(!upload_content_type_.empty());
 
       request_->set_method("POST");
@@ skipping 23 matching lines @@
   DCHECK(MessageLoop::current() == io_loop_);
   if (request_) {
     request_->Cancel();
     delete request_;
     request_ = NULL;
   }
   // Release the reference to the request context. There could be multiple
   // references to URLFetcher::Core at this point so it may take a while to
   // delete the object, but we cannot delay the destruction of the request
   // context.
-  request_context_ = NULL;
+  request_context_getter_ = NULL;
 }
 
 void URLFetcher::Core::OnCompletedURLRequest(const URLRequestStatus& status) {
   DCHECK(MessageLoop::current() == delegate_loop_);
 
   // Checks the response from server.
   if (response_code_ >= 500) {
     // When encountering a server error, we will send the request again
     // after backoff time.
     const int64 wait =
@@ skipping 33 matching lines @@
 
 int URLFetcher::load_flags() const {
   return core_->load_flags_;
 }
 
 void URLFetcher::set_extra_request_headers(
     const std::string& extra_request_headers) {
   core_->extra_request_headers_ = extra_request_headers;
 }
 
-void URLFetcher::set_request_context(URLRequestContext* request_context) {
-  core_->request_context_ = request_context;
+void URLFetcher::set_request_context(
+    URLRequestContextGetter* request_context_getter) {
+  core_->request_context_getter_ = request_context_getter;
 }
 
 net::HttpResponseHeaders* URLFetcher::response_headers() const {
   return core_->response_headers_;
 }
 
 void URLFetcher::Start() {
   core_->Start();
 }
 
 const GURL& URLFetcher::url() const {
   return core_->url_;
 }
 
 URLFetcher::Delegate* URLFetcher::delegate() const {
   return core_->delegate();
 }