fml::MessageLoopFuchsia Class Reference

#include <message_loop_fuchsia.h>

Inheritance diagram for fml::MessageLoopFuchsia:

Private Member Functions
	~MessageLoopFuchsia () override
void	Run () override
void	Terminate () override
void	WakeUp (fml::TimePoint time_point) override

Additional Inherited Members
Public Member Functions inherited from fml::MessageLoopImpl
virtual	~MessageLoopImpl ()
void	PostTask (const fml::closure &task, fml::TimePoint target_time)
void	AddTaskObserver (intptr_t key, const fml::closure &callback)
void	RemoveTaskObserver (intptr_t key)
void	DoRun ()
void	DoTerminate ()
virtual TaskQueueId	GetTaskQueueId () const
Public Member Functions inherited from fml::Wakeable
virtual	~Wakeable ()
Public Member Functions inherited from fml::RefCountedThreadSafe< MessageLoopImpl >
void	Release () const
Public Member Functions inherited from fml::internal::RefCountedThreadSafeBase
void	AddRef () const
bool	HasOneRef () const
void	AssertHasOneRef () const
Static Public Member Functions inherited from fml::MessageLoopImpl
static fml::RefPtr< MessageLoopImpl >	Create ()
Protected Member Functions inherited from fml::MessageLoopImpl
void	RunExpiredTasksNow ()
void	RunSingleExpiredTaskNow ()
	MessageLoopImpl ()
Protected Member Functions inherited from fml::RefCountedThreadSafe< MessageLoopImpl >
	RefCountedThreadSafe ()
	~RefCountedThreadSafe ()
Protected Member Functions inherited from fml::internal::RefCountedThreadSafeBase
	RefCountedThreadSafeBase ()
	~RefCountedThreadSafeBase ()
bool	Release () const
void	Adopt ()

Detailed Description

Definition at line 17 of file message_loop_fuchsia.h.

Member Function Documentation

Run()

void fml::MessageLoopFuchsia::Run ( )

overrideprivatevirtual

Implements fml::MessageLoopImpl.

Definition at line 49 of file message_loop_fuchsia.cc.

                             {
  timer_wait_ = std::make_unique<async::Wait>(
      timer_.get(), ZX_TIMER_SIGNALED, 0,
      [this](async_dispatcher_t* dispatcher, async::Wait* wait,
             zx_status_t status, const zx_packet_signal_t* signal) {
        if (status == ZX_ERR_CANCELED) {
          return;
        }
        FML_CHECK(signal->observed & ZX_TIMER_SIGNALED);
 
        // Cancel the timer now, because `RunExpiredTasksNow` might not re-arm
        // the timer.  That would leave the timer in a signalled state and it
        // would trigger the async::Wait again immediately, creating a busy
        // loop.
        //
        // NOTE: It is not neccesary to synchronize this with the timer_.set()
        // call below, even though WakeUp() can be called from any thread and
        // thus timer_.set() can run in parallel with this timer_.cancel().
        //
        // Zircon will synchronize the 2 syscalls internally, and the Wait loop
        // here is resilient to cancel() and set() being called in any order.
        timer_.cancel();
 
        // Run the tasks, which may or may not re-arm the timer for the future.
        RunExpiredTasksNow();
 
        // Kick off the next iteration of the timer wait loop.
        zx_status_t wait_status = wait->Begin(loop_.dispatcher());
        FML_CHECK(wait_status == ZX_OK)
            << "MessageLoopFuchsia::WakeUp failed to wait for timer; status="
            << zx_status_get_string(wait_status);
      });
 
  // Kick off the first iteration of the timer wait loop.
  zx_status_t wait_status = timer_wait_->Begin(loop_.dispatcher());
  FML_CHECK(wait_status == ZX_OK)
      << "MessageLoopFuchsia::WakeUp failed to wait for timer; status="
      << zx_status_get_string(wait_status);
 
  // Kick off the underlying async loop that services the timer wait in addition
  // to other tasks and waits queued on its `async_dispatcher_t`.
  loop_.Run();
 
  // Ensure any pending waits on the timer are properly canceled.
  if (timer_wait_->is_pending()) {
    timer_wait_->Cancel();
    timer_.cancel();
  }
}

Terminate()

void fml::MessageLoopFuchsia::Terminate ( )

overrideprivatevirtual

Implements fml::MessageLoopImpl.

Definition at line 99 of file message_loop_fuchsia.cc.

                                   {
  loop_.Quit();
}

WakeUp()

void fml::MessageLoopFuchsia::WakeUp ( fml::TimePoint  time_point )

overrideprivatevirtual

Implements fml::Wakeable.

Definition at line 103 of file message_loop_fuchsia.cc.

                                                       {
  constexpr zx::duration kZeroSlack(0);
  zx::time due_time(time_point.ToEpochDelta().ToNanoseconds());
 
  zx_status_t timer_status = timer_.set(due_time, kZeroSlack);
  FML_CHECK(timer_status == ZX_OK)
      << "MessageLoopFuchsia::WakeUp failed to set timer; status="
      << zx_status_get_string(timer_status);
}

~MessageLoopFuchsia()

fml::MessageLoopFuchsia::~MessageLoopFuchsia ( )

overrideprivate

Definition at line 41 of file message_loop_fuchsia.cc.

                                        {
  // It is only safe to unset the current thread's default dispatcher if it is
  // already pointing to this loop.
  if (async_get_default_dispatcher() == loop_.dispatcher()) {
    async_set_default_dispatcher(nullptr);
  }
}

---

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

• fml/platform/fuchsia/message_loop_fuchsia.h
• fml/platform/fuchsia/message_loop_fuchsia.cc