More aggressive IO asserts in content_browsertests.

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 <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 34 matching lines @@
 
 EmbeddedTestServer::EmbeddedTestServer(Type type)
     : is_using_ssl_(type == TYPE_HTTPS),
       connection_listener_(nullptr),
       port_(0),
       cert_(CERT_OK),
       weak_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (is_using_ssl_) {
+    base::ThreadRestrictions::ScopedAllowIO allow_io_for_importing_test_cert;
     TestRootCerts* root_certs = TestRootCerts::GetInstance();
     base::FilePath certs_dir(GetTestCertsDirectory());
     root_certs->AddFromFile(certs_dir.AppendASCII("root_ca_cert.pem"));
   }
 }
 
 EmbeddedTestServer::~EmbeddedTestServer() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (Started() && !ShutdownAndWaitUntilComplete()) {
     LOG(ERROR) << "EmbeddedTestServer failed to shut down.";
   }
+
+  {
+    // Thread::Join induced by test code should cause an assert.
+    base::ThreadRestrictions::ScopedAllowIO allow_io_for_thread_join;
+
+    io_thread_.reset();
+  }
 }
 
 void EmbeddedTestServer::SetConnectionListener(
     EmbeddedTestServerConnectionListener* listener) {
   DCHECK(!Started());
   connection_listener_ = listener;
 }
 
 bool EmbeddedTestServer::Start() {
   bool success = InitializeAndListen();
@@ skipping 34 matching lines @@
   port_ = local_endpoint_.port();
 
   listen_socket_->DetachFromThread();
 
   if (is_using_ssl_)
     InitializeSSLServerContext();
   return true;
 }
 
 void EmbeddedTestServer::InitializeSSLServerContext() {
+  base::ThreadRestrictions::ScopedAllowIO allow_io_for_ssl_initialization;
   base::FilePath certs_dir(GetTestCertsDirectory());
   std::string cert_name = GetCertificateName();
 
   base::FilePath key_path = certs_dir.AppendASCII(cert_name);
   std::string key_string;
   CHECK(base::ReadFileToString(key_path, &key_string));
   std::vector<std::string> headers;
   headers.push_back("PRIVATE KEY");
   PEMTokenizer pem_tokenizer(key_string, headers);
   pem_tokenizer.GetNext();
@@ skipping 120 matching lines @@
     case CERT_BAD_VALIDITY:
       return "bad_validity.pem";
   }
 
   return "ok_cert.pem";
 }
 
 scoped_refptr<X509Certificate> EmbeddedTestServer::GetCertificate() const {
   DCHECK(is_using_ssl_);
   base::FilePath certs_dir(GetTestCertsDirectory());
+
+  base::ThreadRestrictions::ScopedAllowIO allow_io_for_importing_test_cert;
   return ImportCertFromFile(certs_dir, GetCertificateName());
 }
 
 void EmbeddedTestServer::ServeFilesFromDirectory(
     const base::FilePath& directory) {
   RegisterRequestHandler(base::Bind(&HandleFileRequest, directory));
 }
 
 void EmbeddedTestServer::ServeFilesFromSourceDirectory(
     const std::string& relative) {
@@ skipping 181 matching lines @@
                                                    run_loop.QuitClosure())) {
     return false;
   }
   run_loop.Run();
 
   return true;
 }
 
 }  // namespace test_server
 }  // namespace net