Remove SequencedWorkerPool::PostWorkerTask().

base/threading/sequenced_worker_pool_unittest.cc

Index: base/threading/sequenced_worker_pool_unittest.cc
diff --git a/base/threading/sequenced_worker_pool_unittest.cc b/base/threading/sequenced_worker_pool_unittest.cc
index ccc21d8ebbaadaac4a17b60bfec3ef0cea545b6f..17eadbb3d517d8eb19c60b3fa475583ba2e4ad6c 100644
--- a/base/threading/sequenced_worker_pool_unittest.cc
+++ b/base/threading/sequenced_worker_pool_unittest.cc
@@ -322,9 +322,8 @@ class SequencedWorkerPoolTest
     // workers to be created.
     ThreadBlocker blocker;
     for (size_t i = 0; i < kNumWorkerThreads; i++) {
-      pool()->PostWorkerTask(
-          FROM_HERE,
-          base::BindOnce(&TestTracker::BlockTask, tracker(), -1, &blocker));
+      pool()->PostTask(FROM_HERE, base::BindOnce(&TestTracker::BlockTask,
+                                                 tracker(), -1, &blocker));
     }
     tracker()->WaitUntilTasksBlocked(kNumWorkerThreads);
 
@@ -453,13 +452,13 @@ TEST_P(SequencedWorkerPoolTest, NamedTokens) {
 // Tests that posting a bunch of tasks (many more than the number of worker
 // threads) runs them all.
 TEST_P(SequencedWorkerPoolTest, LotsOfTasks) {
-  pool()->PostWorkerTask(FROM_HERE,
-                         base::BindOnce(&TestTracker::SlowTask, tracker(), 0));
+  pool()->PostTask(FROM_HERE,
+                   base::BindOnce(&TestTracker::SlowTask, tracker(), 0));
 
   const size_t kNumTasks = 20;
   for (size_t i = 1; i < kNumTasks; i++) {
-    pool()->PostWorkerTask(
-        FROM_HERE, base::BindOnce(&TestTracker::FastTask, tracker(), i));
+    pool()->PostTask(FROM_HERE,
+                     base::BindOnce(&TestTracker::FastTask, tracker(), i));
   }
 
   std::vector<int> result = tracker()->WaitUntilTasksComplete(kNumTasks);
@@ -475,15 +474,15 @@ TEST_P(SequencedWorkerPoolTest, LotsOfTasksTwoPools) {
   SequencedWorkerPoolOwner pool2(kNumWorkerThreads, "test2");
 
   base::Closure slow_task = base::Bind(&TestTracker::SlowTask, tracker(), 0);
-  pool1.pool()->PostWorkerTask(FROM_HERE, slow_task);
-  pool2.pool()->PostWorkerTask(FROM_HERE, slow_task);
+  pool1.pool()->PostTask(FROM_HERE, slow_task);
+  pool2.pool()->PostTask(FROM_HERE, slow_task);
 
   const size_t kNumTasks = 20;
   for (size_t i = 1; i < kNumTasks; i++) {
     base::Closure fast_task =
         base::Bind(&TestTracker::FastTask, tracker(), i);
-    pool1.pool()->PostWorkerTask(FROM_HERE, fast_task);
-    pool2.pool()->PostWorkerTask(FROM_HERE, fast_task);
+    pool1.pool()->PostTask(FROM_HERE, fast_task);
+    pool2.pool()->PostTask(FROM_HERE, fast_task);
   }
 
   std::vector<int> result =
@@ -498,9 +497,9 @@ TEST_P(SequencedWorkerPoolTest, Sequence) {
   const size_t kNumBackgroundTasks = kNumWorkerThreads - 1;
   ThreadBlocker background_blocker;
   for (size_t i = 0; i < kNumBackgroundTasks; i++) {
-    pool()->PostWorkerTask(FROM_HERE,
-                           base::BindOnce(&TestTracker::BlockTask, tracker(), i,
-                                          &background_blocker));
+    pool()->PostTask(FROM_HERE,
+                     base::BindOnce(&TestTracker::BlockTask, tracker(), i,
+                                    &background_blocker));
   }
   tracker()->WaitUntilTasksBlocked(kNumBackgroundTasks);
 
@@ -559,8 +558,8 @@ TEST_P(SequencedWorkerPoolTest, DISABLED_IgnoresAfterShutdown) {
   EnsureAllWorkersCreated();
   ThreadBlocker blocker;
   for (size_t i = 0; i < kNumWorkerThreads; i++) {
-    pool()->PostWorkerTask(FROM_HERE, base::BindOnce(&TestTracker::BlockTask,
-                                                     tracker(), i, &blocker));
+    pool()->PostTask(FROM_HERE, base::BindOnce(&TestTracker::BlockTask,
+                                               tracker(), i, &blocker));
   }
   tracker()->WaitUntilTasksBlocked(kNumWorkerThreads);
 
@@ -606,7 +605,7 @@ TEST_P(SequencedWorkerPoolTest, AllowsAfterShutdown) {
   // Start tasks to take all the threads and block them.
   const int kNumBlockTasks = static_cast<int>(kNumWorkerThreads);
   for (int i = 0; i < kNumBlockTasks; ++i) {
-    EXPECT_TRUE(pool()->PostWorkerTask(
+    EXPECT_TRUE(pool()->PostTask(
         FROM_HERE,
         base::BindOnce(&TestTracker::BlockTask, tracker(), i, &blocker)));
   }
@@ -670,7 +669,7 @@ TEST_P(SequencedWorkerPoolTest,
   // Start tasks to take all the threads and block them.
   const int kNumBlockTasks = static_cast<int>(kNumWorkerThreads);
   for (int i = 0; i < kNumBlockTasks; ++i) {
-    EXPECT_TRUE(pool()->PostWorkerTask(
+    EXPECT_TRUE(pool()->PostTask(
         FROM_HERE,
         base::BindOnce(&TestTracker::BlockTask, tracker(), i, &blocker)));
   }
@@ -726,8 +725,8 @@ TEST_P(SequencedWorkerPoolTest, DiscardOnShutdown) {
   EnsureAllWorkersCreated();
   ThreadBlocker blocker;
   for (size_t i = 0; i < kNumWorkerThreads; i++) {
-    pool()->PostWorkerTask(FROM_HERE, base::BindOnce(&TestTracker::BlockTask,
-                                                     tracker(), i, &blocker));
+    pool()->PostTask(FROM_HERE, base::BindOnce(&TestTracker::BlockTask,
+                                               tracker(), i, &blocker));
   }
   tracker()->WaitUntilTasksBlocked(kNumWorkerThreads);
 
@@ -994,14 +993,14 @@ TEST_P(SequencedWorkerPoolTest, FlushForTesting) {
   pool()->PostDelayedTask(FROM_HERE,
                           base::BindOnce(&TestTracker::FastTask, tracker(), 0),
                           TimeDelta::FromMinutes(5));
-  pool()->PostWorkerTask(FROM_HERE,
-                         base::BindOnce(&TestTracker::SlowTask, tracker(), 0));
+  pool()->PostTask(FROM_HERE,
+                   base::BindOnce(&TestTracker::SlowTask, tracker(), 0));
   const size_t kNumFastTasks = 20;
   for (size_t i = 0; i < kNumFastTasks; i++) {
-    pool()->PostWorkerTask(
-        FROM_HERE, base::BindOnce(&TestTracker::FastTask, tracker(), 0));
+    pool()->PostTask(FROM_HERE,
+                     base::BindOnce(&TestTracker::FastTask, tracker(), 0));
   }
-  pool()->PostWorkerTask(
+  pool()->PostTask(
       FROM_HERE, base::BindOnce(&TestTracker::PostAdditionalTasks, tracker(), 0,
                                 base::RetainedRef(pool()), true));
 
@@ -1078,9 +1077,9 @@ TEST_P(SequencedWorkerPoolTest, GetWorkerPoolAndSequenceTokenForCurrentThread) {
       token2, FROM_HERE,
       base::BindOnce(&CheckWorkerPoolAndSequenceToken, pool(), token2));
 
-  pool()->PostWorkerTask(
-      FROM_HERE, base::BindOnce(&CheckWorkerPoolAndSequenceToken, pool(),
-                                SequencedWorkerPool::SequenceToken()));
+  pool()->PostTask(FROM_HERE,
+                   base::BindOnce(&CheckWorkerPoolAndSequenceToken, pool(),
+                                  SequencedWorkerPool::SequenceToken()));
 
   pool()->FlushForTesting();
 }