Do not spawn a thread in browser/interactive ui tests before spawning sandbox host process

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());
 }
 
+void HttpListenSocket::DetachFromThread() {
+  thread_checker_.DetachFromThread();
+}
+
 EmbeddedTestServer::EmbeddedTestServer()
     : port_(-1),
       weak_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 EmbeddedTestServer::~EmbeddedTestServer() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (Started() && !ShutdownAndWaitUntilComplete()) {
     LOG(ERROR) << "EmbeddedTestServer failed to shut down.";
   }
 }
 
 bool EmbeddedTestServer::InitializeAndWaitUntilReady() {
-  base::Thread::Options thread_options;
-  thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
-  io_thread_.reset(new base::Thread("EmbeddedTestServer io thread"));
-  CHECK(io_thread_->StartWithOptions(thread_options));
-
+  StartThread();
   DCHECK(thread_checker_.CalledOnValidThread());
-
   if (!PostTaskToIOThreadAndWait(base::Bind(
           &EmbeddedTestServer::InitializeOnIOThread, base::Unretained(this)))) {
     return false;
   }
+  return Started() && base_url_.is_valid();
+}
 
-  return Started() && base_url_.is_valid();
+void EmbeddedTestServer::StopThread() {
+  io_thread_->Stop();
+  io_thread_.reset();
+  thread_checker_.DetachFromThread();
+  listen_socket_->DetachFromThread();
+}
+
+void EmbeddedTestServer::RestartThreadAndListen() {
+  StartThread();
+  if (!PostTaskToIOThreadAndWait(base::Bind(
+          &EmbeddedTestServer::ListenOnIOThread, base::Unretained(this)))) {

[satorux1, 2013/11/27 03:27:17]

did you meant to add LOG(ERROR) here? Otherwise the if block doesn't mean
anything.

[oshima, 2013/11/27 07:41:54]

changed to CHECK. This should never fail in tests (and this failure leads to
test failure anyway)

+    return;
+  }
 }
 
 bool EmbeddedTestServer::ShutdownAndWaitUntilComplete() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   return PostTaskToIOThreadAndWait(base::Bind(
       &EmbeddedTestServer::ShutdownOnIOThread, base::Unretained(this)));
 }
 
+void EmbeddedTestServer::StartThread() {
+  DCHECK(!io_thread_.get());
+  base::Thread::Options thread_options;
+  thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
+  io_thread_.reset(new base::Thread("EmbeddedTestServer io thread"));
+  CHECK(io_thread_->StartWithOptions(thread_options));
+}
+
 void EmbeddedTestServer::InitializeOnIOThread() {
   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::ListenOnIOThread() {
+  DCHECK(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
+  DCHECK(Started());
+  listen_socket_->Listen();
+}
+
 void EmbeddedTestServer::ShutdownOnIOThread() {
   DCHECK(io_thread_->message_loop_proxy()->BelongsToCurrentThread());
 
   listen_socket_.reset();
   STLDeleteContainerPairSecondPointers(connections_.begin(),
                                        connections_.end());
   connections_.clear();
 }
 
 void EmbeddedTestServer::HandleRequest(HttpConnection* connection,
@@ skipping 113 matching lines @@
           FROM_HERE, closure, run_loop.QuitClosure())) {
     return false;
   }
   run_loop.Run();
 
   return true;
 }
 
 }  // namespace test_server
 }  // namespace net