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_wait (FlTaskRunner *self)
void	fl_task_runner_stop_wait (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_class_init()

static void fl_task_runner_class_init ( FlTaskRunnerClass *  klass )

static

Definition at line 138 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 123 of file fl_task_runner.cc.

                                             {
  FlTaskRunner* self = FL_TASK_RUNNER(object);
 
  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 142 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 147 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(), and TEST().

fl_task_runner_next_task_expiration_time_locked()

static gint64 fl_task_runner_next_task_expiration_time_locked ( FlTaskRunner *  self )

static

Definition at line 96 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_tasks_did_change_locked(), and fl_task_runner_wait().

fl_task_runner_on_expired_timeout()

static gboolean fl_task_runner_on_expired_timeout ( gpointer  data )

static

Definition at line 75 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(), fl_task_runner_tasks_did_change_locked(), and g_autoptr().

Referenced by fl_task_runner_tasks_did_change_locked().

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 154 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);
 
  // Tasks changed, so wake up anything blocking in fl_task_runner_wait.
  g_cond_signal(&self->cond);
}

References fl_task_runner_tasks_did_change_locked(), g_autoptr(), 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 36 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);
      fl_engine_execute_task(engine, &task->task);
      l = l->next;
    }
  }
 
  g_list_free_full(expired_tasks, g_free);
 
  g_mutex_lock(&self->mutex);
}

References fl_engine_execute_task(), g_autoptr(), _FlTaskRunnerTask::task, and _FlTaskRunnerTask::task_time_micros.

Referenced by fl_task_runner_on_expired_timeout(), and fl_task_runner_wait().

fl_task_runner_stop_wait()

void fl_task_runner_stop_wait

(

FlTaskRunner *

self

)

fl_task_runner_stop_wait: @task_runner: an #FlTaskRunner.

Cause fl_task_runner_wait() to complete. May be called even if fl_task_runner_wait() is not being used.

May be called by any thread.

Definition at line 182 of file fl_task_runner.cc.

                                                  {
  g_cond_signal(&self->cond);
}

fl_task_runner_tasks_did_change_locked()

static void fl_task_runner_tasks_did_change_locked ( FlTaskRunner *  self )

static

Definition at line 108 of file fl_task_runner.cc.

                                                                       {
  // 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_on_expired_timeout(), fl_task_runner_post_flutter_task(), and fl_task_runner_wait().

fl_task_runner_wait()

void fl_task_runner_wait

(

FlTaskRunner *

task_runner

)

fl_task_runner_wait: @task_runner: an #FlTaskRunner.

Block until the next task is ready and then perform it. May be interrupted by fl_task_runner_stop_wait(), in which case no task is run but execution will be returned to the caller.

Must be called only by the GTK thread.

Definition at line 172 of file fl_task_runner.cc.

                                             {
  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->mutex);
  (void)locker;  // unused variable
 
  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);
  fl_task_runner_tasks_did_change_locked(self);
}

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

Referenced by fl_compositor_opengl_render(), and fl_compositor_software_render().

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().