flutter::TaskRunner Class Reference

#include <task_runner.h>

Inheritance diagram for flutter::TaskRunner:

Public Types
using	TaskTimePoint = std::chrono::steady_clock::time_point
using	TaskExpiredCallback = std::function< void(const FlutterTask *)>
using	TaskClosure = std::function< void()>

Public Member Functions
	TaskRunner (CurrentTimeProc get_current_time, const TaskExpiredCallback &on_task_expired)
virtual	~TaskRunner ()
virtual bool	RunsTasksOnCurrentThread () const
void	PostFlutterTask (FlutterTask flutter_task, uint64_t flutter_target_time_nanos)
void	PostTask (TaskClosure task)
void	RunNowOrPostTask (TaskClosure task)
std::chrono::nanoseconds	ProcessTasks ()

Private Member Functions
virtual void	WakeUp ()
virtual TaskTimePoint	GetCurrentTimeForTask () const

Detailed Description

Definition at line 26 of file task_runner.h.

Member Typedef Documentation

TaskClosure

using flutter::TaskRunner::TaskClosure = std::function<void()>

Definition at line 30 of file task_runner.h.

TaskExpiredCallback

using flutter::TaskRunner::TaskExpiredCallback = std::function<void(const FlutterTask*)>

Definition at line 29 of file task_runner.h.

TaskTimePoint

using flutter::TaskRunner::TaskTimePoint = std::chrono::steady_clock::time_point

Definition at line 28 of file task_runner.h.

Constructor & Destructor Documentation

TaskRunner()

flutter::TaskRunner::TaskRunner	(	CurrentTimeProc	get_current_time,
		const TaskExpiredCallback &	on_task_expired
	)

Definition at line 12 of file task_runner.cc.

    : get_current_time_(get_current_time),
      on_task_expired_(std::move(on_task_expired)) {
  main_thread_id_ = GetCurrentThreadId();
  task_runner_window_ = TaskRunnerWindow::GetSharedInstance();
  task_runner_window_->AddDelegate(this);
}

~TaskRunner()

flutter::TaskRunner::~TaskRunner ( )

virtual

Definition at line 21 of file task_runner.cc.

                        {
  task_runner_window_->RemoveDelegate(this);
}

Member Function Documentation

GetCurrentTimeForTask()

virtual TaskTimePoint flutter::TaskRunner::GetCurrentTimeForTask ( ) const

inlineprivatevirtual

Definition at line 90 of file task_runner.h.

                                                      {
    return TaskTimePoint::clock::now();
  }

PostFlutterTask()

void flutter::TaskRunner::PostFlutterTask	(	FlutterTask	flutter_task,
		uint64_t	flutter_target_time_nanos
	)

Definition at line 80 of file task_runner.cc.

                                                                     {
  Task task;
  task.fire_time = TimePointFromFlutterTime(flutter_target_time_nanos);
  task.variant = flutter_task;
  EnqueueTask(std::move(task));
}

PostTask()

void flutter::TaskRunner::PostTask

(

TaskClosure

task

)

Definition at line 88 of file task_runner.cc.

                                             {
  Task task;
  task.fire_time = GetCurrentTimeForTask();
  task.variant = std::move(closure);
  EnqueueTask(std::move(task));
}

ProcessTasks()

std::chrono::nanoseconds flutter::TaskRunner::ProcessTasks ( )

virtual

Implements flutter::TaskRunnerWindow::Delegate.

Definition at line 25 of file task_runner.cc.

                                              {
  const TaskTimePoint now = GetCurrentTimeForTask();
 
  std::vector<Task> expired_tasks;
 
  // Process expired tasks.
  {
    std::lock_guard<std::mutex> lock(task_queue_mutex_);
    while (!task_queue_.empty()) {
      const auto& top = task_queue_.top();
      // If this task (and all tasks after this) has not yet expired, there is
      // nothing more to do. Quit iterating.
      if (top.fire_time > now) {
        break;
      }
 
      // Make a record of the expired task. Do NOT service the task here
      // because we are still holding onto the task queue mutex. We don't want
      // other threads to block on posting tasks onto this thread till we are
      // done processing expired tasks.
      expired_tasks.push_back(task_queue_.top());
 
      // Remove the tasks from the delayed tasks queue.
      task_queue_.pop();
    }
  }
 
  // Fire expired tasks.
  {
    // Flushing tasks here without holing onto the task queue mutex.
    for (const auto& task : expired_tasks) {
      if (auto flutter_task = std::get_if<FlutterTask>(&task.variant)) {
        on_task_expired_(flutter_task);
      } else if (auto closure = std::get_if<TaskClosure>(&task.variant))
        (*closure)();
    }
  }
 
  // Calculate duration to sleep for on next iteration.
  {
    std::lock_guard<std::mutex> lock(task_queue_mutex_);
    const auto next_wake = task_queue_.empty() ? TaskTimePoint::max()
                                               : task_queue_.top().fire_time;
 
    return std::min(next_wake - now, std::chrono::nanoseconds::max());
  }
}

RunNowOrPostTask()

void flutter::TaskRunner::RunNowOrPostTask ( TaskClosure  task )

inline

Definition at line 51 of file task_runner.h.

                                          {
    if (RunsTasksOnCurrentThread()) {
      task();
    } else {
      PostTask(std::move(task));
    }
  }

RunsTasksOnCurrentThread()

bool flutter::TaskRunner::RunsTasksOnCurrentThread ( ) const

virtual

Definition at line 112 of file task_runner.cc.

                                                {
  return GetCurrentThreadId() == main_thread_id_;
}

WakeUp()

void flutter::TaskRunner::WakeUp ( )

privatevirtual

Definition at line 116 of file task_runner.cc.

                        {
  task_runner_window_->WakeUp();
}

---

The documentation for this class was generated from the following files:

• shell/platform/windows/task_runner.h
• shell/platform/windows/task_runner.cc