Instantiate ScopedTaskEnvironment in net unittests.

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 26 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_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"
 #include "net/base/net_module.h"
@@ skipping 715 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()
-      : scoped_task_scheduler_(base::MessageLoop::current()),
-        default_context_(true) {
+  URLRequestTest() : 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 26 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_;
   }
 
- private:
-  base::test::ScopedTaskScheduler scoped_task_scheduler_;
-
  protected:
   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 7958 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_;
   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 548 matching lines @@
     // With a newline at the end which makes the split think that there are
     // three lines.
 
     EXPECT_EQ(1, d.response_started_count());
     AssertTwoDistinctSessionsInserted(d.data_received());
   }
 }
 
 class HTTPSFallbackTest : public testing::Test {
  public:
-  HTTPSFallbackTest()
-      : scoped_task_scheduler_(base::MessageLoop::current()), context_(true) {
+  HTTPSFallbackTest() : context_(true) {
     ssl_config_service_ = new TestSSLConfigService(
         true /* check for EV */, false /* online revocation checking */,
         false /* require rev. checking for local anchors */,
         false /* token binding enabled */);
     context_.set_ssl_config_service(ssl_config_service_.get());
   }
   ~HTTPSFallbackTest() override {}
 
  protected:
   TestSSLConfigService* ssl_config_service() {
@@ skipping 24 matching lines @@
     EXPECT_EQ(version, SSLConnectionStatusToVersion(
                            request_->ssl_info().connection_status));
   }
 
   void ExpectFailure(int error) {
     EXPECT_EQ(1, delegate_.response_started_count());
     EXPECT_EQ(error, delegate_.request_status());
   }
 
  private:
-  // Required by ChannelIDService.
-  base::test::ScopedTaskScheduler scoped_task_scheduler_;
   TestDelegate delegate_;
   TestURLRequestContext context_;
   std::unique_ptr<URLRequest> request_;
   scoped_refptr<TestSSLConfigService> ssl_config_service_;
 };
 
 // Tests the TLS 1.0 fallback doesn't happen.
 TEST_F(HTTPSFallbackTest, TLSv1NoFallback) {
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_OK);
@@ skipping 34 matching lines @@
   ssl_options.tls_intolerant =
       SpawnedTestServer::SSLOptions::TLS_INTOLERANT_TLS1_3;
   ssl_config_service()->set_max_version(SSL_PROTOCOL_VERSION_TLS1_2);
 
   ASSERT_NO_FATAL_FAILURE(DoFallbackTest(ssl_options));
   ExpectConnection(SSL_CONNECTION_VERSION_TLS1_2);
 }
 
 class HTTPSSessionTest : public testing::Test {
  public:
-  HTTPSSessionTest()
-      : scoped_task_scheduler_(base::MessageLoop::current()),
-        default_context_(true) {
+  HTTPSSessionTest() : default_context_(true) {
     cert_verifier_.set_default_result(OK);
 
     default_context_.set_network_delegate(&default_network_delegate_);
     default_context_.set_cert_verifier(&cert_verifier_);
     default_context_.Init();
   }
   ~HTTPSSessionTest() override {}
 
  protected:
-  // Required by ChannelIDService.
-  base::test::ScopedTaskScheduler scoped_task_scheduler_;
   MockCertVerifier cert_verifier_;
   TestNetworkDelegate default_network_delegate_;  // Must outlive URLRequest.
   TestURLRequestContext default_context_;
 };
 
 // Tests that session resumption is not attempted if an invalid certificate
 // is presented.
 TEST_F(HTTPSSessionTest, DontResumeSessionsForInvalidCertificates) {
   SpawnedTestServer::SSLOptions ssl_options;
   ssl_options.record_resume = true;
@@ skipping 1557 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