TaskScheduler: Remove base/task_scheduler/utils.h/.cc

base/task_scheduler/scheduler_worker_thread_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_thread.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <vector>
@@ skipping 59 matching lines @@
     return num_run_tasks_;
   }
 
   std::vector<scoped_refptr<Sequence>> CreatedSequences() {
     AutoSchedulerLock auto_lock(lock_);
     return created_sequences_;
   }
 
   std::vector<scoped_refptr<Sequence>> EnqueuedSequences() {
     AutoSchedulerLock auto_lock(lock_);
-    return enqueued_sequences_;
+    return re_enqueued_sequences_;
   }
 
   std::unique_ptr<SchedulerWorkerThread> worker_thread_;
 
  private:
   // SchedulerWorkerThread::Delegate:
   void OnMainEntry() override {
     // Without this |auto_lock|, OnMainEntry() could be called twice without
     // generating an error.
     AutoSchedulerLock auto_lock(lock_);
@@ skipping 35 matching lines @@
     {
       // Add the Sequence to the vector of created Sequences.
       AutoSchedulerLock auto_lock(lock_);
       created_sequences_.push_back(sequence);
     }
 
     return sequence;
   }
 
   // This override verifies that |sequence| contains the expected number of
-  // Tasks and adds it to |enqueued_sequences_|. Unlike a normal EnqueueSequence
-  // implementation, it doesn't reinsert |sequence| into a queue for further
-  // execution.
-  void EnqueueSequence(scoped_refptr<Sequence> sequence) override {
+  // Tasks and adds it to |re_enqueued_sequences_|. Unlike a normal
+  // ReEnqueueSequence implementation, it doesn't reinsert |sequence| into a
+  // queue for further execution.
+  void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override {
     EXPECT_GT(TasksPerSequence(), 1U);
 
     // Verify that |sequence| contains TasksPerSequence() - 1 Tasks.
     for (size_t i = 0; i < TasksPerSequence() - 1; ++i) {
       EXPECT_TRUE(sequence->PeekTask());
       sequence->PopTask();
     }
     EXPECT_FALSE(sequence->PeekTask());
 
-    // Add |sequence| to |enqueued_sequences_|.
+    // Add |sequence| to |re_enqueued_sequences_|.
     AutoSchedulerLock auto_lock(lock_);
-    enqueued_sequences_.push_back(std::move(sequence));
-    EXPECT_LE(enqueued_sequences_.size(), created_sequences_.size());
+    re_enqueued_sequences_.push_back(std::move(sequence));
+    EXPECT_LE(re_enqueued_sequences_.size(), created_sequences_.size());
   }
 
   void RunTaskCallback() {
     AutoSchedulerLock auto_lock(lock_);
     ++num_run_tasks_;
     EXPECT_LE(num_run_tasks_, created_sequences_.size());
   }
 
   TaskTracker task_tracker_;
 
@@ skipping 13 matching lines @@
   // Maximum number of times that GetWork() can be called.
   size_t max_get_work_ = 0;
 
   // Condition variable signaled when |num_get_work_| is incremented.
   std::unique_ptr<ConditionVariable> num_get_work_cv_;
 
   // Sequences created by GetWork().
   std::vector<scoped_refptr<Sequence>> created_sequences_;
 
   // Sequences passed to EnqueueSequence().
-  std::vector<scoped_refptr<Sequence>> enqueued_sequences_;
+  std::vector<scoped_refptr<Sequence>> re_enqueued_sequences_;
 
   // Number of times that RunTaskCallback() has been called.
   size_t num_run_tasks_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerThreadTest);
 };
 
 // Verify that when GetWork() continuously returns Sequences, all Tasks in these
 // Sequences run successfully. The test wakes up the SchedulerWorkerThread once.
 TEST_P(TaskSchedulerWorkerThreadTest, ContinuousWork) {
@@ skipping 58 matching lines @@
 INSTANTIATE_TEST_CASE_P(OneTaskPerSequence,
                         TaskSchedulerWorkerThreadTest,
                         ::testing::Values(1));
 INSTANTIATE_TEST_CASE_P(TwoTasksPerSequence,
                         TaskSchedulerWorkerThreadTest,
                         ::testing::Values(2));
 
 }  // namespace
 }  // namespace internal
 }  // namespace base