Instantiate ScopedTaskEnvironment in net unittests.

net/http/http_network_transaction_unittest.cc

 // Copyright 2013 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/http/http_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <stdint.h>
 
 #include <limits>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/test/scoped_task_scheduler.h"
+#include "base/task_scheduler/task_scheduler.h"
 #include "base/test/test_file_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/auth.h"
 #include "net/base/chunked_upload_data_stream.h"
 #include "net/base/completion_callback.h"
 #include "net/base/elements_upload_data_stream.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/network_throttle_manager.h"
@@ skipping 16714 matching lines @@
 
   // Call it and check results (partially a "doesn't crash" test).
   trans_ptr->SetPriority(IDLE);
   trans_ptr = nullptr;  // No longer a valid pointer.
 
   base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(callback.have_result());
 }
 
 #if !defined(OS_IOS)
+
+namespace {
+
+// TODO(fdoray): Use ScopedTaskEnvironment::RunUntilIdle() instead of this once
+// implemented. https://crbug.com/708584
+class TaskObserver : public base::MessageLoop::TaskObserver {
+ public:
+  TaskObserver() : ran_task_(false) {}
+  ~TaskObserver() override {}
+
+  // MessageLoop::TaskObserver overrides.
+  void WillProcessTask(const base::PendingTask& pending_task) override {}
+  void DidProcessTask(const base::PendingTask& pending_task) override {
+    ran_task_ = true;
+  }
+
+  bool ran_task() const { return ran_task_; }
+
+ private:
+  bool ran_task_ = false;
+  DISALLOW_COPY_AND_ASSIGN(TaskObserver);
+};
+
+// Run tasks on the main thread until there are no more main thread or
+// TaskScheduler tasks.
+void RunMainThreadAndTaskSchedulerUntilIdle() {
+  for (;;) {
+    base::TaskScheduler::GetInstance()->FlushForTesting();

[mmenke, 2017/05/09 15:40:44]

Why are both this and RunUntilIdle needed?

[fdoray, 2017/05/09 21:43:47]

n/a with latest patch set

+
+    // Setup a task observer to determine if main thread tasks have run in the
+    // current loop iteration.
+    TaskObserver task_observer;
+    base::MessageLoop::current()->AddTaskObserver(&task_observer);
+    base::RunLoop().RunUntilIdle();
+    base::MessageLoop::current()->RemoveTaskObserver(&task_observer);
+
+    if (!task_observer.ran_task())
+      break;
+  }
+}
+
+}  // namespace
+
 TEST_F(HttpNetworkTransactionTest, TokenBindingSpdy) {
-  // Required by ChannelIDService.
-  base::test::ScopedTaskScheduler scoped_task_scheduler(
-      base::MessageLoop::current());
-
   const std::string https_url = "https://www.example.com";
   HttpRequestInfo request;
   request.url = GURL(https_url);
   request.method = "GET";
 
   SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.token_binding_negotiated = true;
   ssl.token_binding_key_param = TB_PARAM_ECDSAP256;
   ssl.next_proto = kProtoHTTP2;
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
   SpdySerializedFrame body(spdy_util_.ConstructSpdyDataFrame(1, true));
   MockRead reads[] = {CreateMockRead(resp), CreateMockRead(body),
                       MockRead(ASYNC, ERR_IO_PENDING)};
   StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&data);
   session_deps_.channel_id_service.reset(
       new ChannelIDService(new DefaultChannelIDStore(nullptr)));
   std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             trans.Start(&request, callback.callback(), NetLogWithSource()));
-  base::RunLoop().RunUntilIdle();
+
+  RunMainThreadAndTaskSchedulerUntilIdle();
 
   EXPECT_TRUE(trans.GetResponseInfo()->was_fetched_via_spdy);
   HttpRequestHeaders headers;
   ASSERT_TRUE(trans.GetFullRequestHeaders(&headers));
   EXPECT_TRUE(headers.HasHeader(HttpRequestHeaders::kTokenBinding));
 }
 #endif  // !defined(OS_IOS)
 
 void CheckContentEncodingMatching(SpdySessionDependencies* session_deps,
                                   const std::string& accept_encoding,
@@ skipping 62 matching lines @@
   CheckContentEncodingMatching(&session_deps_, "identity;q=1, *;q=0", "gzip",
                                "", false);
 }
 
 TEST_F(HttpNetworkTransactionTest, MatchContentEncoding4) {
   CheckContentEncodingMatching(&session_deps_, "identity;q=1, *;q=0", "gzip",
                                "www.foo.com/other", true);
 }
 
 }  // namespace net