base/task_scheduler/scheduler_worker_pool.h

// 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.

#ifndef BASE_TASK_SCHEDULER_SCHEDULER_WORKER_POOL_H_
#define BASE_TASK_SCHEDULER_SCHEDULER_WORKER_POOL_H_

#include <memory>

#include "base/base_export.h"
#include "base/memory/ref_counted.h"
#include "base/sequenced_task_runner.h"
#include "base/single_thread_task_runner.h"
#include "base/task_runner.h"
#include "base/task_scheduler/sequence.h"
#include "base/task_scheduler/task.h"
#include "base/task_scheduler/task_traits.h"

namespace base {
namespace internal {

class SchedulerWorker;
class SequenceSortKey;

// Interface for a worker pool.
class BASE_EXPORT SchedulerWorkerPool {
 public:
  virtual ~SchedulerWorkerPool() = default;

  // Returns a TaskRunner whose PostTask invocations result in scheduling tasks
  // in this SchedulerWorkerPool using |traits|. Tasks may run in any order and
  // in parallel.
  virtual scoped_refptr<TaskRunner> CreateTaskRunnerWithTraits(
      const TaskTraits& traits) = 0;

  // Returns a SequencedTaskRunner whose PostTask invocations result in
  // scheduling tasks in this SchedulerWorkerPool using |traits|. Tasks run one
  // at a time in posting order.
  virtual scoped_refptr<SequencedTaskRunner>
  CreateSequencedTaskRunnerWithTraits(const TaskTraits& traits) = 0;

  // Returns a SingleThreadTaskRunner whose PostTask invocations result in
  // scheduling tasks in this SchedulerWorkerPool using |traits|. Tasks run on a
  // single thread in posting order.
  virtual scoped_refptr<SingleThreadTaskRunner>
  CreateSingleThreadTaskRunnerWithTraits(const TaskTraits& traits) = 0;

  // Inserts |sequence| with |sequence_sort_key| into a queue of Sequences that
  // can be processed by any worker owned by this SchedulerWorkerPool. Must only
  // be used to put |sequence| back into a queue after running a Task from it.
  // The thread that calls this doesn't have to belong to this
  // SchedulerWorkerPool.
  virtual void ReEnqueueSequence(scoped_refptr<Sequence> sequence,
                                 const SequenceSortKey& sequence_sort_key) = 0;

  // Posts |task| to be executed by this SchedulerWorkerPool as part of
  // |sequence|. If |worker| is non-null, |task| will be scheduled to run on it
  // specifically (note: |worker| must be owned by this SchedulerWorkerPool);
  // otherwise, |task| will be added to the pending shared work. |task| won't be
  // executed before its delayed run time, if any. Returns true if |task| is
  // posted.
  virtual bool PostTaskWithSequence(std::unique_ptr<Task> task,
                                    scoped_refptr<Sequence> sequence,
                                    SchedulerWorker* worker) = 0;

  // Posts |task| to be executed by this SchedulerWorkerPool as part of
  // |sequence|. If |worker| is non-null, |task| will be scheduled to run on it
  // specifically (note: |worker| must be owned by this SchedulerWorkerPool);
  // otherwise, |task| will be added to the pending shared work. This must only
  // be called after |task| has gone through PostTaskWithSequence() and after
  // |task|'s delayed run time.
  virtual void PostTaskWithSequenceNow(std::unique_ptr<Task> task,
                                       scoped_refptr<Sequence> sequence,
                                       SchedulerWorker* worker) = 0;
};

}  // namespace internal
}  // namespace base

#endif  // BASE_TASK_SCHEDULER_SCHEDULER_WORKER_POOL_H_