--- a/dom/media/MediaEventSource.h
+++ b/dom/media/MediaEventSource.h
@@ -44,21 +44,21 @@ public:
     return mRevoked;
   }
 
 private:
   ~RevocableToken() {}
   Atomic<bool> mRevoked;
 };
 
-enum class ListenerMode : int8_t {
+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,
-  // This is the default. Event data will always be copied when passed
+  // Allow multiple listeners. Event data will always be copied when passed
   // to the listeners.
   NonExclusive
 };
 
 namespace detail {
 
 /**
  * Define how an event type is passed internally in MediaEventSource and to the
@@ -270,28 +270,28 @@ public:
   void Dispatch(As... aEvents) override {
     mHelper.Dispatch(Move(aEvents)...);
   }
 private:
   ListenerHelper<Target, Function> mHelper;
 };
 
 /**
- * Select EventPassMode based on ListenerMode.
+ * Select EventPassMode based on ListenerPolicy.
  *
- * @Copy Selected when ListenerMode is NonExclusive because each listener
+ * @Copy Selected when ListenerPolicy is NonExclusive because each listener
  * must get a copy.
  *
- * @Move Selected when ListenerMode is Exclusive. All types passed to
+ * @Move Selected when ListenerPolicy is Exclusive. All types passed to
  * MediaEventProducer::Notify() must be movable.
  */
-template <ListenerMode Mode>
+template <ListenerPolicy Lp>
 struct PassModePicker {
   static const EventPassMode Value =
-    Mode == ListenerMode::NonExclusive ?
+    Lp == ListenerPolicy::NonExclusive ?
     EventPassMode::Copy : EventPassMode::Move;
 };
 
 /**
  * Return true if any type is a reference type.
  */
 template <typename Head, typename... Tails>
 struct IsAnyReference {
@@ -301,26 +301,26 @@ struct IsAnyReference {
 
 template <typename T>
 struct IsAnyReference<T> {
   static const bool value = IsReference<T>::value;
 };
 
 } // namespace detail
 
-template <ListenerMode, typename... Ts> class MediaEventSourceImpl;
+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 <ListenerMode, typename... Ts>
+  template <ListenerPolicy, typename... Ts>
   friend class MediaEventSourceImpl;
 
 public:
   MediaEventListener() {}
 
   MediaEventListener(MediaEventListener&& aOther)
     : mToken(Move(aOther.mToken)) {}
 
@@ -350,41 +350,41 @@ private:
   // 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 <ListenerMode Mode, typename... Es>
+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;
 
   static const detail::EventPassMode PassMode =
-    detail::PassModePicker<Mode>::Value;
+    detail::PassModePicker<Lp>::Value;
 
   typedef detail::Listener<PassMode, ArgType<Es>...> Listener;
 
   template<typename Target, typename Func>
   using ListenerImpl =
     detail::ListenerImpl<Target, Func, PassMode, ArgType<Es>...>;
 
   template <typename Method>
   using TakeArgs = detail::TakeArgs<Method>;
 
   template<typename Target, typename Function>
   MediaEventListener
   ConnectInternal(Target* aTarget, const Function& aFunction) {
     MutexAutoLock lock(mMutex);
-    MOZ_ASSERT(Mode == ListenerMode::NonExclusive || mListeners.IsEmpty());
+    MOZ_ASSERT(Lp == ListenerPolicy::NonExclusive || mListeners.IsEmpty());
     auto l = mListeners.AppendElement();
     l->reset(new ListenerImpl<Target, Function>(aTarget, aFunction));
     return MediaEventListener((*l)->Token());
   }
 
   // |Method| takes one or more arguments.
   template <typename Target, typename This, typename Method>
   typename EnableIf<TakeArgs<Method>::value, MediaEventListener>::Type
@@ -471,21 +471,21 @@ protected:
 
 private:
   Mutex mMutex;
   nsTArray<UniquePtr<Listener>> mListeners;
 };
 
 template <typename... Es>
 using MediaEventSource =
-  MediaEventSourceImpl<ListenerMode::NonExclusive, Es...>;
+  MediaEventSourceImpl<ListenerPolicy::NonExclusive, Es...>;
 
 template <typename... Es>
 using MediaEventSourceExc =
-  MediaEventSourceImpl<ListenerMode::Exclusive, Es...>;
+  MediaEventSourceImpl<ListenerPolicy::Exclusive, 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...> {
@@ -504,17 +504,17 @@ template <>
 class MediaEventProducer<void> : public MediaEventSource<void> {
 public:
   void Notify() {
     this->NotifyInternal(true /* dummy */);
   }
 };
 
 /**
- * A producer with Exclusive mode.
+ * 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(Forward<Ts>(aEvents)...);
   }