Use TaskScheduler instead of WorkerPool in multi_threaded_cert_verifier.cc.

net/url_request/url_fetcher_impl_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 "net/url_request/url_fetcher_impl.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/test/scoped_task_scheduler.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
@@ skipping 274 matching lines @@
 
   base::Closure on_destruction_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(FetcherTestURLRequestContextGetter);
 };
 
 }  // namespace
 
 class URLFetcherTest : public testing::Test {
  public:
-  URLFetcherTest() : num_upload_streams_created_(0) {}
+  URLFetcherTest()
+      : scoped_task_scheduler_(base::MessageLoop::current()),
+        num_upload_streams_created_(0) {}
 
   static int GetNumFetcherCores() {
     return URLFetcherImpl::GetNumFetcherCores();
   }
 
   // Creates a URLRequestContextGetter with a URLRequestContext that lives on
   // the current thread.
   scoped_refptr<FetcherTestURLRequestContextGetter>
   CreateSameThreadContextGetter() {
     return scoped_refptr<FetcherTestURLRequestContextGetter>(
@@ skipping 117 matching lines @@
 #endif
   }
 
   // Initializes |test_server_| without starting it.  Allows subclasses to use
   // their own server configuration.
   virtual void SetUpServer() {
     test_server_.reset(new EmbeddedTestServer);
     test_server_->AddDefaultHandlers(base::FilePath(kDocRoot));
   }
 
+  base::test::ScopedTaskScheduler scoped_task_scheduler_;
+
   // Network thread for cross-thread tests.  Most threads just use the main
   // thread for network activity.
   std::unique_ptr<base::Thread> network_thread_;
 
   std::unique_ptr<EmbeddedTestServer> test_server_;
   GURL hanging_url_;
 
   size_t num_upload_streams_created_;
 };
 
@@ skipping 49 matching lines @@
   EXPECT_TRUE(delegate.fetcher()->GetStatus().is_success());
   EXPECT_EQ(200, delegate.fetcher()->GetResponseCode());
   std::string data;
   ASSERT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
   EXPECT_EQ(kDefaultResponseBody, data);
 }
 
 // Create the fetcher from a sequenced (not single-threaded) task. Verify that
 // the expected response is received.
 TEST_F(URLFetcherTest, SequencedTaskTest) {
-  base::test::ScopedTaskScheduler scoped_task_scheduler(
-      base::MessageLoop::current());
   auto sequenced_task_runner =
       base::CreateSequencedTaskRunnerWithTraits(base::TaskTraits());
 
   auto delegate = base::MakeUnique<WaitingURLFetcherDelegate>();
   sequenced_task_runner->PostTask(
       FROM_HERE, base::Bind(&WaitingURLFetcherDelegate::CreateFetcher,
                             base::Unretained(delegate.get()),
                             test_server_->GetURL(kDefaultResponsePath),
                             URLFetcher::GET, CreateCrossThreadContextGetter()));
   base::RunLoop().RunUntilIdle();
@@ skipping 1033 matching lines @@
   EXPECT_EQ(-1, delegate.fetcher()->GetResponseCode());
   EXPECT_FALSE(delegate.fetcher()->GetResponseHeaders());
   std::string data;
   EXPECT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
   EXPECT_TRUE(data.empty());
 }
 
 }  // namespace
 
 }  // namespace net