flutter::EventLoop Class Reference

#include <event_loop.h>

Inheritance diagram for flutter::EventLoop:

Classes
struct	Task

Public Types
using	TaskExpiredCallback = std::function< void(const FlutterTask *)>

Public Member Functions
	EventLoop (std::thread::id main_thread_id, const TaskExpiredCallback &on_task_expired)
virtual	~EventLoop ()
	EventLoop (const EventLoop &)=delete
EventLoop &	operator= (const EventLoop &)=delete
bool	RunsTasksOnCurrentThread () const
void	WaitForEvents (std::chrono::nanoseconds max_wait=std::chrono::nanoseconds::max())
void	PostTask (FlutterTask flutter_task, uint64_t flutter_target_time_nanos)

Protected Types
using	TaskTimePoint = std::chrono::steady_clock::time_point

Protected Member Functions
std::mutex &	GetTaskQueueMutex ()
virtual void	WaitUntil (const TaskTimePoint &time)=0
virtual void	Wake ()=0

Static Protected Member Functions
static TaskTimePoint	TimePointFromFlutterTime (uint64_t flutter_target_time_nanos)

Protected Attributes
std::thread::id	main_thread_id_
TaskExpiredCallback	on_task_expired_
std::mutex	task_queue_mutex_
std::priority_queue< Task, std::deque< Task >, Task::Comparer >	task_queue_

Detailed Description

Definition at line 20 of file event_loop.h.

Member Typedef Documentation

TaskExpiredCallback

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

Definition at line 22 of file event_loop.h.

TaskTimePoint

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

protected

Definition at line 50 of file event_loop.h.

Constructor & Destructor Documentation

EventLoop() [1/2]

flutter::EventLoop::EventLoop	(	std::thread::id	main_thread_id,
		const TaskExpiredCallback &	on_task_expired
	)

Definition at line 12 of file event_loop.cc.

    : main_thread_id_(main_thread_id), on_task_expired_(on_task_expired) {}

~EventLoop()

flutter::EventLoop::~EventLoop ( )

virtualdefault

EventLoop() [2/2]

flutter::EventLoop::EventLoop ( const EventLoop &  )

delete

Member Function Documentation

GetTaskQueueMutex()

std::mutex & flutter::EventLoop::GetTaskQueueMutex ( )

inlineprotected

Definition at line 58 of file event_loop.h.

{ return task_queue_mutex_; }

operator=()

EventLoop & flutter::EventLoop::operator= ( const EventLoop &  )

delete

PostTask()

void flutter::EventLoop::PostTask	(	FlutterTask	flutter_task,
		uint64_t	flutter_target_time_nanos
	)

Definition at line 82 of file event_loop.cc.

                                                             {
  static std::atomic_uint64_t sGlobalTaskOrder(0);
 
  Task task;
  task.order = ++sGlobalTaskOrder;
  task.fire_time = TimePointFromFlutterTime(flutter_target_time_nanos);
  task.task = flutter_task;
 
  {
    std::lock_guard<std::mutex> lock(task_queue_mutex_);
    task_queue_.push(task);
 
    // Make sure the queue mutex is unlocked before waking up the loop. In case
    // the wake causes this thread to be descheduled for the primary thread to
    // process tasks, the acquisition of the lock on that thread while holding
    // the lock here momentarily till the end of the scope is a pessimization.
  }
  Wake();
}

RunsTasksOnCurrentThread()

bool flutter::EventLoop::RunsTasksOnCurrentThread

(

)

const

Definition at line 18 of file event_loop.cc.

                                               {
  return std::this_thread::get_id() == main_thread_id_;
}

TimePointFromFlutterTime()

EventLoop::TaskTimePoint flutter::EventLoop::TimePointFromFlutterTime ( uint64_t  flutter_target_time_nanos )

staticprotected

Definition at line 74 of file event_loop.cc.

                                        {
  const auto now = TaskTimePoint::clock::now();
  const int64_t flutter_duration =
      flutter_target_time_nanos - FlutterEngineGetCurrentTime();
  return now + std::chrono::nanoseconds(flutter_duration);
}

WaitForEvents()

void flutter::EventLoop::WaitForEvents

(

std::chrono::nanoseconds

max_wait = std::chrono::nanoseconds::max()

)

Definition at line 22 of file event_loop.cc.

                                                           {
  const auto now = TaskTimePoint::clock::now();
  std::vector<FlutterTask> 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().task);
 
      // 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) {
      on_task_expired_(&task);
    }
  }
 
  // Sleep till the next task needs to be processed. If a new task comes
  // along, the wait will be resolved early because PostTask calls Wake().
  {
    TaskTimePoint next_wake;
    {
      std::lock_guard<std::mutex> lock(task_queue_mutex_);
      TaskTimePoint max_wake_timepoint =
          max_wait == std::chrono::nanoseconds::max() ? TaskTimePoint::max()
                                                      : now + max_wait;
      TaskTimePoint next_event_timepoint = task_queue_.empty()
                                               ? TaskTimePoint::max()
                                               : task_queue_.top().fire_time;
      next_wake = std::min(max_wake_timepoint, next_event_timepoint);
    }
    WaitUntil(next_wake);
  }
}

WaitUntil()

virtual void flutter::EventLoop::WaitUntil ( const TaskTimePoint &  time )

protectedpure virtual

Implemented in flutter::GLFWEventLoop, and flutter::HeadlessEventLoop.

Wake()

virtual void flutter::EventLoop::Wake ( )

protectedpure virtual

Implemented in flutter::GLFWEventLoop, and flutter::HeadlessEventLoop.

Member Data Documentation

main_thread_id_

std::thread::id flutter::EventLoop::main_thread_id_

protected

Definition at line 80 of file event_loop.h.

on_task_expired_

TaskExpiredCallback flutter::EventLoop::on_task_expired_

protected

Definition at line 81 of file event_loop.h.

task_queue_

std::priority_queue<Task, std::deque<Task>, Task::Comparer> flutter::EventLoop::task_queue_

protected

Definition at line 83 of file event_loop.h.

task_queue_mutex_

std::mutex flutter::EventLoop::task_queue_mutex_

protected

Definition at line 82 of file event_loop.h.

---

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

• shell/platform/glfw/event_loop.h
• shell/platform/glfw/event_loop.cc