Simplify threading in browser thread by making only ChromeThread deal with di...

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"
@@ skipping 47 matching lines @@
   void StartURLRequest();
   void CancelURLRequest();
   void OnCompletedURLRequest(const URLRequestStatus& status);
 
   URLFetcher* fetcher_;              // Corresponding fetcher object
   GURL original_url_;                // The URL we were asked to fetch
   GURL url_;                         // The URL we eventually wound up at
   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<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
@@ skipping 40 matching lines @@
 
 URLFetcher::Core::Core(URLFetcher* fetcher,
                        const GURL& original_url,
                        RequestType request_type,
                        URLFetcher::Delegate* d)
     : fetcher_(fetcher),
       original_url_(original_url),
       request_type_(request_type),
       delegate_(d),
       delegate_loop_(MessageLoop::current()),
-      io_loop_(ChromeThread::GetMessageLoop(ChromeThread::IO)),
       request_(NULL),
       load_flags_(net::LOAD_NORMAL),
       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_getter_) << "We need an URLRequestContextGetter!";
-  io_loop_->PostDelayedTask(FROM_HERE, NewRunnableMethod(
-          this, &Core::StartURLRequest),
-      protect_entry_->UpdateBackoff(URLFetcherProtectEntry::SEND));
+  DCHECK(request_context_getter_) << "We need an URLRequestContext!";
+  ChromeThread::PostDelayedTask(
+      ChromeThread::IO, 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));
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(this, &Core::CancelURLRequest));
 }
 
 void URLFetcher::Core::OnResponseStarted(URLRequest* request) {
   DCHECK(request == request_);
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   if (request_->status().is_success()) {
     response_code_ = request_->GetResponseCode();
     response_headers_ = request_->response_headers();
   }
 
   int bytes_read = 0;
   // Some servers may treat HEAD requests as GET requests.  To free up the
   // network connection as soon as possible, signal that the request has
   // completed immediately, without trying to read any data back (all we care
   // about is the response code and headers, which we already have).
   if (request_->status().is_success() && (request_type_ != HEAD))
     request_->Read(buffer_, kBufferSize, &bytes_read);
   OnReadCompleted(request_, bytes_read);
 }
 
 void URLFetcher::Core::OnReadCompleted(URLRequest* request, int bytes_read) {
   DCHECK(request == request_);
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   url_ = request->url();
 
   do {
     if (!request_->status().is_success() || bytes_read <= 0)
       break;
     data_.append(buffer_->data(), bytes_read);
   } while (request_->Read(buffer_, kBufferSize, &bytes_read));
 
   if (request_->status().is_success())
     request_->GetResponseCookies(&cookies_);
 
   // See comments re: HEAD requests in OnResponseStarted().
   if (!request_->status().is_io_pending() || (request_type_ == HEAD)) {
     delegate_loop_->PostTask(FROM_HERE, NewRunnableMethod(
         this, &Core::OnCompletedURLRequest, request_->status()));
     delete request_;
     request_ = NULL;
   }
 }
 
 void URLFetcher::Core::StartURLRequest() {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   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_getter_->GetURLRequestContext());
 
@@ skipping 22 matching lines @@
       NOTREACHED();
   }
 
   if (!extra_request_headers_.empty())
     request_->SetExtraRequestHeaders(extra_request_headers_);
 
   request_->Start();
 }
 
 void URLFetcher::Core::CancelURLRequest() {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   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_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 =
         protect_entry_->UpdateBackoff(URLFetcherProtectEntry::FAILURE);
     ++num_retries_;
     // Restarts the request if we still need to notify the delegate.
     if (delegate_) {
       if (num_retries_ <= protect_entry_->max_retries()) {
-        io_loop_->PostDelayedTask(FROM_HERE, NewRunnableMethod(
-            this, &Core::StartURLRequest), wait);
+        ChromeThread::PostDelayedTask(
+            ChromeThread::IO, FROM_HERE,
+            NewRunnableMethod(this, &Core::StartURLRequest), wait);
       } else {
         delegate_->OnURLFetchComplete(fetcher_, url_, status, response_code_,
                                       cookies_, data_);
       }
     }
   } else {
     protect_entry_->UpdateBackoff(URLFetcherProtectEntry::SUCCESS);
     if (delegate_)
       delegate_->OnURLFetchComplete(fetcher_, url_, status, response_code_,
                                     cookies_, data_);
   }
 }
 
-void URLFetcher::set_io_loop(MessageLoop* io_loop) {
-  core_->io_loop_ = io_loop;
-}
-
 void URLFetcher::set_upload_data(const std::string& upload_content_type,
                      const std::string& upload_content) {
   core_->upload_content_type_ = upload_content_type;
   core_->upload_content_ = upload_content;
 }
 
 void URLFetcher::set_load_flags(int load_flags) {
   core_->load_flags_ = load_flags;
 }
 
@@ skipping 19 matching lines @@
   core_->Start();
 }
 
 const GURL& URLFetcher::url() const {
   return core_->url_;
 }
 
 URLFetcher::Delegate* URLFetcher::delegate() const {
   return core_->delegate();
 }