// Copyright 2017 The Fuchsia 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 <trace/observer.h>

#include <zircon/assert.h>

namespace trace {

TraceObserver::TraceObserver() {
}

TraceObserver::~TraceObserver() {
    Stop();
}

void TraceObserver::Start(async_t* async, fbl::Closure callback) {
    ZX_DEBUG_ASSERT(async);
    ZX_DEBUG_ASSERT(callback);

    Stop();
    callback_ = fbl::move(callback);

    zx_status_t status = zx::event::create(0u, &event_);
    ZX_ASSERT(status == ZX_OK);
    trace_register_observer(event_.get());

    wait_.set_object(event_.get());
    wait_.set_trigger(ZX_EVENT_SIGNALED);
    BeginWait(async);
}

void TraceObserver::Stop() {
    wait_.Cancel();
    callback_ = nullptr;

    if (event_) {
        trace_unregister_observer(event_.get());
        event_.reset();
    }
}

void TraceObserver::Handle(async_t* async, async::WaitBase* wait, zx_status_t status,
                           const zx_packet_signal_t* signal) {
    if (status != ZX_OK) {
        Stop();
        return;
    }

    ZX_DEBUG_ASSERT(status == ZX_OK);
    ZX_DEBUG_ASSERT(signal->observed & ZX_EVENT_SIGNALED);

    // Clear the signal otherwise we'll keep getting called.
    // Clear the signal *before* invoking the callback because there's no
    // synchronization between the engine and the observers, thus it's possible
    // that an observer could get back to back notifications.
    event_.signal(ZX_EVENT_SIGNALED, 0u);

    // Invoke the callback.
    callback_();

    // Tell engine we're done.
    trace_notify_observer_updated(event_.get());

    // Wait again!
    BeginWait(async);
}

void TraceObserver::BeginWait(async_t* async) {
    zx_status_t status = wait_.Begin(async);
    if (status != ZX_OK)
        Stop();
}

} // namespace trace