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

chrome/browser/sync/glue/http_bridge.cc

 // Copyright (c) 2006-2008 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.
 
 #if defined(BROWSER_SYNC)
 
 #include "chrome/browser/sync/glue/http_bridge.h"
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/profile.h"
+#include "chrome/browser/chrome_thread.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_status.h"
 #include "webkit/glue/webkit_glue.h"
 
 namespace browser_sync {
@@ skipping 23 matching lines @@
     URLRequestContextGetter* baseline_context_getter) {
   DCHECK(baseline_context_getter != NULL);
   request_context_getter_ =
       new HttpBridge::RequestContextGetter(baseline_context_getter);
   request_context_getter_->AddRef();
 }
 
 HttpBridgeFactory::~HttpBridgeFactory() {
   if (request_context_getter_) {
     // Clean up request context getter on IO thread.
-    ChromeThread::GetMessageLoop(ChromeThread::IO)->ReleaseSoon(FROM_HERE,
-        request_context_getter_);
+    bool posted = ChromeThread::ReleaseSoon(
+        ChromeThread::IO, FROM_HERE, request_context_getter_);
+    DCHECK(posted);
     request_context_getter_ = NULL;
   }
 }
 
 sync_api::HttpPostProviderInterface* HttpBridgeFactory::Create() {
-  HttpBridge* http = new HttpBridge(request_context_getter_,
-      ChromeThread::GetMessageLoop(ChromeThread::IO));
+  HttpBridge* http = new HttpBridge(request_context_getter_);
   http->AddRef();
   return http;
 }
 
 void HttpBridgeFactory::Destroy(sync_api::HttpPostProviderInterface* http) {
   static_cast<HttpBridge*>(http)->Release();
 }
 
 HttpBridge::RequestContext::RequestContext(URLRequestContext* baseline_context)
     : baseline_context_(baseline_context) {
@@ skipping 27 matching lines @@
 
   // We default to the browser's user agent. This can (and should) be overridden
   // with set_user_agent.
   user_agent_ = webkit_glue::GetUserAgent(GURL());
 }
 
 HttpBridge::RequestContext::~RequestContext() {
   delete http_transaction_factory_;
 }
 
-HttpBridge::HttpBridge(HttpBridge::RequestContextGetter* context_getter,
-                       MessageLoop* io_loop)
+HttpBridge::HttpBridge(HttpBridge::RequestContextGetter* context_getter)
     : context_getter_for_request_(context_getter),
       url_poster_(NULL),
       created_on_loop_(MessageLoop::current()),
-      io_loop_(io_loop),
       request_completed_(false),
       request_succeeded_(false),
       http_response_code_(-1),
-      http_post_completed_(false, false),
-      use_io_loop_for_testing_(false) {
+      http_post_completed_(false, false) {
   context_getter_for_request_->AddRef();
 }
 
 HttpBridge::~HttpBridge() {
-  io_loop_->ReleaseSoon(FROM_HERE, context_getter_for_request_);
+  bool posted = ChromeThread::ReleaseSoon(
+      ChromeThread::IO, FROM_HERE, context_getter_for_request_);
+  DCHECK(posted);
 }
 
 void HttpBridge::SetUserAgent(const char* user_agent) {
   DCHECK_EQ(MessageLoop::current(), created_on_loop_);
   DCHECK(!request_completed_);
   context_getter_for_request_->set_user_agent(user_agent);
 }
 
 void HttpBridge::SetExtraRequestHeaders(const char * headers) {
   DCHECK(extra_headers_.empty())
@@ skipping 31 matching lines @@
     request_content_.assign(content, content_length);
   }
 }
 
 bool HttpBridge::MakeSynchronousPost(int* os_error_code, int* response_code) {
   DCHECK_EQ(MessageLoop::current(), created_on_loop_);
   DCHECK(!request_completed_);
   DCHECK(url_for_request_.is_valid()) << "Invalid URL for request";
   DCHECK(!content_type_.empty()) << "Payload not set";
 
-  io_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-                                &HttpBridge::CallMakeAsynchronousPost));
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(this, &HttpBridge::CallMakeAsynchronousPost));
 
   if (!http_post_completed_.Wait())  // Block until network request completes.
     NOTREACHED();                    // See OnURLFetchComplete.
 
   DCHECK(request_completed_);
   *os_error_code = os_error_code_;
   *response_code = http_response_code_;
   return request_succeeded_;
 }
 
 void HttpBridge::MakeAsynchronousPost() {
-  DCHECK_EQ(MessageLoop::current(), io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   DCHECK(!request_completed_);
 
   url_poster_ = new URLFetcher(url_for_request_, URLFetcher::POST, this);
   url_poster_->set_request_context(context_getter_for_request_);
   url_poster_->set_upload_data(content_type_, request_content_);
   url_poster_->set_extra_request_headers(extra_headers_);
-
-  if (use_io_loop_for_testing_)
-    url_poster_->set_io_loop(io_loop_);
-
   url_poster_->Start();
 }
 
 int HttpBridge::GetResponseContentLength() const {
   DCHECK_EQ(MessageLoop::current(), created_on_loop_);
   DCHECK(request_completed_);
   return response_content_.size();
 }
 
 const char* HttpBridge::GetResponseContent() const {
   DCHECK_EQ(MessageLoop::current(), created_on_loop_);
   DCHECK(request_completed_);
   return response_content_.data();
 }
 
 void HttpBridge::OnURLFetchComplete(const URLFetcher *source, const GURL &url,
                                     const URLRequestStatus &status,
                                     int response_code,
                                     const ResponseCookies &cookies,
                                     const std::string &data) {
-  DCHECK_EQ(MessageLoop::current(), io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   request_completed_ = true;
   request_succeeded_ = (URLRequestStatus::SUCCESS == status.status());
   http_response_code_ = response_code;
   os_error_code_ = status.os_error();
 
   response_content_ = data;
 
-  // End of the line for url_poster_. It lives only on the io_loop.
+  // End of the line for url_poster_. It lives only on the IO loop.
   // We defer deletion because we're inside a callback from a component of the
   // URLFetcher, so it seems most natural / "polite" to let the stack unwind.
-  io_loop_->DeleteSoon(FROM_HERE, url_poster_);
+  MessageLoop::current()->DeleteSoon(FROM_HERE, url_poster_);
   url_poster_ = NULL;
 
   // Wake the blocked syncer thread in MakeSynchronousPost.
   // WARNING: DONT DO ANYTHING AFTER THIS CALL! |this| may be deleted!
   http_post_completed_.Signal();
 }
 
 }  // namespace browser_sync
 
 #endif  // defined(BROWSER_SYNC)