mirror of
https://github.com/klzgrad/naiveproxy.git
synced 2024-11-24 22:36:09 +03:00
83 lines
3.0 KiB
C++
83 lines
3.0 KiB
C++
// Copyright 2018 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_SEQUENCE_MANAGER_THREAD_CONTROLLER_H_
|
|
#define BASE_TASK_SEQUENCE_MANAGER_THREAD_CONTROLLER_H_
|
|
|
|
#include "base/run_loop.h"
|
|
#include "base/single_thread_task_runner.h"
|
|
#include "base/task/sequence_manager/lazy_now.h"
|
|
#include "base/time/time.h"
|
|
|
|
namespace base {
|
|
|
|
class TickClock;
|
|
struct PendingTask;
|
|
|
|
namespace sequence_manager {
|
|
namespace internal {
|
|
|
|
class SequencedTaskSource;
|
|
|
|
// Implementation of this interface is used by TaskQueueManager to schedule
|
|
// actual work to be run. Hopefully we can stop using MessageLoop and this
|
|
// interface will become more concise.
|
|
class ThreadController {
|
|
public:
|
|
virtual ~ThreadController() = default;
|
|
|
|
// Sets the number of tasks executed in a single invocation of DoWork.
|
|
// Increasing the batch size can reduce the overhead of yielding back to the
|
|
// main message loop.
|
|
virtual void SetWorkBatchSize(int work_batch_size = 1) = 0;
|
|
|
|
// Notifies that |pending_task| was enqueued. Needed for tracing purposes.
|
|
virtual void DidQueueTask(const PendingTask& pending_task) = 0;
|
|
|
|
// Notify the controller that its associated sequence has immediate work
|
|
// to run. Shortly after this is called, the thread associated with this
|
|
// controller will run a task returned by sequence->TakeTask(). Can be called
|
|
// from any sequence.
|
|
//
|
|
// TODO(altimin): Change this to "the thread associated with this
|
|
// controller will run tasks returned by sequence->TakeTask() until it
|
|
// returns null or sequence->DidRunTask() returns false" once the
|
|
// code is changed to work that way.
|
|
virtual void ScheduleWork() = 0;
|
|
|
|
// Notify the controller that SequencedTaskSource will have a delayed work
|
|
// ready to be run at |run_time|. This call cancels any previously
|
|
// scheduled delayed work. Can only be called from the main sequence.
|
|
// NOTE: DelayTillNextTask might return a different value as it also takes
|
|
// immediate work into account.
|
|
virtual void SetNextDelayedDoWork(LazyNow* lazy_now, TimeTicks run_time) = 0;
|
|
|
|
// Sets the sequenced task source from which to take tasks after
|
|
// a Schedule*Work() call is made.
|
|
// Must be called before the first call to Schedule*Work().
|
|
virtual void SetSequencedTaskSource(SequencedTaskSource*) = 0;
|
|
|
|
// TODO(altimin): Get rid of the methods below.
|
|
// These methods exist due to current integration of TaskQueueManager
|
|
// with MessageLoop.
|
|
|
|
virtual bool RunsTasksInCurrentSequence() = 0;
|
|
|
|
virtual const TickClock* GetClock() = 0;
|
|
|
|
virtual void SetDefaultTaskRunner(scoped_refptr<SingleThreadTaskRunner>) = 0;
|
|
|
|
virtual void RestoreDefaultTaskRunner() = 0;
|
|
|
|
virtual void AddNestingObserver(RunLoop::NestingObserver* observer) = 0;
|
|
|
|
virtual void RemoveNestingObserver(RunLoop::NestingObserver* observer) = 0;
|
|
};
|
|
|
|
} // namespace internal
|
|
} // namespace sequence_manager
|
|
} // namespace base
|
|
|
|
#endif // BASE_TASK_SEQUENCE_MANAGER_THREAD_CONTROLLER_H_
|