flutter::VsyncWaiter Class Reference

#include <vsync_waiter.h>

Inheritance diagram for flutter::VsyncWaiter:

Public Types
using	Callback = std::function< void(std::unique_ptr< FrameTimingsRecorder >)>

Public Member Functions
virtual	~VsyncWaiter ()
void	AsyncWaitForVsync (const Callback &callback)
void	ScheduleSecondaryCallback (uintptr_t id, const fml::closure &callback)

Protected Member Functions
	VsyncWaiter (const TaskRunners &task_runners)
virtual void	AwaitVSync ()=0
virtual void	AwaitVSyncForSecondaryCallback ()
void	FireCallback (fml::TimePoint frame_start_time, fml::TimePoint frame_target_time, bool pause_secondary_tasks=true)

Protected Attributes
const TaskRunners	task_runners_

Friends
class	VsyncWaiterAndroid
class	VsyncWaiterEmbedder

Detailed Description

Abstract Base Class that represents a platform specific mechanism for getting callbacks when a vsync event happens.

See also

VsyncWaiterAndroid

VsyncWaiterEmbedder

Definition at line 24 of file vsync_waiter.h.

Member Typedef Documentation

Callback

using flutter::VsyncWaiter::Callback = std::function<void(std::unique_ptr<FrameTimingsRecorder>)>

Definition at line 26 of file vsync_waiter.h.

Constructor & Destructor Documentation

~VsyncWaiter()

flutter::VsyncWaiter::~VsyncWaiter ( )

virtualdefault

Reimplemented in flutter_runner::VsyncWaiter.

VsyncWaiter()

flutter::VsyncWaiter::VsyncWaiter ( const TaskRunners &  task_runners )

explicitprotected

Definition at line 21 of file vsync_waiter.cc.

    : task_runners_(task_runners) {}

Member Function Documentation

AsyncWaitForVsync()

void flutter::VsyncWaiter::AsyncWaitForVsync

(

const Callback &

callback

)

Definition at line 27 of file vsync_waiter.cc.

                                                            {
  if (!callback) {
    return;
  }
 
  TRACE_EVENT0("flutter", "AsyncWaitForVsync");
 
  {
    std::scoped_lock lock(callback_mutex_);
    if (callback_) {
      // The animator may request a frame more than once within a frame
      // interval. Multiple calls to request frame must result in a single
      // callback per frame interval.
      TRACE_EVENT_INSTANT0("flutter", "MultipleCallsToVsyncInFrameInterval");
      return;
    }
    callback_ = callback;
    if (!secondary_callbacks_.empty()) {
      // Return directly as `AwaitVSync` is already called by
      // `ScheduleSecondaryCallback`.
      return;
    }
  }
  AwaitVSync();
}

AwaitVSync()

virtual void flutter::VsyncWaiter::AwaitVSync ( )

protectedpure virtual

Implemented in flutter::testing::TestVsyncWaiter, flutter::testing::ShellTestVsyncWaiter, flutter::testing::ConstantFiringVsyncWaiter, and flutter::VsyncWaiterIOS.

AwaitVSyncForSecondaryCallback()

virtual void flutter::VsyncWaiter::AwaitVSyncForSecondaryCallback ( )

inlineprotectedvirtual

Definition at line 69 of file vsync_waiter.h.

{ AwaitVSync(); }

FireCallback()

void flutter::VsyncWaiter::FireCallback ( fml::TimePoint  frame_start_time, fml::TimePoint  frame_target_time, bool  pause_secondary_tasks = true  )

protected

Definition at line 87 of file vsync_waiter.cc.

                                                           {
  FML_DCHECK(fml::TimePoint::Now() >= frame_start_time);
 
  Callback callback;
  std::vector<fml::closure> secondary_callbacks;
 
  {
    std::scoped_lock lock(callback_mutex_);
    callback = std::move(callback_);
    for (auto& pair : secondary_callbacks_) {
      secondary_callbacks.push_back(std::move(pair.second));
    }
    secondary_callbacks_.clear();
  }
 
  if (!callback && secondary_callbacks.empty()) {
    // This means that the vsync waiter implementation fired a callback for a
    // request we did not make. This is a paranoid check but we still want to
    // make sure we catch misbehaving vsync implementations.
    TRACE_EVENT_INSTANT0("flutter", "MismatchedFrameCallback");
    return;
  }
 
  if (callback) {
    const uint64_t flow_identifier = fml::tracing::TraceNonce();
    if (pause_secondary_tasks) {
      PauseDartEventLoopTasks();
    }
 
    // The base trace ensures that flows have a root to begin from if one does
    // not exist. The trace viewer will ignore traces that have no base event
    // trace. While all our message loops insert a base trace trace
    // (MessageLoop::RunExpiredTasks), embedders may not.
    TRACE_EVENT0_WITH_FLOW_IDS("flutter", "VsyncFireCallback",
                               /*flow_id_count=*/1,
                               /*flow_ids=*/&flow_identifier);
 
    TRACE_FLOW_BEGIN("flutter", kVsyncFlowName, flow_identifier);
 
    fml::TaskQueueId ui_task_queue_id =
        task_runners_.GetUITaskRunner()->GetTaskQueueId();
 
    task_runners_.GetUITaskRunner()->PostTask(
        [ui_task_queue_id, callback, flow_identifier, frame_start_time,
         frame_target_time, pause_secondary_tasks]() {
          FML_TRACE_EVENT_WITH_FLOW_IDS(
              "flutter", kVsyncTraceName, /*flow_id_count=*/1,
              /*flow_ids=*/&flow_identifier, "StartTime", frame_start_time,
              "TargetTime", frame_target_time);
          std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder =
              std::make_unique<FrameTimingsRecorder>();
          frame_timings_recorder->RecordVsync(frame_start_time,
                                              frame_target_time);
          callback(std::move(frame_timings_recorder));
          TRACE_FLOW_END("flutter", kVsyncFlowName, flow_identifier);
          if (pause_secondary_tasks) {
            ResumeDartEventLoopTasks(ui_task_queue_id);
          }
        });
  }
 
  for (auto& secondary_callback : secondary_callbacks) {
    task_runners_.GetUITaskRunner()->PostTask(secondary_callback);
  }
}

ScheduleSecondaryCallback()

void flutter::VsyncWaiter::ScheduleSecondaryCallback	(	uintptr_t	id,
		const fml::closure &	callback
	)

Add a secondary callback for key |id| for the next vsync.

See also |PointerDataDispatcher::ScheduleSecondaryVsyncCallback| and |Animator::ScheduleMaybeClearTraceFlowIds|.

Definition at line 53 of file vsync_waiter.cc.

                                                                        {
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());
 
  if (!callback) {
    return;
  }
 
  TRACE_EVENT0("flutter", "ScheduleSecondaryCallback");
 
  {
    std::scoped_lock lock(callback_mutex_);
    bool secondary_callbacks_originally_empty = secondary_callbacks_.empty();
    auto [_, inserted] = secondary_callbacks_.emplace(id, callback);
    if (!inserted) {
      // Multiple schedules must result in a single callback per frame interval.
      TRACE_EVENT_INSTANT0("flutter",
                           "MultipleCallsToSecondaryVsyncInFrameInterval");
      return;
    }
    if (callback_) {
      // Return directly as `AwaitVSync` is already called by
      // `AsyncWaitForVsync`.
      return;
    }
    if (!secondary_callbacks_originally_empty) {
      // Return directly as `AwaitVSync` is already called by
      // `ScheduleSecondaryCallback`.
      return;
    }
  }
  AwaitVSyncForSecondaryCallback();
}

Friends And Related Function Documentation

VsyncWaiterAndroid

friend class VsyncWaiterAndroid

friend

Definition at line 41 of file vsync_waiter.h.

VsyncWaiterEmbedder

friend class VsyncWaiterEmbedder

friend

Definition at line 42 of file vsync_waiter.h.

Member Data Documentation

task_runners_

const TaskRunners flutter::VsyncWaiter::task_runners_

protected

Definition at line 44 of file vsync_waiter.h.

---

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

• shell/common/vsync_waiter.h
• shell/common/vsync_waiter.cc