GTTF: Make EmbeddedTestServer always use its own thread for IO

net/test/embedded_test_server/embedded_test_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 "net/test/embedded_test_server/embedded_test_server.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 81 matching lines @@
 
 void HttpListenSocket::Listen() {
   DCHECK(thread_checker_.CalledOnValidThread());
   TCPListenSocket::Listen();
 }
 
 HttpListenSocket::~HttpListenSocket() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
-EmbeddedTestServer::EmbeddedTestServer(
-    const scoped_refptr<base::SingleThreadTaskRunner>& io_thread)
-    : io_thread_(io_thread),
+EmbeddedTestServer::EmbeddedTestServer()
+    : io_thread_("EmbeddedTestServer io thread"),
       port_(-1),
       weak_factory_(this) {
-  DCHECK(io_thread_.get());
   DCHECK(thread_checker_.CalledOnValidThread());
+
+  base::Thread::Options thread_options;
+  thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
+  CHECK(io_thread_.StartWithOptions(thread_options));
 }
 
 EmbeddedTestServer::~EmbeddedTestServer() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (Started() && !ShutdownAndWaitUntilComplete()) {
     LOG(ERROR) << "EmbeddedTestServer failed to shut down.";
   }
 }
 
 bool EmbeddedTestServer::InitializeAndWaitUntilReady() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!PostTaskToIOThreadAndWait(base::Bind(
           &EmbeddedTestServer::InitializeOnIOThread, base::Unretained(this)))) {
     return false;
   }
 
   return Started() && base_url_.is_valid();
 }
 
 bool EmbeddedTestServer::ShutdownAndWaitUntilComplete() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   return PostTaskToIOThreadAndWait(base::Bind(
       &EmbeddedTestServer::ShutdownOnIOThread, base::Unretained(this)));
 }
 
 void EmbeddedTestServer::InitializeOnIOThread() {
-  DCHECK(io_thread_->BelongsToCurrentThread());
+  DCHECK(io_thread_.message_loop_proxy()->BelongsToCurrentThread());
   DCHECK(!Started());
 
   SocketDescriptor socket_descriptor =
       TCPListenSocket::CreateAndBindAnyPort("127.0.0.1", &port_);
   if (socket_descriptor == kInvalidSocket)
     return;
 
   listen_socket_.reset(new HttpListenSocket(socket_descriptor, this));
   listen_socket_->Listen();
 
   IPEndPoint address;
   int result = listen_socket_->GetLocalAddress(&address);
   if (result == OK) {
     base_url_ = GURL(std::string("http://") + address.ToString());
   } else {
     LOG(ERROR) << "GetLocalAddress failed: " << ErrorToString(result);
   }
 }
 
 void EmbeddedTestServer::ShutdownOnIOThread() {
-  DCHECK(io_thread_->BelongsToCurrentThread());
+  DCHECK(io_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   listen_socket_.reset();
   STLDeleteContainerPairSecondPointers(connections_.begin(),
                                        connections_.end());
   connections_.clear();
 }
 
 void EmbeddedTestServer::HandleRequest(HttpConnection* connection,
                                scoped_ptr<HttpRequest> request) {
-  DCHECK(io_thread_->BelongsToCurrentThread());
+  DCHECK(io_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   bool request_handled = false;
 
   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());
       request_handled = true;
       break;
@@ skipping 28 matching lines @@
 }
 
 void EmbeddedTestServer::RegisterRequestHandler(
     const HandleRequestCallback& callback) {
   request_handlers_.push_back(callback);
 }
 
 void EmbeddedTestServer::DidAccept(
     StreamListenSocket* server,
     scoped_ptr<StreamListenSocket> connection) {
-  DCHECK(io_thread_->BelongsToCurrentThread());
+  DCHECK(io_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   HttpConnection* http_connection = new HttpConnection(
       connection.Pass(),
       base::Bind(&EmbeddedTestServer::HandleRequest,
                  weak_factory_.GetWeakPtr()));
   // TODO(szym): Make HttpConnection the StreamListenSocket delegate.
   connections_[http_connection->socket_.get()] = http_connection;
 }
 
 void EmbeddedTestServer::DidRead(StreamListenSocket* connection,
                          const char* data,
                          int length) {
-  DCHECK(io_thread_->BelongsToCurrentThread());
+  DCHECK(io_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   HttpConnection* http_connection = FindConnection(connection);
   if (http_connection == NULL) {
     LOG(WARNING) << "Unknown connection.";
     return;
   }
   http_connection->ReceiveData(std::string(data, length));
 }
 
 void EmbeddedTestServer::DidClose(StreamListenSocket* connection) {
-  DCHECK(io_thread_->BelongsToCurrentThread());
+  DCHECK(io_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   HttpConnection* http_connection = FindConnection(connection);
   if (http_connection == NULL) {
     LOG(WARNING) << "Unknown connection.";
     return;
   }
   delete http_connection;
   connections_.erase(connection);
 }
 
 HttpConnection* EmbeddedTestServer::FindConnection(
     StreamListenSocket* socket) {
-  DCHECK(io_thread_->BelongsToCurrentThread());
+  DCHECK(io_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   std::map<StreamListenSocket*, HttpConnection*>::iterator it =
       connections_.find(socket);
   if (it == connections_.end()) {
     return NULL;
   }
   return it->second;
 }
 
 bool EmbeddedTestServer::PostTaskToIOThreadAndWait(
     const base::Closure& closure) {
   // Note that PostTaskAndReply below requires base::MessageLoopProxy::current()
   // to return a loop for posting the reply task. However, in order to make
   // EmbeddedTestServer universally usable, it needs to cope with the situation
   // where it's running on a thread on which a message loop is not (yet)
   // available or as has been destroyed already.
   //
   // To handle this situation, create temporary message loop to support the
   // PostTaskAndReply operation if the current thread as no message loop.
   scoped_ptr<base::MessageLoop> temporary_loop;
   if (!base::MessageLoop::current())
     temporary_loop.reset(new base::MessageLoop());
 
   base::RunLoop run_loop;
-  if (!io_thread_->PostTaskAndReply(FROM_HERE, closure, run_loop.QuitClosure()))
+  if (!io_thread_.message_loop_proxy()->PostTaskAndReply(
+          FROM_HERE, closure, run_loop.QuitClosure())) {
     return false;
+  }
   run_loop.Run();
 
   return true;
 }
 
 }  // namespace test_server
 }  // namespace net