Replace single-threaded SequencedWorkerPool with base::Thread in net_unittests

Only logic change is that base::Thread will run all tasks before being
destroyed (as opposed to previous SKIP_ON_SHUTDOWN semantics), but no
tests called Shutdown() explicitly so I assume this wasn't an explicit
choice and that those tests don't care?

A few drive-by cleanups too.

BUG=646443
NO_DEPENDENCY_CHECKS=true

Review-Url: https://codereview.chromium.org/2334163005
Cr-Commit-Position: refs/heads/master@{#418912}

net/base/file_stream_unittest.cc

@@ -16,8 +16,8 @@
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/waitable_event.h"
-#include "base/test/sequenced_worker_pool_owner.h"
 #include "base/test/test_timeouts.h"
+#include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/io_buffer.h"
@@ -727,10 +727,12 @@ TEST_F(FileStreamTest, WriteClose) {
 }
 
 TEST_F(FileStreamTest, OpenAndDelete) {
-  base::SequencedWorkerPoolOwner pool_owner(1, "StreamTest");
+  base::Thread worker_thread("StreamTest");
+  ASSERT_TRUE(worker_thread.Start());
 
   bool prev = base::ThreadRestrictions::SetIOAllowed(false);
-  std::unique_ptr<FileStream> stream(new FileStream(pool_owner.pool()));
+  std::unique_ptr<FileStream> stream(
+      new FileStream(worker_thread.task_runner()));
   int flags = base::File::FLAG_OPEN | base::File::FLAG_WRITE |
               base::File::FLAG_ASYNC;
   TestCompletionCallback open_callback;
@@ -741,8 +743,9 @@ TEST_F(FileStreamTest, OpenAndDelete) {
   // complete. Should be safe.
   stream.reset();
 
-  // Force an operation through the pool.
-  std::unique_ptr<FileStream> stream2(new FileStream(pool_owner.pool()));
+  // Force an operation through the worker.
+  std::unique_ptr<FileStream> stream2(
+      new FileStream(worker_thread.task_runner()));
   TestCompletionCallback open_callback2;
   rv = stream2->Open(temp_file_path(), flags, open_callback2.callback());
   EXPECT_THAT(open_callback2.GetResult(rv), IsOk());

net/url_request/url_request_simple_job_unittest.cc

@@ -5,14 +5,16 @@
 #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/run_loop.h"
+#include "base/sequenced_task_runner.h"
+#include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
-#include "base/test/sequenced_worker_pool_owner.h"
-#include "base/threading/worker_pool.h"
+#include "base/threading/thread.h"
 #include "net/base/request_priority.h"
 #include "net/test/gtest_util.h"
 #include "net/url_request/url_request_job.h"
@@ -43,10 +45,10 @@ class MockSimpleJob : public URLRequestSimpleJob {
   MockSimpleJob(URLRequest* request,
                 NetworkDelegate* network_delegate,
                 scoped_refptr<base::TaskRunner> task_runner,
-                std::string data)
+                base::StringPiece data)
       : URLRequestSimpleJob(request, network_delegate),
-        data_(data),
-        task_runner_(task_runner) {}
+        data_(data.as_string()),
+        task_runner_(std::move(task_runner)) {}
 
  protected:
   // URLRequestSimpleJob implementation:
@@ -69,7 +71,7 @@ class MockSimpleJob : public URLRequestSimpleJob {
 
   const std::string data_;
 
-  scoped_refptr<base::TaskRunner> task_runner_;
+  const scoped_refptr<base::TaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(MockSimpleJob);
 };
@@ -105,7 +107,7 @@ class SimpleJobProtocolHandler :
     public URLRequestJobFactory::ProtocolHandler {
  public:
   SimpleJobProtocolHandler(scoped_refptr<base::TaskRunner> task_runner)
-      : task_runner_(task_runner) {}
+      : task_runner_(std::move(task_runner)) {}
   URLRequestJob* MaybeCreateJob(
       URLRequest* request,
       NetworkDelegate* network_delegate) const override {
@@ -118,21 +120,19 @@ class SimpleJobProtocolHandler :
   ~SimpleJobProtocolHandler() override {}
 
  private:
-  scoped_refptr<base::TaskRunner> task_runner_;
+  const scoped_refptr<base::TaskRunner> task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(SimpleJobProtocolHandler);
 };
 
 class URLRequestSimpleJobTest : public ::testing::Test {
  public:
   URLRequestSimpleJobTest()
-      : worker_pool_owner_(1, "URLRequestSimpleJobTest"),
-        task_runner_(worker_pool_owner_.pool()
-                         ->GetSequencedTaskRunnerWithShutdownBehavior(
-                             worker_pool_owner_.pool()
-                                 ->GetSequenceToken(),
-                             base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)),
-        context_(true) {
+      : worker_thread_("URLRequestSimpleJobTest"), context_(true) {
+    EXPECT_TRUE(worker_thread_.Start());
+
     job_factory_.SetProtocolHandler(
-        "data", base::MakeUnique<SimpleJobProtocolHandler>(task_runner_));
+        "data", base::MakeUnique<SimpleJobProtocolHandler>(task_runner()));
     context_.set_job_factory(&job_factory_);
     context_.Init();
 
@@ -150,13 +150,18 @@ class URLRequestSimpleJobTest : public ::testing::Test {
     EXPECT_FALSE(request_->is_pending());
   }
 
+  scoped_refptr<base::SequencedTaskRunner> task_runner() {
+    return worker_thread_.task_runner();
+  }
+
  protected:
-  base::SequencedWorkerPoolOwner worker_pool_owner_;
-  scoped_refptr<base::SequencedTaskRunner> task_runner_;
+  base::Thread worker_thread_;
   TestURLRequestContext context_;
   URLRequestJobFactoryImpl job_factory_;
   TestDelegate delegate_;
   std::unique_ptr<URLRequest> request_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestSimpleJobTest);
 };
 
 }  // namespace
@@ -240,7 +245,7 @@ TEST_F(URLRequestSimpleJobTest, CancelAfterFirstReadStarted) {
   // Feed a dummy task to the SequencedTaskRunner to make sure that the
   // callbacks which are invoked in ReadRawData have completed safely.
   base::RunLoop run_loop;
-  EXPECT_TRUE(task_runner_->PostTaskAndReply(
+  EXPECT_TRUE(task_runner()->PostTaskAndReply(
       FROM_HERE, base::Bind(&base::DoNothing), run_loop.QuitClosure()));
   run_loop.Run();