Use TaskScheduler instead of WorkerPool in multi_threaded_cert_verifier.cc.

net/url_request/url_request_unittest.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 <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "build/build_config.h"
@@ skipping 25 matching lines @@
 #include "base/power_monitor/power_monitor_source.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
+#include "base/test/scoped_async_task_scheduler.h"
 #include "base/test/scoped_task_scheduler.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "net/base/chunked_upload_data_stream.h"
 #include "net/base/directory_listing.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/load_flags.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/load_timing_info_test_util.h"
 #include "net/base/net_errors.h"
@@ skipping 708 matching lines @@
  private:
   bool on_ssl_certificate_error_called_ = false;
   SSLInfo ssl_info_;
 };
 
 }  // namespace
 
 // Inherit PlatformTest since we require the autorelease pool on Mac OS X.
 class URLRequestTest : public PlatformTest {
  public:
-  URLRequestTest() : default_context_(true) {
+  URLRequestTest()
+      : scoped_task_scheduler_(base::MessageLoop::current()),
+        default_context_(true) {
     default_context_.set_network_delegate(&default_network_delegate_);
     default_context_.set_net_log(&net_log_);
     job_factory_impl_ = new URLRequestJobFactoryImpl();
     job_factory_.reset(job_factory_impl_);
   }
 
   ~URLRequestTest() override {
     // URLRequestJobs may post clean-up tasks on destruction.
     base::RunLoop().RunUntilIdle();
   }
@@ skipping 27 matching lines @@
   // Adds the TestJobInterceptor to the default context.
   TestJobInterceptor* AddTestInterceptor() {
     TestJobInterceptor* protocol_handler_ = new TestJobInterceptor();
     job_factory_impl_->SetProtocolHandler("http", nullptr);
     job_factory_impl_->SetProtocolHandler("http",
                                           base::WrapUnique(protocol_handler_));
     return protocol_handler_;
   }
 
  protected:
+  // Required by ChannelIDService and MultiThreadedCertVerifier.
+  base::test::ScopedTaskScheduler scoped_task_scheduler_;
   TestNetLog net_log_;
   TestNetworkDelegate default_network_delegate_;  // Must outlive URLRequest.
   URLRequestJobFactoryImpl* job_factory_impl_;
   std::unique_ptr<URLRequestJobFactory> job_factory_;
   TestURLRequestContext default_context_;
 };
 
 TEST_F(URLRequestTest, AboutBlankTest) {
   TestDelegate d;
   {
@@ skipping 2605 matching lines @@
   const bool online_rev_checking_;
   const bool rev_checking_required_local_anchors_;
   const bool token_binding_enabled_;
   uint16_t min_version_;
 };
 
 // TODO(svaldez): Update tests to use EmbeddedTestServer.
 #if !defined(OS_IOS)
 class TokenBindingURLRequestTest : public URLRequestTestHTTP {
  public:
-  TokenBindingURLRequestTest()
-      : scoped_task_scheduler_(base::MessageLoop::current()) {}
+  TokenBindingURLRequestTest() = default;
 
   void SetUp() override {
     default_context_.set_ssl_config_service(
         new TestSSLConfigService(false, false, false, true));
     channel_id_service_.reset(
         new ChannelIDService(new DefaultChannelIDStore(NULL)));
     default_context_.set_channel_id_service(channel_id_service_.get());
     URLRequestTestHTTP::SetUp();
   }
 
  protected:
-  // Required by ChannelIDService.
-  base::test::ScopedTaskScheduler scoped_task_scheduler_;
   std::unique_ptr<ChannelIDService> channel_id_service_;
 };
 
 TEST_F(TokenBindingURLRequestTest, TokenBindingTest) {
   SpawnedTestServer::SSLOptions ssl_options;
   ssl_options.supported_token_binding_params.push_back(TB_PARAM_ECDSAP256);
   SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
                                       ssl_options,
                                       base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
@@ skipping 5058 matching lines @@
       origin_server()->GetURL("/path/to/file.html"),
       origin_server()->GetURL("/"));
 
   VerifyReferrerAfterRedirect(URLRequest::NEVER_CLEAR_REFERRER,
                               origin_server()->GetURL("/path/to/file.html"),
                               origin_server()->GetURL("/path/to/file.html"));
 }
 
 class HTTPSRequestTest : public testing::Test {
  public:
-  HTTPSRequestTest()
-      : scoped_task_scheduler_(base::MessageLoop::current()),
-        default_context_(true) {
+  HTTPSRequestTest() : default_context_(true) {
     default_context_.set_network_delegate(&default_network_delegate_);
     default_context_.Init();
   }
   ~HTTPSRequestTest() override {}
 
  protected:
-  // Required by ChannelIDService.
-  base::test::ScopedTaskScheduler scoped_task_scheduler_;
+  // Required by ChannelIDService and MultiThreadedCertVerifier. Needs to be a
+  // ScopedAsyncTaskScheduler rather than a ScopedTaskScheduler because the task
+  // posted by MultiThreadedCertVerifier synchronously waits for a task running
+  // on the main thread (OCSPRequestSession::Wait).
+  base::test::ScopedAsyncTaskScheduler scoped_async_task_scheduler_;
+
+ protected:
   TestNetworkDelegate default_network_delegate_;  // Must outlive URLRequest.
   TestURLRequestContext default_context_;
 };
 
 TEST_F(HTTPSRequestTest, HTTPSGetTest) {
   EmbeddedTestServer test_server(net::EmbeddedTestServer::TYPE_HTTPS);
   test_server.AddDefaultHandlers(
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
   ASSERT_TRUE(test_server.Start());
 
@@ skipping 2179 matching lines @@
   AddTestInterceptor()->set_main_intercept_job(std::move(job));
 
   req->Start();
   req->Cancel();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(ERR_ABORTED, d.request_status());
   EXPECT_EQ(0, d.received_redirect_count());
 }
 
 }  // namespace net