Remove SchedulerWorkerPoolImpl::ReEnqueueSequenceCallback.

base/task_scheduler/scheduler_worker_pool_impl_unittest.cc

 // Copyright 2016 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 "base/task_scheduler/scheduler_worker_pool_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <unordered_set>
@@ skipping 64 matching lines @@
     worker_pool_->WaitForAllWorkersIdleForTesting();
     worker_pool_->JoinForTesting();
   }
 
   void CreateWorkerPool() {
     ASSERT_FALSE(worker_pool_);
     service_thread_.Start();
     delayed_task_manager_.Start(service_thread_.task_runner());
     worker_pool_ = MakeUnique<SchedulerWorkerPoolImpl>(
         "TestWorkerPool", ThreadPriority::NORMAL,
-        Bind(&TaskSchedulerWorkerPoolImplTest::ReEnqueueSequenceCallback,
-             Unretained(this)),
         &task_tracker_, &delayed_task_manager_);
     ASSERT_TRUE(worker_pool_);
   }
 
   void StartWorkerPool(TimeDelta suggested_reclaim_time, size_t num_workers) {
     ASSERT_TRUE(worker_pool_);
     worker_pool_->Start(SchedulerWorkerPoolParams(
         StandbyThreadPolicy::LAZY, num_workers, suggested_reclaim_time));
   }
 
   void CreateAndStartWorkerPool(TimeDelta suggested_reclaim_time,
                                 size_t num_workers) {
     CreateWorkerPool();
     StartWorkerPool(suggested_reclaim_time, num_workers);
   }
 
   std::unique_ptr<SchedulerWorkerPoolImpl> worker_pool_;
 
   TaskTracker task_tracker_;
   Thread service_thread_;
 
  private:
-  void ReEnqueueSequenceCallback(scoped_refptr<Sequence> sequence) {
-    // In production code, this callback would be implemented by the
-    // TaskScheduler which would first determine which PriorityQueue the
-    // sequence must be re-enqueued.
-    const SequenceSortKey sort_key(sequence->GetSortKey());
-    worker_pool_->ReEnqueueSequence(std::move(sequence), sort_key);
-  }
-
   DelayedTaskManager delayed_task_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolImplTest);
 };
 
 scoped_refptr<TaskRunner> CreateTaskRunnerWithExecutionMode(
     SchedulerWorkerPoolImpl* worker_pool,
     test::ExecutionMode execution_mode) {
   // Allow tasks posted to the returned TaskRunner to wait on a WaitableEvent.
   const TaskTraits traits = TaskTraits().WithBaseSyncPrimitives();
@@ skipping 646 matching lines @@
   EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(0));
   EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(1));
   EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(2));
   EXPECT_EQ(1, histogram->SnapshotSamples()->GetCount(3));
   EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(4));
   EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(5));
   EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(6));
   EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(10));
 }
 
-namespace {
-
-void NotReachedReEnqueueSequenceCallback(scoped_refptr<Sequence> sequence) {
-  ADD_FAILURE()
-      << "Unexpected invocation of NotReachedReEnqueueSequenceCallback.";
-}
-
-}  // namespace
-
 TEST(TaskSchedulerWorkerPoolStandbyPolicyTest, InitLazy) {
   TaskTracker task_tracker;
   DelayedTaskManager delayed_task_manager;
   delayed_task_manager.Start(make_scoped_refptr(new TestSimpleTaskRunner));
   auto worker_pool = MakeUnique<SchedulerWorkerPoolImpl>(
-      "LazyPolicyWorkerPool", ThreadPriority::NORMAL,
-      Bind(&NotReachedReEnqueueSequenceCallback), &task_tracker,
+      "LazyPolicyWorkerPool", ThreadPriority::NORMAL, &task_tracker,
       &delayed_task_manager);
   worker_pool->Start(SchedulerWorkerPoolParams(StandbyThreadPolicy::LAZY, 8U,
                                                TimeDelta::Max()));
   ASSERT_TRUE(worker_pool);
   EXPECT_EQ(0U, worker_pool->NumberOfAliveWorkersForTesting());
   worker_pool->JoinForTesting();
 }
 
 TEST(TaskSchedulerWorkerPoolStandbyPolicyTest, InitOne) {
   TaskTracker task_tracker;
   DelayedTaskManager delayed_task_manager;
   delayed_task_manager.Start(make_scoped_refptr(new TestSimpleTaskRunner));
   auto worker_pool = MakeUnique<SchedulerWorkerPoolImpl>(
-      "OnePolicyWorkerPool", ThreadPriority::NORMAL,
-      Bind(&NotReachedReEnqueueSequenceCallback), &task_tracker,
+      "OnePolicyWorkerPool", ThreadPriority::NORMAL, &task_tracker,
       &delayed_task_manager);
   worker_pool->Start(SchedulerWorkerPoolParams(StandbyThreadPolicy::ONE, 8U,
                                                TimeDelta::Max()));
   ASSERT_TRUE(worker_pool);
   EXPECT_EQ(1U, worker_pool->NumberOfAliveWorkersForTesting());
   worker_pool->JoinForTesting();
 }
 
 }  // namespace internal
 }  // namespace base