fl_task_runner.cc File Reference

#include "flutter/shell/platform/linux/fl_task_runner.h"
#include "flutter/shell/platform/linux/fl_engine_private.h"

Go to the source code of this file.

Classes
struct	_FlTaskRunner
struct	_FlTaskRunnerTask

Typedefs
typedef struct _FlTaskRunnerTask	FlTaskRunnerTask

Functions
static void	fl_task_runner_process_expired_tasks_locked (FlTaskRunner *self)
static void	fl_task_runner_tasks_did_change_locked (FlTaskRunner *self)
static gboolean	fl_task_runner_on_expired_timeout (gpointer data)
static gint64	fl_task_runner_next_task_expiration_time_locked (FlTaskRunner *self)
void	fl_task_runner_dispose (GObject *object)
static void	fl_task_runner_class_init (FlTaskRunnerClass *klass)
static void	fl_task_runner_init (FlTaskRunner *self)
FlTaskRunner *	fl_task_runner_new (FlEngine *engine)
void	fl_task_runner_post_flutter_task (FlTaskRunner *self, FlutterTask task, uint64_t target_time_nanos)
void	fl_task_runner_post_callback (FlTaskRunner *self, void(*callback)(gpointer data), gpointer data)
void	fl_task_runner_block_main_thread (FlTaskRunner *self)
void	fl_task_runner_release_main_thread (FlTaskRunner *self)

Variables
static constexpr int	kMicrosecondsPerNanosecond = 1000
static constexpr int	kMillisecondsPerMicrosecond = 1000

Typedef Documentation

FlTaskRunnerTask

typedef struct _FlTaskRunnerTask FlTaskRunnerTask

Function Documentation

fl_task_runner_block_main_thread()

void fl_task_runner_block_main_thread

(

FlTaskRunner *

task_runner

)

fl_task_runner_block_main_thread: @task_runner: an #FlTaskRunner.

Blocks main thread until fl_task_runner_release_main_thread is called. While main thread is blocked tasks posted to #FlTaskRunner are executed as usual. Must be invoked on main thread.

Definition at line 203 of file fl_task_runner.cc.

                                                          {
  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->mutex);
  (void)locker;  // unused variable
 
  g_return_if_fail(self->blocking_main_thread == FALSE);
 
  g_object_ref(self);
 
  self->blocking_main_thread = true;
  while (self->blocking_main_thread) {
    g_cond_wait_until(&self->cond, &self->mutex,
                      fl_task_runner_next_task_expiration_time_locked(self));
    fl_task_runner_process_expired_tasks_locked(self);
  }
 
  // Tasks might have changed in the meanwhile, reschedule timeout
  fl_task_runner_tasks_did_change_locked(self);
 
  g_object_unref(self);
}

References fl_task_runner_next_task_expiration_time_locked(), fl_task_runner_process_expired_tasks_locked(), and fl_task_runner_tasks_did_change_locked().

Referenced by fl_compositor_opengl_wait_for_frame().

fl_task_runner_class_init()

static void fl_task_runner_class_init ( FlTaskRunnerClass *  klass )

static

Definition at line 158 of file fl_task_runner.cc.

                                                                {
  G_OBJECT_CLASS(klass)->dispose = fl_task_runner_dispose;
}

References fl_task_runner_dispose().

fl_task_runner_dispose()

void fl_task_runner_dispose

(

GObject *

object

)

Definition at line 139 of file fl_task_runner.cc.

                                             {
  FlTaskRunner* self = FL_TASK_RUNNER(object);
 
  // this should never happen because the task runner is retained while blocking
  // main thread
  g_assert(!self->blocking_main_thread);
 
  g_weak_ref_clear(&self->engine);
  g_mutex_clear(&self->mutex);
  g_cond_clear(&self->cond);
 
  g_list_free_full(self->pending_tasks, g_free);
  if (self->timeout_source_id != 0) {
    g_source_remove(self->timeout_source_id);
  }
 
  G_OBJECT_CLASS(fl_task_runner_parent_class)->dispose(object);
}

Referenced by fl_task_runner_class_init().

fl_task_runner_init()

static void fl_task_runner_init ( FlTaskRunner *  self )

static

Definition at line 162 of file fl_task_runner.cc.

                                                    {
  g_mutex_init(&self->mutex);
  g_cond_init(&self->cond);
}

fl_task_runner_new()

FlTaskRunner* fl_task_runner_new

(

FlEngine *

engine

)

fl_task_runner_new: @engine: the #FlEngine owning the task runner.

Creates new task runner instance.

Returns: an #FlTaskRunner.

Definition at line 167 of file fl_task_runner.cc.

                                                   {
  FlTaskRunner* self =
      FL_TASK_RUNNER(g_object_new(fl_task_runner_get_type(), nullptr));
  g_weak_ref_init(&self->engine, G_OBJECT(engine));
  return self;
}

Referenced by fl_engine_init().

fl_task_runner_next_task_expiration_time_locked()

static gint64 fl_task_runner_next_task_expiration_time_locked ( FlTaskRunner *  self )

static

Definition at line 107 of file fl_task_runner.cc.

                        {
  gint64 min_time = G_MAXINT64;
  GList* l = self->pending_tasks;
  while (l != nullptr) {
    FlTaskRunnerTask* task = static_cast<FlTaskRunnerTask*>(l->data);
    min_time = MIN(min_time, task->task_time_micros);
    l = l->next;
  }
  return min_time;
}

References _FlTaskRunnerTask::task_time_micros.

Referenced by fl_task_runner_block_main_thread(), and fl_task_runner_tasks_did_change_locked().

fl_task_runner_on_expired_timeout()

static gboolean fl_task_runner_on_expired_timeout ( gpointer  data )

static

Definition at line 86 of file fl_task_runner.cc.

                                                                 {
  FlTaskRunner* self = FL_TASK_RUNNER(data);
 
  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->mutex);
  (void)locker;  // unused variable
 
  g_object_ref(self);
 
  self->timeout_source_id = 0;
  fl_task_runner_process_expired_tasks_locked(self);
 
  // reschedule timeout
  fl_task_runner_tasks_did_change_locked(self);
 
  g_object_unref(self);
 
  return FALSE;
}

References fl_task_runner_process_expired_tasks_locked(), and fl_task_runner_tasks_did_change_locked().

Referenced by fl_task_runner_tasks_did_change_locked().

fl_task_runner_post_callback()

void fl_task_runner_post_callback	(	FlTaskRunner *	task_runner,
		void(*)(gpointer data)	callback,
		gpointer	data
	)

fl_task_runner_post_callback: @task_runner: an #FlTaskRunner. @callback: callback to be scheduled @data: data to be passed to the callback

Schedules arbitrary callback to be executed on main thread. The callback will be executed in next run loop turn. This function is thread safe and may be called from any thread.

Definition at line 189 of file fl_task_runner.cc.

                                                 {
  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->mutex);
  (void)locker;  // unused variable
 
  FlTaskRunnerTask* runner_task = g_new0(FlTaskRunnerTask, 1);
  runner_task->callback = callback;
  runner_task->callback_data = data;
 
  self->pending_tasks = g_list_append(self->pending_tasks, runner_task);
  fl_task_runner_tasks_did_change_locked(self);
}

References _FlTaskRunnerTask::callback, _FlTaskRunnerTask::callback_data, and fl_task_runner_tasks_did_change_locked().

Referenced by fl_compositor_opengl_present_layers().

fl_task_runner_post_flutter_task()

void fl_task_runner_post_flutter_task	(	FlTaskRunner *	task_runner,
		FlutterTask	task,
		uint64_t	target_time_nanos
	)

fl_task_runner_post_flutter_task: @task_runner: an #FlTaskRunner. @task: Flutter task being scheduled @target_time_nanos: absolute time in nanoseconds

Posts a Flutter task to be executed on main thread. This function is thread safe and may be called from any thread.

Definition at line 174 of file fl_task_runner.cc.

                                                                  {
  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->mutex);
  (void)locker;  // unused variable
 
  FlTaskRunnerTask* runner_task = g_new0(FlTaskRunnerTask, 1);
  runner_task->task = task;
  runner_task->task_time_micros =
      target_time_nanos / kMicrosecondsPerNanosecond;
 
  self->pending_tasks = g_list_append(self->pending_tasks, runner_task);
  fl_task_runner_tasks_did_change_locked(self);
}

References fl_task_runner_tasks_did_change_locked(), kMicrosecondsPerNanosecond, _FlTaskRunnerTask::task, and _FlTaskRunnerTask::task_time_micros.

Referenced by fl_engine_post_task().

fl_task_runner_process_expired_tasks_locked()

static void fl_task_runner_process_expired_tasks_locked ( FlTaskRunner *  self )

static

Definition at line 43 of file fl_task_runner.cc.

                                                                            {
  GList* expired_tasks = nullptr;
 
  gint64 current_time = g_get_monotonic_time();
 
  GList* l = self->pending_tasks;
  while (l != nullptr) {
    FlTaskRunnerTask* task = static_cast<FlTaskRunnerTask*>(l->data);
    if (task->task_time_micros <= current_time) {
      GList* link = l;
      l = l->next;
      self->pending_tasks = g_list_remove_link(self->pending_tasks, link);
      expired_tasks = g_list_concat(expired_tasks, link);
    } else {
      l = l->next;
    }
  }
 
  g_mutex_unlock(&self->mutex);
 
  g_autoptr(FlEngine) engine = FL_ENGINE(g_weak_ref_get(&self->engine));
  if (engine != nullptr) {
    l = expired_tasks;
    while (l != nullptr) {
      FlTaskRunnerTask* task = static_cast<FlTaskRunnerTask*>(l->data);
      if (task->callback != nullptr) {
        task->callback(task->callback_data);
      } else {
        fl_engine_execute_task(engine, &task->task);
      }
      l = l->next;
    }
  }
 
  g_list_free_full(expired_tasks, g_free);
 
  g_mutex_lock(&self->mutex);
}

References _FlTaskRunnerTask::callback, _FlTaskRunnerTask::callback_data, fl_engine_execute_task(), _FlTaskRunnerTask::task, and _FlTaskRunnerTask::task_time_micros.

Referenced by fl_task_runner_block_main_thread(), and fl_task_runner_on_expired_timeout().

fl_task_runner_release_main_thread()

void fl_task_runner_release_main_thread

(

FlTaskRunner *

self

)

fl_task_runner_release_main_thread: @task_runner: an #FlTaskRunner.

Unblocks main thread. This will resume normal processing of main loop. Can be invoked from any thread.

Definition at line 224 of file fl_task_runner.cc.

                                                            {
  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->mutex);
  (void)locker;  // unused variable
 
  g_return_if_fail(self->blocking_main_thread == TRUE);
 
  self->blocking_main_thread = FALSE;
  g_cond_signal(&self->cond);
}

References TRUE.

Referenced by fl_compositor_opengl_unblock_main_thread().

fl_task_runner_tasks_did_change_locked()

static void fl_task_runner_tasks_did_change_locked ( FlTaskRunner *  self )

static

Definition at line 119 of file fl_task_runner.cc.

                                                                       {
  if (self->blocking_main_thread) {
    // Wake up blocked thread
    g_cond_signal(&self->cond);
  } else {
    // Reschedule timeout
    if (self->timeout_source_id != 0) {
      g_source_remove(self->timeout_source_id);
      self->timeout_source_id = 0;
    }
    gint64 min_time = fl_task_runner_next_task_expiration_time_locked(self);
    if (min_time != G_MAXINT64) {
      gint64 remaining = MAX(min_time - g_get_monotonic_time(), 0);
      self->timeout_source_id =
          g_timeout_add(remaining / kMillisecondsPerMicrosecond + 1,
                        fl_task_runner_on_expired_timeout, self);
    }
  }
}

References fl_task_runner_next_task_expiration_time_locked(), fl_task_runner_on_expired_timeout(), and kMillisecondsPerMicrosecond.

Referenced by fl_task_runner_block_main_thread(), fl_task_runner_on_expired_timeout(), fl_task_runner_post_callback(), and fl_task_runner_post_flutter_task().

Variable Documentation

kMicrosecondsPerNanosecond

constexpr int kMicrosecondsPerNanosecond = 1000

staticconstexpr

Definition at line 8 of file fl_task_runner.cc.

Referenced by fl_task_runner_post_flutter_task().

kMillisecondsPerMicrosecond

constexpr int kMillisecondsPerMicrosecond = 1000

staticconstexpr

Definition at line 9 of file fl_task_runner.cc.

Referenced by fl_task_runner_tasks_did_change_locked().