Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | List of all members
v8::TaskRunner Class Referenceabstract

#include <v8-platform.h>

Public Member Functions

void PostTask (std::unique_ptr< Task > task, const SourceLocation &location=SourceLocation::Current())
 
void PostNonNestableTask (std::unique_ptr< Task > task, const SourceLocation &location=SourceLocation::Current())
 
void PostDelayedTask (std::unique_ptr< Task > task, double delay_in_seconds, const SourceLocation &location=SourceLocation::Current())
 
void PostNonNestableDelayedTask (std::unique_ptr< Task > task, double delay_in_seconds, const SourceLocation &location=SourceLocation::Current())
 
void PostIdleTask (std::unique_ptr< IdleTask > task, const SourceLocation &location=SourceLocation::Current())
 
virtual bool IdleTasksEnabled ()=0
 
virtual bool NonNestableTasksEnabled () const
 
virtual bool NonNestableDelayedTasksEnabled () const
 
 TaskRunner ()=default
 
virtual ~TaskRunner ()=default
 
 TaskRunner (const TaskRunner &)=delete
 
TaskRunner & operator= (const TaskRunner &)=delete
 

Protected Member Functions

virtual void PostTaskImpl (std::unique_ptr< Task > task, const SourceLocation &location)
 
virtual void PostNonNestableTaskImpl (std::unique_ptr< Task > task, const SourceLocation &location)
 
virtual void PostDelayedTaskImpl (std::unique_ptr< Task > task, double delay_in_seconds, const SourceLocation &location)
 
virtual void PostNonNestableDelayedTaskImpl (std::unique_ptr< Task > task, double delay_in_seconds, const SourceLocation &location)
 
virtual void PostIdleTaskImpl (std::unique_ptr< IdleTask > task, const SourceLocation &location)
 

Detailed Description

A TaskRunner allows scheduling of tasks. The TaskRunner may still be used to post tasks after the isolate gets destructed, but these tasks may not get executed anymore. All tasks posted to a given TaskRunner will be invoked in sequence. Tasks can be posted from any thread.

Constructor & Destructor Documentation

◆ TaskRunner() [1/2]

v8::TaskRunner::TaskRunner ( )
default

◆ ~TaskRunner()

virtual v8::TaskRunner::~TaskRunner ( )
virtualdefault

◆ TaskRunner() [2/2]

v8::TaskRunner::TaskRunner ( const TaskRunner &  )
delete

Member Function Documentation

◆ IdleTasksEnabled()

virtual bool v8::TaskRunner::IdleTasksEnabled ( )
pure virtual

Returns true if idle tasks are enabled for this TaskRunner.

◆ NonNestableDelayedTasksEnabled()

virtual bool v8::TaskRunner::NonNestableDelayedTasksEnabled ( ) const
inlinevirtual

Returns true if non-nestable delayed tasks are enabled for this TaskRunner.

◆ NonNestableTasksEnabled()

virtual bool v8::TaskRunner::NonNestableTasksEnabled ( ) const
inlinevirtual

Returns true if non-nestable tasks are enabled for this TaskRunner.

◆ operator=()

TaskRunner & v8::TaskRunner::operator= ( const TaskRunner &  )
delete

◆ PostDelayedTask()

void v8::TaskRunner::PostDelayedTask ( std::unique_ptr< Task >  task,
double  delay_in_seconds,
const SourceLocation &  location = SourceLocation::Current() 
)
inline

Schedules a task to be invoked by this TaskRunner. The task is scheduled after the given number of seconds |delay_in_seconds|. The TaskRunner implementation takes ownership of |task|.

Embedders should override PostDelayedTaskImpl instead of this.

Here is the call graph for this function:

◆ PostDelayedTaskImpl()

virtual void v8::TaskRunner::PostDelayedTaskImpl ( std::unique_ptr< Task >  task,
double  delay_in_seconds,
const SourceLocation &  location 
)
inlineprotectedvirtual
Here is the caller graph for this function:

◆ PostIdleTask()

void v8::TaskRunner::PostIdleTask ( std::unique_ptr< IdleTask >  task,
const SourceLocation &  location = SourceLocation::Current() 
)
inline

Schedules an idle task to be invoked by this TaskRunner. The task is scheduled when the embedder is idle. Requires that |TaskRunnerIdleTasksEnabled()| is true. Idle tasks may be reordered relative to other task types and may be starved for an arbitrarily long time if no idle time is available. The TaskRunner implementation takes ownership of |task|.

Embedders should override PostIdleTaskImpl instead of this.

Here is the call graph for this function:

◆ PostIdleTaskImpl()

virtual void v8::TaskRunner::PostIdleTaskImpl ( std::unique_ptr< IdleTask >  task,
const SourceLocation &  location 
)
inlineprotectedvirtual
Here is the caller graph for this function:

◆ PostNonNestableDelayedTask()

void v8::TaskRunner::PostNonNestableDelayedTask ( std::unique_ptr< Task >  task,
double  delay_in_seconds,
const SourceLocation &  location = SourceLocation::Current() 
)
inline

Schedules a task to be invoked by this TaskRunner. The task is scheduled after the given number of seconds |delay_in_seconds|. The TaskRunner implementation takes ownership of |task|. The |task| cannot be nested within other task executions.

Tasks which shouldn't be interleaved with JS execution must be posted with |PostNonNestableTask| or |PostNonNestableDelayedTask|. This is because the embedder may process tasks in a callback which is called during JS execution.

In particular, tasks which execute JS must be non-nestable, since JS execution is not allowed to nest.

Requires that |TaskRunnerNonNestableDelayedTasksEnabled()| is true.

Embedders should override PostNonNestableDelayedTaskImpl instead of this.

Here is the call graph for this function:

◆ PostNonNestableDelayedTaskImpl()

virtual void v8::TaskRunner::PostNonNestableDelayedTaskImpl ( std::unique_ptr< Task >  task,
double  delay_in_seconds,
const SourceLocation &  location 
)
inlineprotectedvirtual
Here is the caller graph for this function:

◆ PostNonNestableTask()

void v8::TaskRunner::PostNonNestableTask ( std::unique_ptr< Task >  task,
const SourceLocation &  location = SourceLocation::Current() 
)
inline

Schedules a task to be invoked by this TaskRunner. The TaskRunner implementation takes ownership of |task|. The |task| cannot be nested within other task executions.

Tasks which shouldn't be interleaved with JS execution must be posted with |PostNonNestableTask| or |PostNonNestableDelayedTask|. This is because the embedder may process tasks in a callback which is called during JS execution.

In particular, tasks which execute JS must be non-nestable, since JS execution is not allowed to nest.

Requires that |TaskRunnerNonNestableTasksEnabled()| is true.

Embedders should override PostNonNestableTaskImpl instead of this.

Here is the call graph for this function:

◆ PostNonNestableTaskImpl()

virtual void v8::TaskRunner::PostNonNestableTaskImpl ( std::unique_ptr< Task >  task,
const SourceLocation &  location 
)
inlineprotectedvirtual
Here is the caller graph for this function:

◆ PostTask()

void v8::TaskRunner::PostTask ( std::unique_ptr< Task >  task,
const SourceLocation &  location = SourceLocation::Current() 
)
inline

Schedules a task to be invoked by this TaskRunner. The TaskRunner implementation takes ownership of |task|.

Embedders should override PostTaskImpl instead of this.

Here is the call graph for this function:

◆ PostTaskImpl()

virtual void v8::TaskRunner::PostTaskImpl ( std::unique_ptr< Task >  task,
const SourceLocation &  location 
)
inlineprotectedvirtual

Implementation of above methods with an additional location argument.

Here is the caller graph for this function:
The documentation for this class was generated from the following file: