Break dependencies preventing move of test_server down to net.

chrome/browser/google_apis/test_server/http_server.cc

 // Copyright (c) 2012 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/google_apis/test_server/http_server.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
+#include "base/synchronization/waitable_event.h"
 #include "chrome/browser/google_apis/test_server/http_connection.h"
 #include "chrome/browser/google_apis/test_server/http_request.h"
 #include "chrome/browser/google_apis/test_server/http_response.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/test/test_utils.h"
 #include "net/tools/fetch/http_listen_socket.h"
 
 namespace google_apis {
 namespace test_server {
 
-using content::BrowserThread;
-
 namespace {
 
 const int kPort = 8040;
 const char kIp[] = "127.0.0.1";
 const int kRetries = 10;
 
 // Callback to handle requests with default predefined response for requests
 // matching the address |url|.
 scoped_ptr<HttpResponse> HandleDefaultRequest(const GURL& url,
                                               const HttpResponse& response,
                                               const HttpRequest& request) {
   const GURL request_url = url.Resolve(request.relative_url);
   if (url.path() != request_url.path())
     return scoped_ptr<HttpResponse>(NULL);
   return scoped_ptr<HttpResponse>(new HttpResponse(response));
 }
 
 }  // namespace
 
 HttpListenSocket::HttpListenSocket(const SocketDescriptor socket_descriptor,
                                    net::StreamListenSocket::Delegate* delegate)
     : net::TCPListenSocket(socket_descriptor, delegate) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
 void HttpListenSocket::Listen() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(CalledOnValidThread());
   net::TCPListenSocket::Listen();
 }
 
 HttpListenSocket::~HttpListenSocket() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
-HttpServer::HttpServer()
-    : port_(-1),
+HttpServer::HttpServer(
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_thread)
+    : io_thread_(io_thread),
+      port_(-1),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(io_thread_);
 }
 
 HttpServer::~HttpServer() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 bool HttpServer::InitializeAndWaitUntilReady() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(CalledOnValidThread());
 
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&HttpServer::InitializeOnIOThread,
-                 base::Unretained(this)));
+  base::WaitableEvent event(false, false);
+  if (!io_thread_->PostTask(FROM_HERE,
+                            base::Bind(&HttpServer::InitializeOnIOThread,
+                                       base::Unretained(this), &event))) {
+    return false;
+  }
 
-  // Wait for the task completion.
-  content::RunAllPendingInMessageLoop(BrowserThread::IO);
+  event.Wait();
 
   return Started();
 }
 
-void HttpServer::ShutdownAndWaitUntilComplete() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+bool HttpServer::ShutdownAndWaitUntilComplete() {
+  DCHECK(CalledOnValidThread());
 
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&HttpServer::ShutdownOnIOThread,
-                 base::Unretained(this)));
+  base::WaitableEvent event(false, false);
+  if (!io_thread_->PostTask(FROM_HERE,
+                            base::Bind(&HttpServer::ShutdownOnIOThread,
+                                       base::Unretained(this), &event))) {
+    return false;
+  }
 
-  // Wait for the task completion.
-  content::RunAllPendingInMessageLoop(BrowserThread::IO);
+  event.Wait();
+
+  return true;
 }
 
-void HttpServer::InitializeOnIOThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+void HttpServer::InitializeOnIOThread(base::WaitableEvent* event) {
+  DCHECK(io_thread_->BelongsToCurrentThread());
   DCHECK(!Started());
 
   int retries_left = kRetries + 1;
   int try_port = kPort;
 
   while (retries_left > 0) {
     SocketDescriptor socket_descriptor = net::TCPListenSocket::CreateAndBind(
         kIp,
         try_port);
     if (socket_descriptor != net::TCPListenSocket::kInvalidSocket) {
       listen_socket_ = new HttpListenSocket(socket_descriptor, this);
       listen_socket_->Listen();
       base_url_ = GURL(base::StringPrintf("http://%s:%d", kIp, try_port));
       port_ = try_port;
       break;
     }
     retries_left--;
     try_port++;
   }
+
+  event->Signal();
 }
 
-void HttpServer::ShutdownOnIOThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+void HttpServer::ShutdownOnIOThread(base::WaitableEvent* event) {
+  DCHECK(io_thread_->BelongsToCurrentThread());
 
   listen_socket_ = NULL;  // Release the listen socket.
   STLDeleteContainerPairSecondPointers(connections_.begin(),
                                        connections_.end());
   connections_.clear();
+
+  event->Signal();
 }
 
 void HttpServer::HandleRequest(HttpConnection* connection,
                                scoped_ptr<HttpRequest> request) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(io_thread_->BelongsToCurrentThread());
 
   for (size_t i = 0; i < request_handlers_.size(); ++i) {
     scoped_ptr<HttpResponse> response =
         request_handlers_[i].Run(*request.get());
     if (response.get()) {
       connection->SendResponse(response.Pass());
       return;
     }
   }
 
@@ skipping 15 matching lines @@
   return base_url_.Resolve(relative_url);
 }
 
 void HttpServer::RegisterRequestHandler(
     const HandleRequestCallback& callback) {
   request_handlers_.push_back(callback);
 }
 
 void HttpServer::DidAccept(net::StreamListenSocket* server,
                            net::StreamListenSocket* connection) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(io_thread_->BelongsToCurrentThread());
 
   HttpConnection* http_connection = new HttpConnection(
       connection,
       base::Bind(&HttpServer::HandleRequest, weak_factory_.GetWeakPtr()));
   connections_[connection] = http_connection;
 }
 
 void HttpServer::DidRead(net::StreamListenSocket* connection,
                          const char* data,
                          int length) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(io_thread_->BelongsToCurrentThread());
 
   HttpConnection* http_connection = FindConnection(connection);
   if (http_connection == NULL) {
     LOG(WARNING) << "Unknown connection.";
     return;
   }
   http_connection->ReceiveData(std::string(data, length));
 }
 
 void HttpServer::DidClose(net::StreamListenSocket* connection) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(io_thread_->BelongsToCurrentThread());
 
   HttpConnection* http_connection = FindConnection(connection);
   if (http_connection == NULL) {
     LOG(WARNING) << "Unknown connection.";
     return;
   }
   delete http_connection;
   connections_.erase(connection);
 }
 
 HttpConnection* HttpServer::FindConnection(
     net::StreamListenSocket* socket) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(io_thread_->BelongsToCurrentThread());
 
   std::map<net::StreamListenSocket*, HttpConnection*>::iterator it =
       connections_.find(socket);
   if (it == connections_.end()) {
     return NULL;
   }
   return it->second;
 }
 
 }  // namespace test_server
 }  // namespace google_apis