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/test/scoped_task_environment.h"
 #include "net/base/request_priority.h"
 #include "net/test/gtest_util.h"
+#include "net/test/net_test_suite.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"
 
 using net::test::IsError;
 using net::test::IsOk;
@@ skipping 74 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.
-  base::RunLoop().RunUntilIdle();
+  // Run TaskScheduler tasks and their reply on the main thread.
+  NetTestSuite::GetScopedTaskEnvironment()->RunUntilIdle();

[mmenke, 2017/05/10 15:43:44]

Why do only some RunUntilIdle calls need to be switched?  Just skimming over net
unittests, there are still a ton of RunUntilIdle calls.  Are we changing the
behavior of all of them?

[fdoray, 2017/05/10 16:16:12]

This CL removes ScopedTaskScheduler from individual net/ tests and adds a global
ScopedTaskEnvironment.

Within the scope of a ScopedTaskScheduler (deprecated):

  RunLoop().RunUntilIdle()
    Runs TaskScheduler tasks: Yes
    Runs main MessageLoop tasks: Yes
  NetTestSuite::GetScopedTaskEnvironment()->RunUntilIdle()
    Runs TaskScheduler tasks: Yes
    Runs main MessageLoop tasks: Yes

Within the scope of a ScopedTaskEnvironment:

  RunLoop().RunUntilIdle()
    Runs TaskScheduler tasks: *NO*
    Runs main MessageLoop tasks: Yes
  NetTestSuite::GetScopedTaskEnvironment()->RunUntilIdle()
    Runs TaskScheduler tasks: *YES*
    Runs main MessageLoop tasks: Yes

Replacing RunLoop().RunUntilIdle() with
NetTestSuite::GetScopedTaskEnvironment()->RunUntilIdle() is not necessary if we
don't expect to run TaskScheduler tasks.

 
   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