/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef MediaEventSource_h_
#define MediaEventSource_h_

#include <type_traits>
#include <utility>

#include "mozilla/DataMutex.h"
#include "mozilla/Mutex.h"
#include "nsISupportsImpl.h"
#include "nsTArray.h"
#include "nsThreadUtils.h"

namespace mozilla {

/**
 * A thread-safe tool to communicate "revocation" across threads. It is used to
 * disconnect a listener from the event source to prevent future notifications
 * from coming. Revoke() can be called on any thread. However, it is recommended
 * to be called on the target thread to avoid race condition.
 *
 * RevocableToken is not exposed to the client code directly.
 * Use MediaEventListener below to do the job.
 */
class RevocableToken {
  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RevocableToken);

 public:
  RevocableToken() = default;

  virtual void Revoke() = 0;
  virtual bool IsRevoked() const = 0;

 protected:
  // Virtual destructor is required since we might delete a Listener object
  // through its base type pointer.
  virtual ~RevocableToken() = default;
};

enum class ListenerPolicy : int8_t {
  // Allow at most one listener. Move will be used when possible
  // to pass the event data to save copy.
  Exclusive,
  // Allow multiple listeners, which will be given thread-scoped refs of
  // the event data. For N targets/threads, this results in N-1 copies.
  OneCopyPerThread,
  // Allow multiple listeners, which will all be given a const& to the same
  // event data.
  NonExclusive
};

namespace detail {

/**
 * Define how an event type is passed internally in MediaEventSource and to the
 * listeners. Specialized for the void type to pass a dummy bool instead.
 */
template <typename T>
struct EventTypeTraits {
  typedef T ArgType;
};

template <>
struct EventTypeTraits<void> {
  typedef bool ArgType;
};

/**
 * Test if a method function or lambda accepts one or more arguments.
 */
template <typename T>
class TakeArgsHelper {
  template <typename C>
  static std::false_type test(void (C::*)(), int);
  template <typename C>
  static std::false_type test(void (C::*)() const, int);
  template <typename C>
  static std::false_type test(void (C::*)() volatile, int);
  template <typename C>
  static std::false_type test(void (C::*)() const volatile, int);
  template <typename F>
  static std::false_type test(F&&, decltype(std::declval<F>()(), 0));
  static std::true_type test(...);

 public:
  using type = decltype(test(std::declval<T>(), 0));
};

template <typename T>
struct TakeArgs : public TakeArgsHelper<T>::type {};

/**
 * Encapsulate a raw pointer to be captured by a lambda without causing
 * static-analysis errors.
 */
template <typename T>
class RawPtr {
 public:
  explicit RawPtr(T* aPtr) : mPtr(aPtr) {}
  T* get() const { return mPtr; }

 private:
  T* const mPtr;
};

// A list of listeners with some helper functions. Used to batch notifications
// for a single thread/target.
template <typename Listener>
class ListenerBatch {
 public:
  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ListenerBatch);

  explicit ListenerBatch(nsCOMPtr<nsIEventTarget>&& aTarget)
      : mTarget(std::move(aTarget)) {}

  bool MaybeAddListener(const RefPtr<Listener>& aListener) {
    auto target = aListener->GetTarget();
    // It does not matter what batch disconnected listeners go in.
    if (!target) {
      // It _also_ does not matter if we actually add a disconnected listener.
      // Pretend we did, but don't.
      return true;
    }
    if (target != mTarget) {
      return false;
    }
    mListeners.AppendElement(aListener);
    return true;
  }

  bool CanTakeArgs() const {
    for (auto& listener : mListeners) {
      if (listener->CanTakeArgs()) {
        return true;
      }
    }
    return false;
  }

  template <typename Storage>
  void ApplyWithArgsTuple(Storage&& aStorage) {
    std::apply(
        [&](auto&&... aArgs) mutable {
          for (auto& listener : mListeners) {
            if (listener->CanTakeArgs()) {
              listener->ApplyWithArgsImpl(
                  std::forward<decltype(aArgs)>(aArgs)...);
            } else {
              listener->ApplyWithNoArgs();
            }
          }
        },
        std::forward<Storage>(aStorage));
  }

  void ApplyWithNoArgs() {
    for (auto& listener : mListeners) {
      listener->ApplyWithNoArgs();
    }
  }

  void DispatchTask(already_AddRefed<nsIRunnable> aTask) {
    // Every listener might or might not have disconnected, so find the
    // first one that can actually perform the dispatch. If all of them are
    // disconnected, this is a no-op, which is fine.
    nsCOMPtr task = aTask;
    for (auto& listener : mListeners) {
      if (listener->TryDispatchTask(do_AddRef(task))) {
        return;
      }
    }
  }

  size_t Length() const { return mListeners.Length(); }

 private:
  ~ListenerBatch() = default;
  nsTArray<RefPtr<Listener>> mListeners;
  nsCOMPtr<nsIEventTarget> mTarget;
};

template <ListenerPolicy, typename Listener>
class NotificationPolicy;

template <typename Listener>
class NotificationPolicy<ListenerPolicy::Exclusive, Listener> {
 public:
  using ListenerBatch = typename detail::ListenerBatch<Listener>;

  template <typename... Ts>
  static void DispatchNotifications(
      const nsTArray<RefPtr<ListenerBatch>>& aListenerBatches,
      Ts&&... aEvents) {
    using Storage = std::tuple<std::decay_t<Ts>...>;
    // Should we let extra argless listeners slide?
    MOZ_ASSERT(aListenerBatches.Length() == 1);
    auto& batch = aListenerBatches[0];
    if (batch->CanTakeArgs()) {
      Storage storage(std::move(aEvents)...);
      batch->DispatchTask(NS_NewRunnableFunction(
          "ListenerBatch::DispatchTask(with args)",
          [batch, storage = std::move(storage)]() mutable {
            batch->ApplyWithArgsTuple(std::move(storage));
          }));
    } else {
      batch->DispatchTask(
          NewRunnableMethod("ListenerBatch::DispatchTask(without args)", batch,
                            &ListenerBatch::ApplyWithNoArgs));
    }
  }
};

template <typename Listener>
class NotificationPolicy<ListenerPolicy::OneCopyPerThread, Listener> {
 public:
  using ListenerBatch = typename detail::ListenerBatch<Listener>;

  template <typename... Ts>
  static void DispatchNotifications(
      const nsTArray<RefPtr<ListenerBatch>>& aListenerBatches,
      Ts&&... aEvents) {
    using Storage = std::tuple<std::decay_t<Ts>...>;

    // Find the last batch that takes args, and remember the index; that
    // batch will get the original copy (aEvents).
    Maybe<size_t> lastBatchWithArgs;
    for (size_t i = 0; i < aListenerBatches.Length(); ++i) {
      if (aListenerBatches[i]->CanTakeArgs()) {
        lastBatchWithArgs = Some(i);
      }
    }

    Storage storage(std::move(aEvents)...);
    for (size_t i = 0; i < aListenerBatches.Length(); ++i) {
      auto& batch = aListenerBatches[i];
      if (batch->CanTakeArgs()) {
        if (i != *lastBatchWithArgs) {
          // Copy |storage| into everything but the last args-taking dispatch
          batch->DispatchTask(
              NS_NewRunnableFunction("ListenerBatch::DispatchTask(with args)",
                                     [batch, storage]() mutable {
                                       batch->ApplyWithArgsTuple(storage);
                                     }));
        } else {
          // Move |storage| into the last args-taking dispatch
          batch->DispatchTask(NS_NewRunnableFunction(
              "ListenerBatch::DispatchTask(with args)",
              [batch, storage = std::move(storage)]() mutable {
                batch->ApplyWithArgsTuple(storage);
              }));
        }
      } else {
        batch->DispatchTask(
            NewRunnableMethod("ListenerBatch::DispatchTask(without args)",
                              batch, &ListenerBatch::ApplyWithNoArgs));
      }
    }
  }
};

template <typename Listener>
class NotificationPolicy<ListenerPolicy::NonExclusive, Listener> {
 public:
  using ListenerBatch = typename detail::ListenerBatch<Listener>;

  // This base class exists solely to keep the refcount logging code happy :(
  // It cannot handle templates inside the _THREADSAFE_REFCOUNTING macro
  // properly; it is all keyed off string matching, and that string would end
  // up being "SharedArgs<As>" verbatim, which is the same regardless of what
  // |As| is.
  class SharedArgsBase {
   public:
    NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SharedArgsBase);

   protected:
    virtual ~SharedArgsBase() = default;
  };
  template <typename... As>
  class SharedArgs : public SharedArgsBase {
   public:
    using Storage = std::tuple<std::decay_t<As>...>;
    explicit SharedArgs(As&&... aArgs) : mStorage(std::forward<As>(aArgs)...) {}
    // We should not ever be copying this, it is refcounted
    SharedArgs(const SharedArgs& aOrig) = delete;

    void ApplyWithArgs(ListenerBatch* aBatch) {
      aBatch->ApplyWithArgsTuple(mStorage);
    }

   private:
    const Storage mStorage;
  };

  template <typename... Ts>
  static void DispatchNotifications(
      const nsTArray<RefPtr<ListenerBatch>>& aListenerBatches,
      Ts&&... aEvents) {
    // Lazy initted when we see the first args-taking batch
    RefPtr<SharedArgs<Ts...>> args;

    for (auto& batch : aListenerBatches) {
      if (batch->CanTakeArgs()) {
        if (!args) {
          // Lazy init
          args = MakeRefPtr<SharedArgs<Ts...>>(std::forward<Ts>(aEvents)...);
        }
        batch->DispatchTask(NewRunnableMethod<RefPtr<ListenerBatch>>(
            "ListenerBatch::DispatchTask(with args)", args,
            &SharedArgs<Ts...>::ApplyWithArgs, batch));
      } else {
        batch->DispatchTask(
            NewRunnableMethod("ListenerBatch::DispatchTask(without args)",
                              batch, &ListenerBatch::ApplyWithNoArgs));
      }
    }
  }
};

// Bottom-level base class for Listeners. Declares virtual functions that are
// always present, regardless of template parameters. This is where we handle
// the fact that different listeners have different targets, and even different
// ways of dispatching to those targets.
class ListenerBase : public RevocableToken {
 public:
  virtual bool TryDispatchTask(already_AddRefed<nsIRunnable> aTask) = 0;

  // True if the underlying listener function takes non-zero arguments.
  virtual bool CanTakeArgs() const = 0;
  // Invoke the underlying listener function. Should be called only when
  // CanTakeArgs() returns false.
  virtual void ApplyWithNoArgs() = 0;

  virtual nsCOMPtr<nsIEventTarget> GetTarget() const = 0;
};

// This is where we handle the fact that listeners will typically have
// different function signatures on their callbacks, and also the fact that
// different policies require different function signatures when perfect
// forwarding.
// We cannot simply have a single virtual ApplyWithArgs function in our
// superclass, because it is not possible to have a templated virtual function,
// and the policies all have different params that are passed (eg; NonExclusive
// passes const refs, which is not compatible with passing by rvalue ref or
// non-const lvalue ref)
template <ListenerPolicy, typename...>
class Listener;

template <typename... As>
class Listener<ListenerPolicy::Exclusive, As...> : public ListenerBase {
 public:
  virtual void ApplyWithArgsImpl(As&&... aEvents) = 0;
};

template <typename... As>
class Listener<ListenerPolicy::OneCopyPerThread, As...> : public ListenerBase {
 public:
  virtual void ApplyWithArgsImpl(As&... aEvents) = 0;
};

template <typename... As>
class Listener<ListenerPolicy::NonExclusive, As...> : public ListenerBase {
 public:
  virtual void ApplyWithArgsImpl(const As&... aEvents) = 0;
};

/**
 * Store the registered event target and function so it knows where and to
 * whom to send the event data.
 * The only way to make the existence of a virtual function override contingent
 * on a template parameter is to use template specialization. So, this
 * implements everything but ApplyWithArgs, which will be handled by yet
 * another subclass.
 */
template <ListenerPolicy Policy, typename Function, typename... As>
class ListenerImpl : public Listener<Policy, As...> {
  // Strip CV and reference from Function.
  using FunctionStorage = std::decay_t<Function>;
  using SelfType = ListenerImpl<Policy, Function, As...>;

 public:
  ListenerImpl(nsCOMPtr<nsIEventTarget>&& aTarget, Function&& aFunction)
      : mData(MakeRefPtr<Data>(std::move(aTarget),
                               std::forward<Function>(aFunction)),
              "MediaEvent ListenerImpl::mData") {}

 protected:
  virtual ~ListenerImpl() {
    MOZ_ASSERT(IsRevoked(), "Must disconnect the listener.");
  }

  nsCOMPtr<nsIEventTarget> GetTarget() const override {
    auto d = mData.Lock();
    if (d.ref()) {
      return d.ref()->mTarget;
    }
    return nullptr;
  }

  bool TryDispatchTask(already_AddRefed<nsIRunnable> aTask) override {
    nsCOMPtr task = aTask;
    RefPtr<Data> data;
    {
      auto d = mData.Lock();
      data = *d;
    }
    if (!data) {
      return false;
    }
    data->mTarget->Dispatch(task.forget());
    return true;
  }

  bool CanTakeArgs() const override { return TakeArgs<FunctionStorage>::value; }

  template <typename... Ts>
  void ApplyWithArgs(Ts&&... aEvents) {
    if constexpr (TakeArgs<Function>::value) {
      // Don't call the listener if it is disconnected.
      RefPtr<Data> data;
      {
        auto d = mData.Lock();
        data = *d;
      }
      if (!data) {
        return;
      }
      MOZ_DIAGNOSTIC_ASSERT(data->mTarget->IsOnCurrentThread());
      data->mFunction(std::forward<Ts>(aEvents)...);
    } else {
      MOZ_CRASH(
          "Don't use ApplyWithArgsImpl on listeners that don't take args! Use "
          "ApplyWithNoArgsImpl instead.");
    }
  }

  // |F| takes no arguments.
  void ApplyWithNoArgs() override {
    if constexpr (!TakeArgs<Function>::value) {
      // Don't call the listener if it is disconnected.
      RefPtr<Data> data;
      {
        auto d = mData.Lock();
        data = *d;
      }
      if (!data) {
        return;
      }
      MOZ_DIAGNOSTIC_ASSERT(data->mTarget->IsOnCurrentThread());
      data->mFunction();
    } else {
      MOZ_CRASH(
          "Don't use ApplyWithNoArgsImpl on listeners that take args! Use "
          "ApplyWithArgsImpl instead.");
    }
  }

  void Revoke() override {
    {
      auto data = mData.Lock();
      *data = nullptr;
    }
  }

  bool IsRevoked() const override {
    auto data = mData.Lock();
    return !*data;
  }

  struct RefCountedMediaEventListenerData {
    // Keep ref-counting here since Data holds a template member, leading to
    // instances of varying size, which the memory leak logging system dislikes.
    NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RefCountedMediaEventListenerData)
   protected:
    virtual ~RefCountedMediaEventListenerData() = default;
  };
  struct Data : public RefCountedMediaEventListenerData {
    Data(nsCOMPtr<nsIEventTarget>&& aTarget, Function&& aFunction)
        : mTarget(std::move(aTarget)),
          mFunction(std::forward<Function>(aFunction)) {
      MOZ_DIAGNOSTIC_ASSERT(mTarget);
    }
    const nsCOMPtr<nsIEventTarget> mTarget;
    FunctionStorage mFunction;
  };

  // Storage for target and function. Also used to track revocation.
  mutable DataMutex<RefPtr<Data>> mData;
};

// We're finally at the end of the class hierarchy. The implementation code
// within ApplyWithArgs is a one-liner that is mostly identical for all
// policies; this could have all been a single template function if these
// weren't virtual functions.
template <ListenerPolicy, typename, typename...>
class ListenerImplFinal;

template <typename Function, typename... As>
class ListenerImplFinal<ListenerPolicy::Exclusive, Function, As...> final
    : public ListenerImpl<ListenerPolicy::Exclusive, Function, As...> {
 public:
  using BaseType = ListenerImpl<ListenerPolicy::Exclusive, Function, As...>;
  ListenerImplFinal(nsIEventTarget* aTarget, Function&& aFunction)
      : BaseType(aTarget, std::forward<Function>(aFunction)) {}

  void ApplyWithArgsImpl(As&&... aEvents) override {
    BaseType::ApplyWithArgs(std::move(aEvents)...);
  }
};

template <typename Function, typename... As>
class ListenerImplFinal<ListenerPolicy::OneCopyPerThread, Function, As...> final
    : public ListenerImpl<ListenerPolicy::OneCopyPerThread, Function, As...> {
 public:
  using BaseType =
      ListenerImpl<ListenerPolicy::OneCopyPerThread, Function, As...>;
  ListenerImplFinal(nsIEventTarget* aTarget, Function&& aFunction)
      : BaseType(aTarget, std::forward<Function>(aFunction)) {}

  void ApplyWithArgsImpl(As&... aEvents) override {
    BaseType::ApplyWithArgs(aEvents...);
  }
};

template <typename Function, typename... As>
class ListenerImplFinal<ListenerPolicy::NonExclusive, Function, As...> final
    : public ListenerImpl<ListenerPolicy::NonExclusive, Function, As...> {
 public:
  using BaseType = ListenerImpl<ListenerPolicy::NonExclusive, Function, As...>;
  ListenerImplFinal(nsIEventTarget* aTarget, Function&& aFunction)
      : BaseType(aTarget, std::forward<Function>(aFunction)) {}

  void ApplyWithArgsImpl(const As&... aEvents) override {
    BaseType::ApplyWithArgs(aEvents...);
  }
};

/**
 * Return true if any type is a reference type.
 */
template <typename Head, typename... Tails>
struct IsAnyReference {
  static const bool value =
      std::is_reference_v<Head> || IsAnyReference<Tails...>::value;
};

template <typename T>
struct IsAnyReference<T> {
  static const bool value = std::is_reference_v<T>;
};

}  // namespace detail

template <ListenerPolicy, typename... Ts>
class MediaEventSourceImpl;

/**
 * Not thread-safe since this is not meant to be shared and therefore only
 * move constructor is provided. Used to hold the result of
 * MediaEventSource<T>::Connect() and call Disconnect() to disconnect the
 * listener from an event source.
 */
class MediaEventListener {
  template <ListenerPolicy, typename... Ts>
  friend class MediaEventSourceImpl;

 public:
  MediaEventListener() = default;

  MediaEventListener(MediaEventListener&& aOther)
      : mToken(std::move(aOther.mToken)) {}

  MediaEventListener& operator=(MediaEventListener&& aOther) {
    MOZ_ASSERT(!mToken, "Must disconnect the listener.");
    mToken = std::move(aOther.mToken);
    return *this;
  }

  ~MediaEventListener() {
    MOZ_ASSERT(!mToken, "Must disconnect the listener.");
  }

  void Disconnect() {
    mToken->Revoke();
    mToken = nullptr;
  }

  void DisconnectIfExists() {
    if (mToken) {
      Disconnect();
    }
  }

 private:
  // Avoid exposing RevocableToken directly to the client code so that
  // listeners can be disconnected in a controlled manner.
  explicit MediaEventListener(RevocableToken* aToken) : mToken(aToken) {}
  RefPtr<RevocableToken> mToken;
};

/**
 * A generic and thread-safe class to implement the observer pattern.
 */
template <ListenerPolicy Lp, typename... Es>
class MediaEventSourceImpl {
  static_assert(!detail::IsAnyReference<Es...>::value,
                "Ref-type not supported!");

  template <typename T>
  using ArgType = typename detail::EventTypeTraits<T>::ArgType;

  using Listener = detail::Listener<Lp, ArgType<Es>...>;

  template <typename Func>
  using ListenerImpl = detail::ListenerImplFinal<Lp, Func, ArgType<Es>...>;

  using ListenerBatch = typename detail::ListenerBatch<Listener>;

  template <typename Method>
  using TakeArgs = detail::TakeArgs<Method>;

  void PruneListeners() {
    mListeners.RemoveElementsBy(
        [](const auto& listener) { return listener->IsRevoked(); });
  }

  template <typename Function>
  MediaEventListener ConnectInternal(nsIEventTarget* aTarget,
                                     Function&& aFunction) {
    MutexAutoLock lock(mMutex);
    PruneListeners();
    MOZ_ASSERT(Lp != ListenerPolicy::Exclusive || mListeners.IsEmpty());
    auto l = mListeners.AppendElement();
    *l = new ListenerImpl<Function>(aTarget, std::forward<Function>(aFunction));
    return MediaEventListener(*l);
  }

 public:
  /**
   * Register a function to receive notifications from the event source.
   *
   * @param aTarget The event target on which the function will run.
   * @param aFunction A function to be called on the target thread. The function
   *                  parameter must be convertible from |EventType|.
   * @return An object used to disconnect from the event source.
   */
  template <typename Function>
  MediaEventListener Connect(nsIEventTarget* aTarget, Function&& aFunction) {
    return ConnectInternal(aTarget, std::forward<Function>(aFunction));
  }

  /**
   * As above.
   *
   * Note we deliberately keep a weak reference to |aThis| in order not to
   * change its lifetime. This is because notifications are dispatched
   * asynchronously and removing a listener doesn't always break the reference
   * cycle for the pending event could still hold a reference to |aThis|.
   *
   * The caller must call MediaEventListener::Disconnect() to avoid dangling
   * pointers.
   */
  template <typename This, typename Method>
  MediaEventListener Connect(nsIEventTarget* aTarget, This* aThis,
                             Method aMethod) {
    if constexpr (TakeArgs<Method>::value) {
      detail::RawPtr<This> thiz(aThis);
      if constexpr (Lp == ListenerPolicy::Exclusive) {
        return ConnectInternal(aTarget, [=](ArgType<Es>&&... aEvents) {
          (thiz.get()->*aMethod)(std::move(aEvents)...);
        });
      } else if constexpr (Lp == ListenerPolicy::OneCopyPerThread) {
        return ConnectInternal(aTarget, [=](ArgType<Es>&... aEvents) {
          (thiz.get()->*aMethod)(aEvents...);
        });
      } else if constexpr (Lp == ListenerPolicy::NonExclusive) {
        return ConnectInternal(aTarget, [=](const ArgType<Es>&... aEvents) {
          (thiz.get()->*aMethod)(aEvents...);
        });
      }
    } else {
      detail::RawPtr<This> thiz(aThis);
      return ConnectInternal(aTarget, [=]() { (thiz.get()->*aMethod)(); });
    }
  }

 protected:
  MediaEventSourceImpl() : mMutex("MediaEventSourceImpl::mMutex") {}

  template <typename... Ts>
  void NotifyInternal(Ts&&... aEvents) {
    MutexAutoLock lock(mMutex);
    nsTArray<RefPtr<ListenerBatch>> listenerBatches;
    for (size_t i = 0; i < mListeners.Length();) {
      auto& l = mListeners[i];
      // Remove disconnected listeners.
      // It is not optimal but is simple and works well.
      nsCOMPtr<nsIEventTarget> target = l->GetTarget();
      if (!target) {
        mListeners.RemoveElementAt(i);
        continue;
      }

      ++i;

      // Find a batch (or create one) for this listener's target, and add the
      // listener to it.
      bool added = false;
      for (auto& batch : listenerBatches) {
        if (batch->MaybeAddListener(l)) {
          added = true;
          break;
        }
      }

      if (!added) {
        // The listener might not have a target anymore, but we still place it
        // in a Batch with the target we observed up top.
        listenerBatches.AppendElement(new ListenerBatch(nsCOMPtr(target)));
        (void)listenerBatches.LastElement()->MaybeAddListener(l);
      }
    }

    if (listenerBatches.Length()) {
      detail::NotificationPolicy<Lp, Listener>::DispatchNotifications(
          listenerBatches, std::forward<Ts>(aEvents)...);
    }
  }

  using Listeners = nsTArray<RefPtr<Listener>>;

 private:
  Mutex mMutex MOZ_UNANNOTATED;
  nsTArray<RefPtr<Listener>> mListeners;
};

template <typename... Es>
using MediaEventSource =
    MediaEventSourceImpl<ListenerPolicy::NonExclusive, Es...>;

template <typename... Es>
using MediaEventSourceExc =
    MediaEventSourceImpl<ListenerPolicy::Exclusive, Es...>;

template <typename... Es>
using MediaEventSourceOneCopyPerThread =
    MediaEventSourceImpl<ListenerPolicy::OneCopyPerThread, Es...>;

/**
 * A class to separate the interface of event subject (MediaEventSource)
 * and event publisher. Mostly used as a member variable to publish events
 * to the listeners.
 */
template <typename... Es>
class MediaEventProducer : public MediaEventSource<Es...> {
 public:
  template <typename... Ts>
  void Notify(Ts&&... aEvents) {
    this->NotifyInternal(std::forward<Ts>(aEvents)...);
  }
};

/**
 * Specialization for void type. A dummy bool is passed to NotifyInternal
 * since there is no way to pass a void value.
 */
template <>
class MediaEventProducer<void> : public MediaEventSource<void> {
 public:
  void Notify() { this->NotifyInternal(true /* dummy */); }
};

/**
 * A producer allowing at most one listener.
 */
template <typename... Es>
class MediaEventProducerExc : public MediaEventSourceExc<Es...> {
 public:
  template <typename... Ts>
  void Notify(Ts&&... aEvents) {
    this->NotifyInternal(std::forward<Ts>(aEvents)...);
  }
};

template <typename... Es>
class MediaEventProducerOneCopyPerThread
    : public MediaEventSourceOneCopyPerThread<Es...> {
 public:
  template <typename... Ts>
  void Notify(Ts&&... aEvents) {
    this->NotifyInternal(std::forward<Ts>(aEvents)...);
  }
};

/**
 * A class that facilitates forwarding MediaEvents from multiple sources of the
 * same type into a single source.
 *
 * Lifetimes are convenient. A forwarded source is disconnected either by
 * the source itself going away, or the forwarder being destroyed.
 *
 * Not threadsafe. The caller is responsible for calling Forward() in a
 * threadsafe manner.
 */
template <typename... Es>
class MediaEventForwarder : public MediaEventSource<Es...> {
 public:
  template <typename T>
  using ArgType = typename detail::EventTypeTraits<T>::ArgType;

  explicit MediaEventForwarder(nsCOMPtr<nsISerialEventTarget> aEventTarget)
      : mEventTarget(std::move(aEventTarget)) {}

  MediaEventForwarder(MediaEventForwarder&& aOther)
      : mEventTarget(aOther.mEventTarget),
        mListeners(std::move(aOther.mListeners)) {}

  ~MediaEventForwarder() { MOZ_ASSERT(mListeners.IsEmpty()); }

  MediaEventForwarder& operator=(MediaEventForwarder&& aOther) {
    MOZ_RELEASE_ASSERT(mEventTarget == aOther.mEventTarget);
    MOZ_ASSERT(mListeners.IsEmpty());
    mListeners = std::move(aOther.mListeners);
  }

  void Forward(MediaEventSource<Es...>& aSource) {
    // Forwarding a rawptr `this` here is fine, since DisconnectAll disconnect
    // all mListeners synchronously and prevents this handler from running.
    mListeners.AppendElement(
        aSource.Connect(mEventTarget, [this](const ArgType<Es>&... aEvents) {
          this->NotifyInternal(aEvents...);
        }));
  }

  template <typename Function>
  void ForwardIf(MediaEventSource<Es...>& aSource, Function&& aFunction) {
    // Forwarding a rawptr `this` here is fine, since DisconnectAll disconnect
    // all mListeners synchronously and prevents this handler from running.
    mListeners.AppendElement(aSource.Connect(
        mEventTarget, [this, func = aFunction](const ArgType<Es>&... aEvents) {
          if (!func()) {
            return;
          }
          this->NotifyInternal(aEvents...);
        }));
  }

  void DisconnectAll() {
    for (auto& l : mListeners) {
      l.Disconnect();
    }
    mListeners.Clear();
  }

 private:
  const nsCOMPtr<nsISerialEventTarget> mEventTarget;
  nsTArray<MediaEventListener> mListeners;
};

}  // namespace mozilla

#endif  // MediaEventSource_h_