blob: 772fd10992e96f531ebf165ab12819138453e25e [file] [log] [blame]
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/synchronization/waitable_event_watcher.h"
#include "base/bind.h"
#include "base/callback.h"
#include "base/threading/sequenced_task_runner_handle.h"
namespace base {
WaitableEventWatcher::WaitableEventWatcher() : weak_ptr_factory_(this) {}
WaitableEventWatcher::~WaitableEventWatcher() {
bool WaitableEventWatcher::StartWatching(
WaitableEvent* event,
EventCallback callback,
scoped_refptr<SequencedTaskRunner> task_runner) {
DCHECK(!source_ || dispatch_source_testcancel(source_));
// Keep a reference to the receive right, so that if the event is deleted
// out from under the watcher, a signal can still be observed.
receive_right_ = event->receive_right_;
callback_ = BindOnce(std::move(callback), event);
// Locals for capture by the block. Accessing anything through the |this| or
// |event| pointers is not safe, since either may have been deleted by the
// time the handler block is invoked.
WeakPtr<WaitableEventWatcher> weak_this = weak_ptr_factory_.GetWeakPtr();
const bool auto_reset =
event->policy_ == WaitableEvent::ResetPolicy::AUTOMATIC;
// Auto-reset events always use a dispatch source. Manual-reset events
// only do so if dispatch provides reliable delivery, otherwise a manual
// watcher list is used.
if (!WaitableEvent::UseSlowWatchList(event->policy_)) {
// Use the global concurrent queue here, since it is only used to thunk
// to the real callback on the target task runner.
DISPATCH_SOURCE_TYPE_MACH_RECV, receive_right_->Name(), 0,
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)));
// Additional locals for block capture.
dispatch_source_t source = source_.get();
mach_port_t name = receive_right_->Name();
dispatch_source_set_event_handler(source_, ^{
// For automatic-reset events, only fire the callback if this watcher
// can claim/dequeue the event. For manual-reset events, all watchers can
// be called back.
if (auto_reset && !WaitableEvent::PeekPort(name, true)) {
// The event has been consumed. A watcher is one-shot, so cancel the
// source to prevent receiving future event signals.
BindOnce(&WaitableEventWatcher::InvokeCallback, weak_this));
} else {
// The |event->watch_list_| closures can be run from any thread, so bind
// the callback as an invocation of PostTask.
OnceClosure watcher =
BindOnce(IgnoreResult(&TaskRunner::PostTask), task_runner, FROM_HERE,
BindOnce(&WaitableEventWatcher::InvokeCallback, weak_this));
// Hold an additional reference to the ReceiveRight, in case |watcher|
// runs and deletes the event while the lock is held.
// Hold the lock for the duration of IsSignaled() so that if Signal()
// is called by another thread, it waits for this to be added to the
// watch list.
scoped_refptr<WaitableEvent::ReceiveRight> receive_right(receive_right_);
AutoLock lock(receive_right->SlowWatchList()->lock);
if (event->IsSignaled()) {
return true;
return true;
void WaitableEventWatcher::StopWatching() {
receive_right_ = nullptr;
if (source_) {
void WaitableEventWatcher::InvokeCallback() {
// The callback can be null if StopWatching() is called between signaling
// and the |callback_| getting run on the target task runner.
if (callback_.is_null())
receive_right_ = nullptr;
} // namespace base