Instantiate ScopedTaskEnvironment in net unittests.

net/url_request/url_request_simple_job_unittest.cc

 // Copyright 2014 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/url_request/url_request_simple_job.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
-#include "base/test/scoped_task_scheduler.h"
+#include "base/task_scheduler/task_scheduler.h"
 #include "net/base/request_priority.h"
 #include "net/test/gtest_util.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_job_factory.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 76 matching lines @@
   }
 
   ~SimpleJobProtocolHandler() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SimpleJobProtocolHandler);
 };
 
 class URLRequestSimpleJobTest : public ::testing::Test {
  public:
-  URLRequestSimpleJobTest()
-      : context_(true), scoped_task_scheduler_(base::MessageLoop::current()) {
+  URLRequestSimpleJobTest() : context_(true) {
     job_factory_.SetProtocolHandler(
         "data", base::MakeUnique<SimpleJobProtocolHandler>());
     context_.set_job_factory(&job_factory_);
     context_.Init();
 
     request_ = context_.CreateRequest(GURL("data:test"), DEFAULT_PRIORITY,
                                       &delegate_, TRAFFIC_ANNOTATION_FOR_TESTS);
   }
 
   void StartRequest(const HttpRequestHeaders* headers) {
     if (headers)
       request_->SetExtraRequestHeaders(*headers);
     request_->Start();
 
     EXPECT_TRUE(request_->is_pending());
     base::RunLoop().Run();
     EXPECT_FALSE(request_->is_pending());
   }
 
  protected:
   TestURLRequestContext context_;
   URLRequestJobFactoryImpl job_factory_;
   TestDelegate delegate_;
   std::unique_ptr<URLRequest> request_;
 
  private:
-  base::test::ScopedTaskScheduler scoped_task_scheduler_;
-
   DISALLOW_COPY_AND_ASSIGN(URLRequestSimpleJobTest);
 };
 
 }  // namespace
 
 TEST_F(URLRequestSimpleJobTest, SimpleRequest) {
   StartRequest(NULL);
   EXPECT_THAT(delegate_.request_status(), IsOk());
   EXPECT_EQ(kTestData, delegate_.data_received());
 }
@@ skipping 61 matching lines @@
 }
 
 TEST_F(URLRequestSimpleJobTest, CancelAfterFirstReadStarted) {
   CancelAfterFirstReadURLRequestDelegate cancel_delegate;
   request_ =
       context_.CreateRequest(GURL("data:cancel"), DEFAULT_PRIORITY,
                              &cancel_delegate, TRAFFIC_ANNOTATION_FOR_TESTS);
   request_->Start();
   cancel_delegate.WaitUntilHeadersReceived();
 
-  // Run ScopedTaskScheduler tasks.
+  // Run TaskScheduler tasks and their reply on the main thread.
+  base::TaskScheduler::GetInstance()->FlushForTesting();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(cancel_delegate.request_status(), IsError(ERR_ABORTED));
   EXPECT_EQ(1, cancel_delegate.response_started_count());
   EXPECT_EQ("", cancel_delegate.data_received());
   // Destroy the request so it doesn't outlive its delegate.
   request_.reset();
 }
 
 }  // namespace net